use super::*;
use crate::loader::pef::PefResolvedImport;
// Low-level allocator tests borrow adapter fields independently. Keep the
// cursor canonical by publishing the temporary value when each call ends.
macro_rules! test_heap_cursor {
($app:ident) => {
&mut *$app.process_memory_manager.heap_cursor_mut()
};
}
macro_rules! test_handles {
($app:ident) => {
&mut *$app.process_memory_manager.handles_mut()
};
}
macro_rules! test_handle_records {
($app:ident) => {
$app.process_memory_manager.handles()
};
}
// Read the canonical heap limit through the disjoint manager field.
macro_rules! test_heap_limit {
($app:ident) => {
$app.process_memory_manager.heap_limit($app.stack_base)
};
}
macro_rules! with_test_screen_clut {
($app:ident, |$screen:ident| $body:expr) => {{
let screen_clut = $app.screen_clut.shared_handle();
screen_clut.with_mut(|$screen| $body)
}};
}
macro_rules! with_test_color_manager_clut {
($app:ident, |$logical:ident| $body:expr) => {{
let color_manager_clut = $app.color_manager_clut.shared_handle();
color_manager_clut.with_mut(|$logical| $body)
}};
}
macro_rules! with_test_display_cluts {
($app:ident, |$screen:ident, $logical:ident| $body:expr) => {{
let screen_clut = $app.screen_clut.shared_handle();
let color_manager_clut = $app.color_manager_clut.shared_handle();
screen_clut.with_mut(|$screen| {
color_manager_clut.with_mut(|$logical| $body)
})
}};
}
macro_rules! with_test_controls {
($app:ident, |$controls:ident| $body:expr) => {{
let controls = $app.controls.shared_handle();
controls.with_mut(|$controls| $body)
}};
}
use crate::cpu::{CpuOps, Register};
use crate::managers::resource::serialize_resource_fork;
use crate::memory::MemoryBus;
use crate::trap::test_helpers::{setup_with_port, MockCpu, TEST_SP};
use ppc::PpcMemory;
fn test_q3_object(object: u32, object_type: u32) -> PpcQ3ObjectRecord {
PpcQ3ObjectRecord {
object,
kind: PpcQ3ObjectKind::Generic,
object_type,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
}
}
fn run_test_import(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
drain_test_m68k_guest_calls(loaded);
}
fn create_test_cwindow(
loaded: &mut PpcLoadedApp,
bounds_ptr: u32,
bounds: (i16, i16, i16, i16),
proc_id: i16,
visible: bool,
behind: u32,
) -> u32 {
ppc_write_rect(&mut loaded.memory, bounds_ptr, bounds.0, bounds.1, bounds.2, bounds.3)
.unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = u32::from(visible);
loaded.cpu.gpr[7] = proc_id as u16 as u32;
loaded.cpu.gpr[8] = behind;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
run_test_import(loaded, PpcImportDispatcherTarget::NewCWindow);
let window = loaded.cpu.gpr[3];
assert_ne!(window, 0, "test NewCWindow must succeed");
window
}
fn initialize_test_cgraf_port(bus: &mut MacMemoryBus, port: u32) {
bus.write_word(port + 6, 0xc000);
for offset in [36, 38, 40] {
bus.write_word(port + offset, 0);
}
for offset in [42, 44, 46] {
bus.write_word(port + offset, u16::MAX);
}
bus.write_word(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET, 1);
bus.write_word(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2, 1);
bus.write_word(port + PPC_CGRAF_PORT_PN_MODE_OFFSET, PPC_QD_PEN_MODE_PAT_COPY as u16);
bus.write_word(
port + PPC_CGRAF_PORT_TX_MODE_OFFSET,
PPC_QD_TEXT_MODE_SRC_OR as u16,
);
bus.write_word(
port + PPC_CGRAF_PORT_TX_SIZE_OFFSET,
PPC_QD_TEXT_SIZE_SYSTEM as u16,
);
}
fn run_test_import_with_process_memory_manager(
loaded: &mut PpcLoadedApp,
target: PpcImportDispatcherTarget,
memory_manager: &SharedProcessMemoryManager,
) {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_process_memory_manager(
64,
false,
false,
&mut memory_manager.borrow_mut(),
);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
drain_test_m68k_guest_calls(loaded);
}
fn attach_test_classic_heap(
native: &mut PpcLoadedApp,
context: &mut ProcessContext,
ram_size: usize,
heap_len: usize,
) -> MacMemoryBus {
let mut classic_bus = MacMemoryBus::new(ram_size);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, heap_len as u32)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
classic_bus
}
fn drain_test_m68k_guest_calls(loaded: &mut PpcLoadedApp) {
while let Some(pending) = loaded.guest_calls()
.active_m68k()
.or_else(|| loaded.guest_calls().activate_m68k())
{
let mut cpu = m68k::CpuCore::new();
cpu.set_cpu_type(REFERENCE_MACHINE_PROFILE.cpu_type());
cpu.pc = pending.entry;
cpu.set_a(7, pending.initial_sp);
for (index, value) in pending.registers.data.into_iter().enumerate() {
cpu.set_d(index, value);
}
for (index, value) in pending.registers.address.into_iter().enumerate() {
cpu.set_a(index, value);
}
let result = cpu.run_batch(&mut loaded.memory, 4096, &[pending.return_pc]);
assert_eq!(
result.exit,
m68k::BatchExit::WatchedPc {
pc: pending.return_pc
},
"entry=${:08X} pc=${:08X} sp=${:08X} return=${:08X}",
pending.entry,
cpu.pc,
cpu.a(7),
pending.return_pc,
);
let result = match pending.result {
None => None,
Some(crate::guest_call::M68kResultSource::Data(index)) => {
Some(cpu.d(usize::from(index)))
}
Some(crate::guest_call::M68kResultSource::Address(index)) => {
Some(cpu.a(usize::from(index)))
}
Some(crate::guest_call::M68kResultSource::Memory { address, size }) => {
Some(match size {
1 => u32::from(loaded.memory.read_u8(address).unwrap()),
2 => u32::from(loaded.memory.read_u16_be(address).unwrap()),
4 => loaded.memory.read_u32_be(address).unwrap(),
_ => panic!("unsupported 68k result size {size}"),
})
}
Some(crate::guest_call::M68kResultSource::SpecialCase { selector, .. }) => {
panic!("special-case result selector {selector} requires the shared runner")
}
};
assert!(loaded
.toolbox_startup
.execution
.calls()
.complete_m68k_operation_for_powerpc(
cpu.pc,
cpu.a(7),
result,
&mut loaded.cpu,
&mut loaded.memory,
loaded.process_memory_manager.0.borrow_mut().native_mut(),
));
if loaded.cpu.pc == PPC_GUEST_CALL_RETURN_PC
|| (loaded.cpu.pc >= loaded.import_trap_base
&& loaded.cpu.pc
< loaded
.import_trap_base
.saturating_add(loaded.import_count.saturating_mul(4)))
{
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
}
}
}
fn test_menu_resource(menu_id: i16, title: &[u8]) -> Vec<u8> {
test_menu_resource_with_mdef(menu_id, 0, title)
}
fn test_menu_resource_with_mdef(menu_id: i16, mdef_id: i16, title: &[u8]) -> Vec<u8> {
let mut data = vec![0; 14];
data[0..2].copy_from_slice(&menu_id.to_be_bytes());
data[6..8].copy_from_slice(&mdef_id.to_be_bytes());
data[10..14].copy_from_slice(&u32::MAX.to_be_bytes());
data.push(title.len() as u8);
data.extend_from_slice(title);
data.push(0);
data
}
fn test_menu_color_entry(menu_id: i16, item: i16, seed: u8) -> [u8; 30] {
let mut entry = [seed; 30];
entry[0..2].copy_from_slice(&menu_id.to_be_bytes());
entry[2..4].copy_from_slice(&item.to_be_bytes());
entry
}
fn test_menu_color_resource(entries: &[[u8; 30]]) -> Vec<u8> {
let mut data = i16::try_from(entries.len()).unwrap().to_be_bytes().to_vec();
for entry in entries {
data.extend_from_slice(entry);
}
data
}
fn install_test_menu(
loaded: &mut PpcLoadedApp,
scratch: u32,
menu_id: i16,
title: &[u8],
item_specs: &[u8],
) -> u32 {
let mut free_handle_blocks = loaded.free_handle_blocks();
loaded.memory.add_region(scratch, vec![0; 0x200]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, scratch, title));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x80,
item_specs,
));
let menu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu_id,
scratch,
);
assert_ne!(menu, 0);
if !item_specs.is_empty() {
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu,
scratch + 0x80,
i16::MAX,
),
PPC_NO_ERR,
);
}
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
0,
),
PPC_NO_ERR,
);
menu
}
fn install_test_popup_menu(
loaded: &mut PpcLoadedApp,
scratch: u32,
menu_id: i16,
title: &[u8],
item_specs: &[u8],
) -> u32 {
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu = install_test_menu(loaded, scratch, menu_id, title, item_specs);
let current_menu_list = ppc_current_menu_list(&mut loaded.memory);
assert_eq!(
ppc_delete_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
current_menu_list,
menu_id,
),
PPC_NO_ERR,
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
-1,
),
PPC_NO_ERR,
);
menu
}
fn draw_current_test_menu_bar(loaded: &mut PpcLoadedApp) -> bool {
let menu_list = ppc_current_menu_list(&mut loaded.memory);
let menu_color_bytes =
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded));
ppc_draw_menu_bar_with_colors(
&mut loaded.memory,
&loaded.gworlds,
menu_list,
&loaded.screen_clut,
MenuColorTable::new(&menu_color_bytes),
)
}
pub(crate) struct CrossAbiMenuSelectFixture {
pub(crate) app: PpcLoadedApp,
pub(crate) root_menu: u32,
pub(crate) root_record: u32,
pub(crate) mdef_entry: u32,
pub(crate) callback_marker: u32,
pub(crate) title_h: i16,
}
pub(crate) fn cross_abi_menu_select_fixture() -> CrossAbiMenuSelectFixture {
const ROOT_MENU_ID: i16 = 140;
const CHILD_MENU_ID: i16 = 141;
const TARGET_ITEM: i16 = 2;
const MDEF_HANDLE: u32 = PPC_DATA_BASE + 0x7000;
const MDEF_ENTRY: u32 = PPC_DATA_BASE + 0x7100;
const CALLBACK_MARKER: u32 = PPC_DATA_BASE + 0x7200;
const CALLBACK_VALUE: u32 = 0x68c0_ab1e;
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let root_menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
ROOT_MENU_ID,
b"File",
b"Custom child;Disabled after callback",
);
let child_menu = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1400,
CHILD_MENU_ID,
b"Child",
b"Choice",
);
loaded.cpu.gpr[3] = root_menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x1b;
ppc_set_item_cmd(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
);
loaded.cpu.gpr[5] = CHILD_MENU_ID as u32;
ppc_set_item_mark(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
);
let root_record = loaded.memory.read_u32_be(root_menu).unwrap();
let child_record = loaded.memory.read_u32_be(child_menu).unwrap();
loaded.memory.write_u16_be(child_record + 2, 72).unwrap();
loaded.memory.write_u16_be(child_record + 4, 32).unwrap();
loaded.memory.add_region(MDEF_HANDLE, vec![0; 4]);
loaded.memory.add_region(CALLBACK_MARKER, vec![0; 4]);
// The resource-backed MDEF is real 68k guest code. It pushes the
// Pascal DisableItem(rootMenu, 2) arguments, executes the A-line, then
// leaves a marker only after the trap returns and closes its own
// 18-byte MenuDefProc argument frame.
let mut mdef = Vec::new();
mdef.extend_from_slice(&0x2f3cu16.to_be_bytes()); // MOVE.L #rootMenu,-(SP)
mdef.extend_from_slice(&root_menu.to_be_bytes());
mdef.extend_from_slice(&0x3f3cu16.to_be_bytes()); // MOVE.W #2,-(SP)
mdef.extend_from_slice(&(TARGET_ITEM as u16).to_be_bytes());
mdef.extend_from_slice(&0xa93au16.to_be_bytes()); // DisableItem
mdef.extend_from_slice(&0x23fcu16.to_be_bytes()); // MOVE.L #value,marker
mdef.extend_from_slice(&CALLBACK_VALUE.to_be_bytes());
mdef.extend_from_slice(&CALLBACK_MARKER.to_be_bytes());
mdef.extend_from_slice(&0x4e74u16.to_be_bytes()); // RTD #18
mdef.extend_from_slice(&0x0012u16.to_be_bytes());
loaded.memory.add_region(MDEF_ENTRY, mdef.clone());
loaded.memory.write_u32_be(MDEF_HANDLE, MDEF_ENTRY).unwrap();
loaded
.memory
.write_u32_be(child_record + 6, MDEF_HANDLE)
.unwrap();
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Cross-ABI menu fixture".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 512,
name: Vec::new(),
data: mdef,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: MDEF_HANDLE,
});
assert!(draw_current_test_menu_bar(&mut loaded));
let title_h = STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2;
loaded.cpu.gpr[3] = (u32::from(10u16) << 16) | u32::from(title_h as u16);
CrossAbiMenuSelectFixture {
app: loaded,
root_menu,
root_record,
mdef_entry: MDEF_ENTRY,
callback_marker: CALLBACK_MARKER,
title_h,
}
}
fn test_wind_resource(
bounds: (i16, i16, i16, i16),
proc_id: i16,
visible: bool,
go_away: bool,
ref_con: u32,
title: &[u8],
) -> Vec<u8> {
let mut wind = Vec::with_capacity(19 + title.len());
for coordinate in [bounds.0, bounds.1, bounds.2, bounds.3] {
wind.extend_from_slice(&coordinate.to_be_bytes());
}
wind.extend_from_slice(&proc_id.to_be_bytes());
wind.extend_from_slice(&u16::from(visible).to_be_bytes());
wind.extend_from_slice(&u16::from(go_away).to_be_bytes());
wind.extend_from_slice(&ref_con.to_be_bytes());
wind.push(u8::try_from(title.len()).unwrap());
wind.extend_from_slice(title);
wind
}
#[test]
fn ppc_watch_parser_accepts_hex_address_and_optional_length() {
assert_eq!(
parse_ppc_watch_range_value(std::ffi::OsStr::new("0x02000000")),
Some(PpcWatchRange {
start: 0x0200_0000,
len: 1
})
);
assert_eq!(
parse_ppc_watch_range_value(std::ffi::OsStr::new("$02000000:4")),
Some(PpcWatchRange {
start: 0x0200_0000,
len: 4
})
);
assert_eq!(
parse_ppc_watch_range_value(std::ffi::OsStr::new("02000000:0x10")),
Some(PpcWatchRange {
start: 0x0200_0000,
len: 16
})
);
}
#[test]
fn ppc_watch_parser_rejects_empty_zero_and_overflow_ranges() {
assert_eq!(parse_ppc_watch_range_value(std::ffi::OsStr::new("")), None);
assert_eq!(
parse_ppc_watch_range_value(std::ffi::OsStr::new("02000000:0")),
None
);
assert_eq!(
parse_ppc_watch_range_value(std::ffi::OsStr::new("FFFFFFFF:2")),
None
);
assert_eq!(
parse_ppc_watch_range_value(std::ffi::OsStr::new("02000000:4:extra")),
None
);
}
#[test]
fn ppc_watch_range_contains_only_selected_bytes() {
let range = PpcWatchRange {
start: 0x0200_0002,
len: 3,
};
assert!(!range.contains(0x0200_0001));
assert!(range.contains(0x0200_0002));
assert!(range.contains(0x0200_0004));
assert!(!range.contains(0x0200_0005));
}
#[test]
fn ppc_watch_formatter_includes_context_and_written_byte() {
let line = format_ppc_watch_write(PpcWatchWriteRecord {
pc: 0x0100_0004,
lr: 0x0100_0010,
rtoc: 0x0200_0000,
sp: 0x03fe_ffc0,
addr: 0x0200_0002,
value: 0xaa,
});
assert_eq!(
line,
"[PPC-WATCH] pc=$01000004 lr=$01000010 rtoc=$02000000 sp=$03FEFFC0 addr=$02000002 value=$AA"
);
}
#[test]
fn ppc_trace_fetch_formatter_includes_pc_and_instruction_word() {
assert_eq!(
format_ppc_trace_fetch(0x0100_0004, 0x4e80_0020),
"[PPC-TRACE] fetch pc=$01000004 word=$4E800020"
);
}
#[test]
fn ppc_trace_import_formatter_includes_import_and_context() {
let entry = PpcHleImportTraceEntry {
import_index: 12,
library_name: "InterfaceLib".to_string(),
symbol_name: "NewPtrClear".to_string(),
pc: 0x01f0_0030,
lr: 0x0100_0010,
rtoc: 0x0200_0000,
sp: 0x03fe_ffc0,
dispatcher_target: PpcImportDispatcherTarget::NewPtr { clear: true },
repeat_count: 1,
};
assert_eq!(
format_ppc_trace_import(&entry),
"[PPC-TRACE] import #12 InterfaceLib:NewPtrClear pc=$01F00030 lr=$01000010 rtoc=$02000000 sp=$03FEFFC0 target=NewPtr { clear: true }"
);
assert_eq!(
format_ppc_trace_unknown_import(13, 0x01f0_0034, 0x0100_0020, 0x0200_0004, 0x03fe_ffb0),
"[PPC-TRACE] import #13 <unknown> pc=$01F00034 lr=$01000020 rtoc=$02000004 sp=$03FEFFB0"
);
}
#[test]
fn marathon_runtime_imports_have_native_dispatch_targets() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "EventAvail"),
PpcImportDispatcherTarget::EventAvail
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBControlSync"),
PpcImportDispatcherTarget::PBControl
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HandToHand"),
PpcImportDispatcherTarget::HandToHand
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetEntries"),
PpcImportDispatcherTarget::SetEntries
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "RestoreEntries"),
PpcImportDispatcherTarget::RestoreEntries
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "MakeITable"),
PpcImportDispatcherTarget::MakeITable
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "QDError"),
PpcImportDispatcherTarget::QDError
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "RGB2HSL"),
PpcImportDispatcherTarget::RGB2HSL
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "RGB2HSV"),
PpcImportDispatcherTarget::RGB2HSV
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HSV2RGB"),
PpcImportDispatcherTarget::HSV2RGB
);
assert_eq!(
dispatcher_target_for_import("AppearanceLib", "MenuEvent"),
PpcImportDispatcherTarget::MenuEvent
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "TEUseStyleScrap"),
PpcImportDispatcherTarget::TEUseStyleScrap
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FixRatio"),
PpcImportDispatcherTarget::FixRatio
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FixMul"),
PpcImportDispatcherTarget::FixMul
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "Long2Fix"),
PpcImportDispatcherTarget::Long2Fix
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "CountMItems"),
PpcImportDispatcherTarget::CountMItems
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetItemCmd"),
PpcImportDispatcherTarget::SetItemCmd
);
}
#[test]
fn event_avail_peeks_without_consuming_matching_event() {
let queue = VecDeque::from([PpcQueuedEvent {
what: 3,
message: 0x0000_4120,
when: 0,
where_v: 120,
where_h: 240,
modifiers: 0x0080,
}]);
let event = ppc_peek_event(&queue, 1 << 3, PpcInputSnapshot::default(), false, 7);
assert_eq!(event, (3, 0x0000_4120, 0, 120, 240, 0x0080, true));
assert_eq!(queue.len(), 1);
}
#[test]
fn os_event_accessors_skip_toolbox_and_high_level_events() {
let mut queue = VecDeque::from([
PpcQueuedEvent {
what: 6,
message: 0x1000,
when: 0,
where_v: 10,
where_h: 20,
modifiers: 0,
},
PpcQueuedEvent {
what: 23,
message: PPC_CORE_EVENT_CLASS,
when: 0,
where_v: 0,
where_h: 0,
modifiers: 0,
},
PpcQueuedEvent {
what: 3,
message: 0x0000_4120,
when: 0,
where_v: 120,
where_h: 240,
modifiers: 0x0080,
},
]);
// Macintosh Toolbox Essentials (1992), pp. 2-97--2-99:
// GetOSEvent and OSEventAvail return only low-level events from the
// Operating System event queue, never update or high-level events.
let event =
ppc_dequeue_event(&mut queue, u16::MAX, PpcInputSnapshot::default(), true, 7);
assert_eq!(event, (3, 0x0000_4120, 0, 120, 240, 0x0080, true));
assert_eq!(queue.len(), 2);
assert_eq!(queue[0].what, 6);
assert_eq!(queue[1].what, 23);
assert_eq!(
ppc_peek_event(&queue, u16::MAX, PpcInputSnapshot::default(), true, 7),
(0, 0, 7, 0, 0, 0, false)
);
}
#[test]
fn toolbox_event_accessors_apply_documented_event_priority() {
let mut queue = VecDeque::from([
PpcQueuedEvent {
what: 6,
message: 0x1000,
when: 0,
where_v: 10,
where_h: 20,
modifiers: 0,
},
PpcQueuedEvent {
what: 23,
message: PPC_CORE_EVENT_CLASS,
when: 0,
where_v: 0,
where_h: 0,
modifiers: 0,
},
PpcQueuedEvent {
what: 1,
message: 0,
when: 0,
where_v: 120,
where_h: 240,
modifiers: 0,
},
PpcQueuedEvent {
what: 8,
message: 0x2000,
when: 0,
where_v: 10,
where_h: 20,
modifiers: 1,
},
]);
let event =
ppc_dequeue_event(&mut queue, u16::MAX, PpcInputSnapshot::default(), false, 7);
assert_eq!(event.0, 8, "activate events have highest priority");
let event =
ppc_dequeue_event(&mut queue, u16::MAX, PpcInputSnapshot::default(), false, 7);
assert_eq!(event.0, 1, "user input precedes update events");
let event =
ppc_dequeue_event(&mut queue, u16::MAX, PpcInputSnapshot::default(), false, 7);
assert_eq!(event.0, 6, "update events precede high-level events");
assert_eq!(queue.front().map(|event| event.what), Some(23));
}
#[test]
fn front_window_transition_coalesces_pending_activation_pair() {
let mut memory = PpcSectionMem::new();
memory.add_region(0, vec![0; 0x1000]);
let mut queue = VecDeque::new();
ppc_enqueue_window_activation_transition(
&mut memory,
&mut queue,
Some(0x1000),
Some(0x2000),
41,
);
ppc_enqueue_window_activation_transition(
&mut memory,
&mut queue,
Some(0x2000),
Some(0x3000),
42,
);
assert_eq!(queue.len(), 2);
assert_eq!(queue[0].what, 8);
assert_eq!(queue[0].message, 0x2000);
assert_eq!(queue[0].when, 42);
assert_eq!(queue[0].modifiers & 1, 0);
assert_eq!(queue[1].what, 8);
assert_eq!(queue[1].message, 0x3000);
assert_eq!(queue[1].when, 42);
assert_eq!(queue[1].modifiers & 1, 1);
assert_eq!(memory.read_u32_be(0x0A68), Some(0x2000));
assert_eq!(memory.read_u32_be(0x0A64), Some(0x3000));
}
#[test]
fn menu_accessors_parse_item_count_text_and_command() {
let menu_handle = 0x1000;
let menu = 0x1100;
let output = 0x1200;
let menu_list_handle = 0x1300;
let menu_list = 0x1400;
let mut memory = PpcSectionMem::new();
memory.add_region(menu_handle, vec![0; 4]);
memory.add_region(menu, vec![0; 64]);
memory.add_region(output, vec![0; 256]);
memory.add_region(menu_list_handle, vec![0; 4]);
memory.add_region(menu_list, vec![0; 18]);
memory.write_u32_be(menu_handle, menu).unwrap();
memory.write_u16_be(menu, 128).unwrap();
memory.write_u32_be(menu + 10, 0b111).unwrap();
memory.write_u32_be(menu_list_handle, menu_list).unwrap();
memory.write_u16_be(menu_list, 6).unwrap();
memory.write_u32_be(menu_list + 6, menu_handle).unwrap();
memory.write_u8(menu + 14, 4).unwrap();
memory.write_bytes(menu + 15, b"Test").unwrap();
memory.write_u8(menu + 19, 3).unwrap();
memory.write_bytes(menu + 20, b"Run").unwrap();
memory.write_u8(menu + 24, b'R').unwrap();
memory.write_u8(menu + 27, 4).unwrap();
memory.write_bytes(menu + 28, b"Quit").unwrap();
memory.write_u8(menu + 33, b'Q').unwrap();
memory.write_u8(menu + 36, 0).unwrap();
assert_eq!(ppc_count_menu_items(&mut memory, menu_handle), 2);
let unterminated_handle = 0x1500;
let unterminated_menu = 0x1600;
memory.add_region(unterminated_handle, vec![0; 4]);
memory.add_region(unterminated_menu, vec![0; 24]);
memory
.write_u32_be(unterminated_handle, unterminated_menu)
.unwrap();
memory
.write_u32_be(unterminated_menu + 10, u32::MAX)
.unwrap();
memory.write_u8(unterminated_menu + 14, 0).unwrap();
memory.write_u8(unterminated_menu + 15, 4).unwrap();
memory.write_bytes(unterminated_menu + 16, b"Open").unwrap();
memory
.write_bytes(unterminated_menu + 20, &[0, b'O', 0, 0])
.unwrap();
assert_eq!(
ppc_count_menu_items(&mut memory, unterminated_handle),
0,
"both adapters must reject the same unterminated MenuInfo sequence"
);
let mut cpu = PpcCpu::new();
cpu.gpr[3] = menu_handle;
cpu.gpr[4] = 2;
cpu.gpr[5] = output;
ppc_get_menu_item_text(&cpu, &mut memory);
assert_eq!(memory.read_u8(output), Some(4));
assert_eq!(
ppc_memory_read_bytes(&mut memory, output + 1, 4),
Some(b"Quit".to_vec())
);
ppc_get_item_cmd(&cpu, &mut memory);
assert_eq!(memory.read_u16_be(output), Some(u16::from(b'Q')));
assert_eq!(
ppc_menu_key(&mut memory, menu_list_handle, b'r')
.map_or(0, MenuKeySelection::packed_result),
(128 << 16) | 1
);
cpu.gpr[5] = 0x1b;
let handles = [PpcHandleRecord {
handle: menu_handle,
ptr: menu,
size: 64,
capacity: 64,
}];
ppc_set_item_cmd(&cpu, &mut memory, &handles);
cpu.gpr[5] = output;
ppc_get_item_cmd(&cpu, &mut memory);
assert_eq!(memory.read_u16_be(output), Some(0x1b));
}
#[test]
fn menu_event_resolves_command_key_events_only() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"MenuEvent")).unwrap();
install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Game",
b"Start/S",
);
let event = PPC_DATA_BASE + 0x2000;
loaded.memory.add_region(event, vec![0; 16]);
loaded.memory.write_u16_be(event, 3).unwrap();
loaded.memory.write_u32_be(event + 2, u32::from(b's')).unwrap();
loaded.memory.write_u16_be(event + 14, 0x0100).unwrap();
loaded.cpu.gpr[3] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuEvent);
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
loaded.memory.write_u16_be(event + 14, 0).unwrap();
loaded.cpu.gpr[3] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuEvent);
assert_eq!(loaded.cpu.gpr[3], 0);
}
// IM:V 1986 pp. V-228--V-230 and MTE 1992 pp. 3-108--3-109:
// InsertMenu(-1) records a submenu in the hierarchical portion of the
// DynamicMenuList. It remains searchable, but never becomes a menu title.
#[test]
fn native_insert_menu_preserves_regular_and_hierarchical_partitions() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
let regular_title = scratch;
let hierarchical_title = scratch + 0x20;
let regular_items = scratch + 0x40;
let hierarchical_items = scratch + 0x60;
loaded.memory.add_region(scratch, vec![0; 0x100]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
regular_title,
b"File"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
hierarchical_title,
b"Recent"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
regular_items,
b"Open/O"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
hierarchical_items,
b"Document/D"
));
let regular = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
128,
regular_title,
);
let hierarchical = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
200,
hierarchical_title,
);
assert_ne!(regular, 0);
assert_ne!(hierarchical, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
regular,
regular_items,
i16::MAX,
),
PPC_NO_ERR
);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
hierarchical,
hierarchical_items,
i16::MAX,
),
PPC_NO_ERR
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
regular,
0,
),
PPC_NO_ERR
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
hierarchical,
-1,
),
PPC_NO_ERR
);
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
assert_ne!(menu_list_handle, 0);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_LIST),
Some(menu_list_handle)
);
let menu_list = loaded.memory.read_u32_be(menu_list_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_list), Some(6));
assert_eq!(loaded.memory.read_u32_be(menu_list + 6), Some(regular));
assert_eq!(
loaded.memory.read_u16_be(menu_list + 10),
Some(STANDARD_MENU_BAR_FIRST_TITLE_LEFT as u16)
);
assert_eq!(loaded.memory.read_u16_be(menu_list + 12), Some(6));
assert_eq!(loaded.memory.read_u32_be(menu_list + 14), Some(0));
assert_eq!(
loaded.memory.read_u32_be(menu_list + 18),
Some(hierarchical)
);
assert_eq!(loaded.memory.read_u16_be(menu_list + 22), Some(0));
assert_eq!(
loaded
.handles()
.iter()
.find(|record| record.handle == menu_list_handle)
.map(|record| record.size),
Some(24)
);
let definition = ppc_menu_list_definition(&mut loaded.memory, menu_list_handle).unwrap();
assert_eq!(
definition.regular,
vec![PpcMenuListEntry {
handle: regular,
value: STANDARD_MENU_BAR_FIRST_TITLE_LEFT,
}]
);
assert_eq!(
definition.hierarchical,
vec![PpcMenuListEntry {
handle: hierarchical,
value: 0,
}]
);
let snapshot = ppc_guest_menu_snapshot(&mut loaded.memory, menu_list_handle);
assert_eq!(snapshot.menus.len(), 2);
assert!(!snapshot.menus[0].hierarchical);
assert!(snapshot.menus[0].visible_in_menu_bar);
assert!(snapshot.menus[1].hierarchical);
assert!(!snapshot.menus[1].visible_in_menu_bar);
assert_eq!(
ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 200),
hierarchical
);
assert_eq!(
ppc_menu_key(&mut loaded.memory, menu_list_handle, b'd')
.map_or(0, MenuKeySelection::packed_result),
(200 << 16) | 1
);
let regular_command =
ppc_menu_item_attribute_address(&mut loaded.memory, regular, 1, 1).unwrap();
loaded.memory.write_u8(regular_command, b'D').unwrap();
assert_eq!(
ppc_menu_key(&mut loaded.memory, menu_list_handle, b'd')
.map_or(0, MenuKeySelection::packed_result),
(128 << 16) | 1,
"regular menus must be searched before the hierarchical partition"
);
loaded.memory.write_u8(regular_command, b'O').unwrap();
let command = ppc_menu_item_attribute_address(&mut loaded.memory, regular, 1, 1).unwrap();
let mark = ppc_menu_item_attribute_address(&mut loaded.memory, regular, 1, 2).unwrap();
loaded.memory.write_u8(command, 0x1B).unwrap();
loaded.memory.write_u8(mark, 200).unwrap();
assert_eq!(
ppc_submenu_handle_for_item(&mut loaded.memory, menu_list_handle, regular, 1),
Some(hierarchical),
"submenu resolution must find the matching hierarchical entry"
);
loaded.memory.write_u16_be(menu_list + 2, 80).unwrap();
loaded.memory.write_u16_be(menu_list + 10, 40).unwrap();
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list_handle, 39),
None
);
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list_handle, 40),
Some((regular, 40)),
"PPC title hits must use the live guest menuLeft"
);
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list_handle, 79),
Some((regular, 40))
);
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list_handle, 80),
None
);
loaded
.memory
.write_u16_be(menu_list + 2, definition.last_right as u16)
.unwrap();
loaded
.memory
.write_u16_be(menu_list + 10, definition.regular[0].value as u16)
.unwrap();
let first_non_title_h = definition.last_right.saturating_add(1);
assert_eq!(
ppc_menu_handle_at_title_point(
&mut loaded.memory,
menu_list_handle,
first_non_title_h as u16 as u32,
),
None
);
let menu_bar_bytes = 20 * ppc_main_screen_row_bytes();
assert!(loaded
.memory
.write_bytes(PPC_MAIN_SCREEN_BASE, &vec![0x55; menu_bar_bytes as usize])
.is_some());
assert!(ppc_draw_menu_bar(
&mut loaded.memory,
&loaded.gworlds,
menu_list_handle,
&loaded.screen_clut,
));
let with_hierarchical =
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_bytes)
.unwrap();
let regular_only = ppc_alloc_menu_list_definition_handle(
&PpcMenuListDefinition {
last_right: definition.last_right,
regular: definition.regular.clone(),
..PpcMenuListDefinition::default()
},
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(regular_only, 0);
assert_eq!(
ppc_submenu_handle_for_item(&mut loaded.memory, regular_only, regular, 1),
None,
"a detached or regular-only ID match must not resolve as a submenu"
);
assert!(loaded
.memory
.write_bytes(PPC_MAIN_SCREEN_BASE, &vec![0x55; menu_bar_bytes as usize])
.is_some());
assert!(ppc_draw_menu_bar(
&mut loaded.memory,
&loaded.gworlds,
regular_only,
&loaded.screen_clut,
));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_bytes,),
Some(with_hierarchical)
);
let before_duplicate =
ppc_menu_list_definition(&mut loaded.memory, menu_list_handle).unwrap();
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
hierarchical,
0,
),
PPC_NO_ERR
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, menu_list_handle),
Some(before_duplicate),
"reinserting a current menu must be a no-op"
);
}
#[test]
fn native_draw_menu_bar_uses_live_shared_title_geometry() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
let menu_list = loaded.memory.read_u32_be(menu_list_handle).unwrap();
loaded.memory.write_u16_be(menu_list + 2, 90).unwrap();
loaded.memory.write_u16_be(menu_list + 6 + 4, 50).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let black = ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut)
.expect("black screen pixel");
let mut contains_black = |left: i16, right: i16| {
(2..18).any(|y| {
(left..right).any(|x| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(x), i32::from(y)),
) == Some(black)
})
})
};
assert!(
!contains_black(
STANDARD_MENU_BAR_FIRST_TITLE_LEFT + STANDARD_MENU_BAR_TITLE_ORIGIN_INSET,
40,
),
"drawing must not retain the independently reconstructed title origin"
);
assert!(
contains_black(57, 80),
"drawing must place title artwork from the live menuLeft"
);
}
#[test]
fn native_draw_hilite_and_flash_menu_bar_use_live_shared_menu_colors() {
let pef = synthetic_pef_with_import(b"DrawMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = 8;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
let set_rgb = |entry: &mut [u8; MENU_COLOR_ENTRY_SIZE], offset: usize, rgb: [u16; 3]| {
for (channel, value) in rgb.into_iter().enumerate() {
let channel_offset = offset + channel * 2;
entry[channel_offset..channel_offset + 2].copy_from_slice(&value.to_be_bytes());
}
};
let bar_background = [0xffff, 0x1111, 0x1111];
let inherited_title = [0x1111, 0xffff, 0x1111];
let live_title = [0x1111, 0x1111, 0xffff];
let title_background = [0xffff, 0xffff, 0xffff];
let mut bar = test_menu_color_entry(0, 0, 0);
set_rgb(&mut bar, 4, inherited_title);
set_rgb(&mut bar, 22, bar_background);
let mut title = test_menu_color_entry(128, 0, 0);
set_rgb(&mut title, 4, inherited_title);
set_rgb(&mut title, 10, title_background);
let color_bytes = [bar.as_slice(), title.as_slice()].concat();
let color_handle = ppc_ensure_menu_color_table_handle(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(color_handle, 0);
assert_eq!(
ppc_replace_menu_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
color_handle,
&color_bytes,
),
PPC_NO_ERR,
);
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let bar_pixel = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(bar_background),
&loaded.screen_clut,
)
.unwrap();
let inherited_pixel = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(inherited_title),
&loaded.screen_clut,
)
.unwrap();
let live_pixel =
ppc_physical_screen_color_pixel(front, ppc_menu_rgb(live_title), &loaded.screen_clut)
.unwrap();
let title_background_pixel = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(title_background),
&loaded.screen_clut,
)
.unwrap();
assert_ne!(bar_pixel, inherited_pixel);
assert_ne!(bar_pixel, live_pixel);
assert_ne!(bar_pixel, title_background_pixel);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (120, 5)),
Some(bar_pixel),
"DrawMenuBar did not use the menu-bar entry RGB4",
);
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
let region = ppc_menu_list_definition(&mut loaded.memory, menu_list_handle)
.unwrap()
.regular_title_regions()
.into_iter()
.next()
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (i32::from(region.left - 1), 2)),
Some(title_background_pixel),
"DrawMenuBar did not use the title entry RGB2 for its title cell",
);
let title_pixel = (1..19)
.flat_map(|y| (region.left..region.right).map(move |x| (x, y)))
.find(|&(x, y)| {
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (i32::from(x), i32::from(y)))
== Some(inherited_pixel)
})
.expect("inherited green title ink");
let color_data = loaded.memory.read_u32_be(color_handle).unwrap();
for (channel, value) in live_title.into_iter().enumerate() {
loaded
.memory
.write_u16_be(
color_data + MENU_COLOR_ENTRY_SIZE as u32 + 4 + channel as u32 * 2,
value,
)
.unwrap();
}
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(title_pixel.0), i32::from(title_pixel.1)),
),
Some(live_pixel),
"DrawMenuBar did not reread the guest-mutated title entry",
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(title_pixel.0), i32::from(title_pixel.1)),
),
Some(title_background_pixel),
"HiliteMenu did not reverse the live title foreground",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (i32::from(region.left - 1), 2),),
Some(live_pixel),
"HiliteMenu did not reverse the live title background",
);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
let menu_bar_bytes = front.row_bytes * 20;
let normal =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (120, 5)),
Some(inherited_pixel),
"FlashMenuBar did not reverse live RGB4 through default RGB1",
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(title_pixel.0), i32::from(title_pixel.1)),
),
Some(live_pixel),
"FlashMenuBar changed a title-specific RGB1 pixel",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (i32::from(region.left - 1), 2)),
Some(title_background_pixel),
"FlashMenuBar changed a title-specific RGB2 pixel",
);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal),
"two live-color FlashMenuBar calls did not restore the menu bar",
);
}
// MTE 1992 p. 3-131 and HIG 1992 p. 54: disabling item 0 dims the
// menu title without hiding it. IM:V 1986 p. V-142 specifies the GetGray
// midpoint and the standard definition procedure's patterned fallback.
#[test]
fn native_draw_menu_bar_dims_disabled_titles_with_shared_gray_policy() {
let pef = synthetic_pef_with_import(b"DrawMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
let city = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1400, 129, b"City", b"Map");
ppc_set_menu_item_enabled(
&mut loaded.memory,
&test_handle_records!(loaded),
city,
0,
false,
);
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
let regions = ppc_menu_list_definition(&mut loaded.memory, menu_list_handle)
.unwrap()
.regular_title_regions();
assert_eq!(regions.len(), 2);
let baseline = i32::from(ppc_menu_bar_title_baseline(20));
let title_glyph_pixels = |title: &[u8], origin_x: i16| {
let mut cursor = i32::from(origin_x);
let mut pixels = Vec::new();
for byte in title {
let (glyph, data) = get_glyph(
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
char::from(*byte),
)
.unwrap();
for row in 0..glyph.height as usize {
for column in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + column;
if index < data.len() && data[index] >= 128 {
pixels.push((
cursor + i32::from(glyph.origin_x) + column as i32,
baseline + i32::from(glyph.origin_y) + row as i32,
));
}
}
}
cursor += i32::from(glyph.advance);
}
assert!(!pixels.is_empty());
pixels
};
let file_pixels = title_glyph_pixels(b"File", regions[0].title_origin());
let city_pixels = title_glyph_pixels(b"City", regions[1].title_origin());
for depth in [1, 8] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let gray = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(MenuColorTable::dimmed([0; 3], [u16::MAX; 3])),
&loaded.screen_clut,
)
.unwrap();
let read = |memory: &mut PpcSectionMem, point: &(i32, i32)| {
ppc_quickdraw_read_pixel(memory, front, *point).unwrap()
};
assert!(
file_pixels
.iter()
.all(|point| read(&mut loaded.memory, point) == black),
"{depth}bpp enabled title did not remain solid black",
);
if depth == 8 {
assert_ne!(gray, black);
assert_ne!(gray, white);
assert!(
city_pixels
.iter()
.all(|point| read(&mut loaded.memory, point) == gray),
"8bpp disabled title did not use the GetGray midpoint",
);
} else {
let city_ink = city_pixels
.iter()
.map(|point| read(&mut loaded.memory, point))
.collect::<Vec<_>>();
assert!(city_ink.contains(&black));
assert!(city_ink.contains(&white));
}
}
}
// IM:I 1985 p. I-281 and IM:V 1986 p. V-120: the main-screen desktop
// excludes the standard rounded outer corners beneath the menu bar.
#[test]
fn native_draw_menu_bar_uses_the_shared_rounded_corner_mask() {
let pef = synthetic_pef_with_import(b"DrawMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let mut rounded_corner_pixels = Vec::new();
for_each_standard_menu_bar_corner_pixel(
ppc_u32_to_i16_saturating(front.width),
|x, y| rounded_corner_pixels.push((x, y)),
);
let right_start = i32::try_from(front.width).unwrap() - 6;
for y in 0..5 {
for x in (0..6).chain(right_start..i32::try_from(front.width).unwrap()) {
let expected = if rounded_corner_pixels.contains(&(x as i16, y as i16)) {
black
} else {
white
};
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, y)),
Some(expected),
"{depth}bpp rounded corner mask pixel ({x}, {y})",
);
}
}
}
}
// MTE 1992 pp. 3-109--3-110: DeleteMenu resolves duplicate IDs in the
// hierarchical section before it considers regular menu-bar entries.
#[test]
fn native_delete_menu_prefers_hierarchical_id_collisions() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 0x40]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch,
b"Regular"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x20,
b"Submenu"
));
let regular = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
200,
scratch,
);
let hierarchical = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
200,
scratch + 0x20,
);
for (handle, before_id) in [(regular, 0), (hierarchical, -1)] {
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
handle,
before_id,
),
PPC_NO_ERR
);
}
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
assert_eq!(
ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 200),
hierarchical,
"GetMenuHandle must resolve the hierarchical collision first"
);
assert_eq!(
ppc_delete_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu_list_handle,
200,
),
PPC_NO_ERR
);
let after_hierarchical_delete =
ppc_menu_list_definition(&mut loaded.memory, menu_list_handle).unwrap();
assert_eq!(
after_hierarchical_delete
.regular_handles()
.collect::<Vec<_>>(),
vec![regular]
);
assert!(after_hierarchical_delete.hierarchical.is_empty());
assert_eq!(
ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 200),
regular
);
assert_eq!(
ppc_delete_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu_list_handle,
200,
),
PPC_NO_ERR
);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, menu_list_handle),
Some(Vec::new())
);
}
#[test]
fn native_insert_menu_does_not_evict_entries_from_a_full_partition() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 0x40]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch,
b"Existing"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x20,
b"Insert"
));
let existing = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
200,
scratch,
);
let insertion = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
201,
scratch + 0x20,
);
let mut regular = vec![
PpcMenuListEntry {
handle: 0xdead_0000,
value: 0,
};
MAX_MENU_LIST_ENTRIES - 1
];
regular.push(PpcMenuListEntry {
handle: existing,
value: 0,
});
let full = PpcMenuListDefinition {
regular,
..PpcMenuListDefinition::default()
};
let current = ppc_alloc_menu_list_definition_handle(
&full,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(current, 0);
ppc_set_current_menu_list(&mut loaded.memory, current);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
insertion,
200,
),
PPC_NO_ERR
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(full)
);
}
#[test]
fn quickdraw_compatibility_menu_item_icon_and_style_accessors_round_trip() {
let scratch = PPC_DATA_BASE + 0x1000;
for (symbol, operation, initial, replacement, attribute_offset) in [
(b"GetItemIcon".as_slice(), PpcQuickDrawCompatibilityOperation::GetItemIcon, 7u8, 0u8, 0u32),
(b"SetItemIcon".as_slice(), PpcQuickDrawCompatibilityOperation::SetItemIcon, 7u8, 11u8, 0u32),
(b"GetItemStyle".as_slice(), PpcQuickDrawCompatibilityOperation::GetItemStyle, 3u8, 0u8, 3u32),
(b"SetItemStyle".as_slice(), PpcQuickDrawCompatibilityOperation::SetItemStyle, 3u8, 0x25u8, 3u32),
] {
let pef = synthetic_pef_with_import(symbol);
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::QuickDrawCompatibility(operation),
);
let item = if attribute_offset == 0 {
b"Item^7".as_slice()
} else {
b"Item<B<I".as_slice()
};
let menu = install_test_menu(&mut loaded, scratch, 128, b"File", item);
let output = scratch + 0x300;
loaded.memory.add_region(output, vec![0xa5; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = if symbol.starts_with(b"Get") {
output
} else {
u32::from(replacement)
};
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let address =
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, attribute_offset)
.unwrap();
if symbol.starts_with(b"Get") {
assert_eq!(loaded.memory.read_u8(output), Some(initial));
} else {
assert_eq!(loaded.memory.read_u8(address), Some(replacement));
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[4] = 99;
if symbol.starts_with(b"Get") {
loaded.memory.write_u8(output, 0xa5).unwrap();
loaded.cpu.gpr[5] = output;
}
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
if symbol.starts_with(b"Get") {
assert_eq!(loaded.memory.read_u8(output), Some(0));
} else {
assert_eq!(loaded.memory.read_u8(address), Some(replacement));
}
}
}
#[test]
fn find_window_distinguishes_the_menu_bar_from_the_desktop() {
let pef = synthetic_pef_with_import(b"FindWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let window_out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(window_out, vec![0xff; 4]);
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u16_be(PPC_MBAR_HEIGHT_ADDR, 12)
.unwrap();
loaded.cpu.gpr[3] = (11 << 16) | 72;
loaded.cpu.gpr[4] = window_out;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(window_out), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = (12 << 16) | 72;
loaded.cpu.gpr[4] = window_out;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(window_out), Some(0));
}
#[test]
fn find_window_uses_visible_front_to_back_window_geometry_not_the_current_port() {
let pef = synthetic_pef_with_import(b"FindWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1100;
let bounds = scratch;
let window_out = scratch + 16;
loaded.memory.add_region(scratch, vec![0; 32]);
ppc_write_rect(&mut loaded.memory, bounds, 40, 40, 140, 180).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = bounds;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
let back_window = loaded.cpu.gpr[3];
assert_ne!(back_window, 0);
ppc_write_rect(&mut loaded.memory, bounds, 60, 60, 160, 200).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = bounds;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
let front_window = loaded.cpu.gpr[3];
assert_ne!(front_window, 0);
// The current graphics port is not the Window Manager's z-order.
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded.cpu.gpr[3] = (80 << 16) | 80;
loaded.cpu.gpr[4] = window_out;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FindWindow);
assert_eq!(loaded.cpu.gpr[3], 3);
assert_eq!(loaded.memory.read_u32_be(window_out), Some(front_window));
loaded.cpu.gpr[3] = (50 << 16) | 50;
loaded.cpu.gpr[4] = window_out;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FindWindow);
assert_eq!(loaded.cpu.gpr[3], 3);
assert_eq!(loaded.memory.read_u32_be(window_out), Some(back_window));
loaded.cpu.gpr[3] = (300 << 16) | 300;
loaded.cpu.gpr[4] = window_out;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FindWindow);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(window_out), Some(0));
}
#[test]
fn dispose_dialog_removes_it_from_the_window_list_and_restores_the_previous_window() {
let pef = synthetic_pef_with_import(b"DisposeDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let application_window = PPC_DATA_BASE + 0x1000;
let dialog = PPC_DATA_BASE + 0x2000;
for window in [application_window, dialog] {
loaded
.memory
.add_region(window, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded
.memory
.write_u8(window + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: window,
pixmap_handle: 0,
pixmap: 0,
base_addr: 0,
gdevice: PPC_MAIN_GDEVICE,
width: 100,
height: 100,
depth: 8,
row_bytes: 100,
pixels_locked: false,
pixels_no_purge: false,
});
}
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = dialog);
loaded.cpu.gpr[3] = dialog;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DisposeDialog);
assert_eq!(loaded.toolbox_startup.dispose_dialog_count, 1);
assert_eq!(loaded.toolbox_startup.last_disposed_dialog, dialog);
assert!(!loaded.gworlds.iter().any(|record| record.port == dialog));
assert_eq!(*loaded.current_gworld, application_window);
assert_eq!(
ppc_front_visible_window(&mut loaded.memory, &loaded.gworlds),
Some(application_window)
);
}
#[test]
fn menu_bar_title_baseline_tracks_the_live_menu_bar_height() {
let metrics = crate::quickdraw::text::get_font_metrics(0, 12);
for height in [12, 20, 30] {
let baseline = ppc_menu_bar_title_baseline(height);
let top = baseline - metrics.ascent;
let bottom = height - baseline - metrics.descent;
assert!(
(top - bottom).abs() <= 1,
"title must be vertically centered"
);
}
assert_eq!(ppc_menu_bar_system_mark_top(12), 0);
assert_eq!(ppc_menu_bar_system_mark_top(20), 3);
assert_eq!(ppc_menu_bar_system_mark_top(30), 8);
}
#[test]
fn hilite_menu_selects_one_title_and_zero_restores_the_bar_at_supported_depths() {
let pef = synthetic_pef_with_import(b"HiliteMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let title = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(title, vec![0; 16]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, title, b"File"));
let menu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
128,
title,
);
assert_ne!(menu, 0);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
0,
),
PPC_NO_ERR
);
let title_glyph_pixels = {
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, 'F').unwrap();
let mut pixels = Vec::new();
for row in 0..glyph.height as usize {
for col in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + col;
if index < data.len() && data[index] >= 128 {
pixels.push((
i32::from(glyph.origin_x) + col as i32,
i32::from(glyph.origin_y) + row as i32,
));
}
}
}
assert!(!pixels.is_empty());
pixels
};
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.memory.write_u16_be(PPC_THE_MENU_ADDR, 0).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
assert_eq!(front.depth, depth);
let menu_bar_bytes = front.row_bytes * 20;
let normal =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let title_origin = (
i32::from(
STANDARD_MENU_BAR_FIRST_TITLE_LEFT + STANDARD_MENU_BAR_TITLE_ORIGIN_INSET,
),
i32::from(ppc_menu_bar_title_baseline(20)),
);
let normal_title_ink = title_glyph_pixels
.iter()
.filter(|&&(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(title_origin.0 + dx, title_origin.1 + dy),
) == Some(black)
})
.count();
assert_eq!(
normal_title_ink,
title_glyph_pixels.len(),
"{depth}bpp menu title glyph did not draw in black",
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
let highlighted =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
assert_ne!(highlighted, normal, "{depth}bpp title did not highlight");
let highlighted_title_ink = title_glyph_pixels
.iter()
.filter(|&&(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(title_origin.0 + dx, title_origin.1 + dy),
) == Some(white)
})
.count();
assert_eq!(
highlighted_title_ink,
title_glyph_pixels.len(),
"{depth}bpp highlighted menu title glyph did not reverse to white",
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(highlighted),
"{depth}bpp repeated HiliteMenu changed the title"
);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal),
"{depth}bpp HiliteMenu(0) did not restore the menu bar"
);
}
}
// MTE 1992 pp. 3-141--3-142 and IM:V 1986 p. V-246: zero or an
// unknown ID reverses the complete bar, while a regular ID toggles that
// title and restores any different title first.
#[test]
fn native_flash_menu_bar_matches_whole_bar_and_title_semantics_at_supported_depths() {
let pef = synthetic_pef_with_import(b"FlashMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1400, 129, b"Edit", b"Cut");
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
let regions = ppc_menu_list_definition(&mut loaded.memory, menu_list_handle)
.unwrap()
.regular_title_regions();
assert_eq!(regions.len(), 2);
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.memory.write_u16_be(PPC_THE_MENU_ADDR, 0).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let menu_bar_bytes = front.row_bytes * 20;
let normal =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
let file_cell = (i32::from(regions[0].left.saturating_add(3)), 2);
let edit_cell = (i32::from(regions[1].left.saturating_add(3)), 2);
let bar_point = (200, 5);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, file_cell),
Some(white),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, edit_cell),
Some(white),
);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, bar_point),
Some(black),
"{depth}bpp FlashMenuBar(0) did not reverse the bar background",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (0, 0)),
Some(black),
"{depth}bpp FlashMenuBar(0) did not preserve the corner mask",
);
let whole_bar_flipped =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
assert_ne!(whole_bar_flipped, normal);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal.clone()),
"{depth}bpp two whole-bar flashes did not restore the framebuffer",
);
loaded.cpu.gpr[3] = 999;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.cpu.gpr[3], 999);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(whole_bar_flipped),
"{depth}bpp unknown menu ID did not flash the complete bar",
);
loaded.cpu.gpr[3] = 999;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal.clone()),
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, file_cell),
Some(black),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, edit_cell),
Some(white),
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal.clone()),
"{depth}bpp flashing the selected title did not toggle it off",
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(129));
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, file_cell),
Some(white),
"{depth}bpp previous title was not restored",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, edit_cell),
Some(black),
"{depth}bpp requested title was not highlighted",
);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal),
"{depth}bpp title switching did not restore the original bar",
);
}
}
#[test]
fn tracked_menu_draws_standard_item_chrome_and_dims_disabled_rows() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Checked!\x12;Command/C;Disabled/C!\x12(;-;Parent/\x1b!\xc9",
);
ppc_calc_menu_size(&mut loaded.memory, menu);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
let command_text_advance = ppc_text_bytes_advance_for_font(
b"Command",
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
);
assert!(
tracking.popup_width >= command_text_advance.saturating_add(53),
"command-key column overlaps item text"
);
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let gray = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(MenuColorTable::dimmed([0; 3], [u16::MAX; 3])),
&loaded.screen_clut,
)
.unwrap();
let glyph_pixels = |ch| {
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, ch).unwrap();
let mut pixels = Vec::new();
for row in 0..glyph.height as usize {
for col in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + col;
if index < data.len() && data[index] >= 128 {
pixels.push((
i32::from(glyph.origin_x) + col as i32,
i32::from(glyph.origin_y) + row as i32,
));
}
}
}
pixels
};
let assert_glyph_color =
|memory: &mut PpcSectionMem, origin: (i32, i32), ch: char, pixel: u16| {
let glyph = glyph_pixels(ch);
assert!(!glyph.is_empty());
assert!(glyph.iter().all(|(dx, dy)| {
ppc_quickdraw_read_pixel(memory, front, (origin.0 + dx, origin.1 + dy))
== Some(pixel)
}));
};
let row_top =
|item: i16| tracking.popup_top + ppc_tracked_menu_item_offset(&tracking, item);
let command_layout = standard_menu_item_layout(
(
tracking.popup_left,
tracking.popup_left + tracking.popup_width,
),
(row_top(2), ppc_tracked_menu_item_height(&tracking, 2)),
StandardMenuIconKind::None,
false,
{
let metrics = get_font_metrics(PPC_QD_TEXT_FONT_DEFAULT, PPC_QD_TEXT_SIZE_SYSTEM);
(metrics.ascent, metrics.descent)
},
true,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(command_layout.text_left),
i32::from(command_layout.text_baseline),
),
'C',
black,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + 3),
i32::from(row_top(1) + 11),
),
'\u{2713}',
black,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + tracking.popup_width - 25),
i32::from(row_top(2) + 11),
),
'\u{2318}',
black,
);
let command_symbol_advance = i32::from(
get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, '\u{2318}')
.unwrap()
.0
.advance,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + tracking.popup_width - 25) + command_symbol_advance,
i32::from(row_top(2) + 11),
),
'C',
black,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + 15),
i32::from(row_top(3) + 11),
),
'D',
gray,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + 3),
i32::from(row_top(3) + 11),
),
'\u{2713}',
gray,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + tracking.popup_width - 25),
i32::from(row_top(3) + 11),
),
'\u{2318}',
gray,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + tracking.popup_width - 25) + command_symbol_advance,
i32::from(row_top(3) + 11),
),
'C',
gray,
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left + 10),
i32::from(row_top(4) + 2),
),
),
Some(gray)
);
let hierarchy_ink = (0..7i16)
.flat_map(|dx| (-3..=3).map(move |dy| (dx, dy)))
.filter(|(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left + tracking.popup_width - 12 + *dx),
i32::from(row_top(5) + 8 + *dy),
),
) == Some(black)
})
.count();
assert!(hierarchy_ink >= 7, "hierarchical indicator did not draw");
let disabled_hover = PpcInputSnapshot {
mouse_button: true,
mouse_v: row_top(3) + 4,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_menu_tracking_item(&mut loaded.memory, &tracking, disabled_hover),
0
);
let selected = PpcInputSnapshot {
mouse_button: true,
mouse_v: row_top(1) + 4,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
selected,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + 3),
i32::from(row_top(1) + 11),
),
'\u{2713}',
white,
);
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
},
),
Some(0)
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before)
);
}
#[test]
fn native_popup_draws_from_the_live_shared_menu_color_table() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu =
install_test_popup_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 300, b"Popup", b"Color");
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = 8;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
let set_rgb = |entry: &mut [u8; MENU_COLOR_ENTRY_SIZE], offset: usize, rgb: [u16; 3]| {
for (channel, value) in rgb.into_iter().enumerate() {
let channel_offset = offset + channel * 2;
entry[channel_offset..channel_offset + 2].copy_from_slice(&value.to_be_bytes());
}
};
let menu_background = [0xffff, 0x1111, 0x1111];
let item_name = [0x1111, 0x1111, 0xffff];
let mut title = test_menu_color_entry(300, 0, 0);
set_rgb(&mut title, 22, menu_background);
let mut item = test_menu_color_entry(300, 1, 0);
set_rgb(&mut item, 10, item_name);
set_rgb(&mut item, 22, menu_background);
let color_bytes = [title.as_slice(), item.as_slice()].concat();
let color_handle = ppc_ensure_menu_color_table_handle(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(color_handle, 0);
assert_eq!(
ppc_replace_menu_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
color_handle,
&color_bytes,
),
PPC_NO_ERR,
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::PopUpMenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 80;
loaded.cpu.gpr[6] = 0;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let background_pixel = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(menu_background),
&loaded.screen_clut,
)
.unwrap();
let name_pixel =
ppc_physical_screen_color_pixel(front, ppc_menu_rgb(item_name), &loaded.screen_clut)
.unwrap();
assert_ne!(background_pixel, name_pixel);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left + tracking.popup_width - 3),
i32::from(tracking.popup_top + 2),
),
),
Some(background_pixel),
);
let metrics = get_font_metrics(PPC_QD_TEXT_FONT_DEFAULT, PPC_QD_TEXT_SIZE_SYSTEM);
let layout = standard_menu_item_layout(
(
tracking.popup_left,
tracking.popup_left + tracking.popup_width,
),
(tracking.content_top, tracking.item_appearances[0].height),
StandardMenuIconKind::None,
false,
(metrics.ascent, metrics.descent),
false,
);
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, 'C').unwrap();
let (dx, dy) = (0..glyph.height as usize)
.flat_map(|row| (0..glyph.width as usize).map(move |column| (column, row)))
.find(|(column, row)| {
data.get(glyph.data_offset + row * glyph.width as usize + column)
.is_some_and(|alpha| *alpha >= 128)
})
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(layout.text_left) + i32::from(glyph.origin_x) + dx as i32,
i32::from(layout.text_baseline) + i32::from(glyph.origin_y) + dy as i32,
),
),
Some(name_pixel),
);
}
#[test]
fn tracked_menu_renders_each_standard_text_style() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Menu;Menu;Menu;Menu;Menu;Menu;Menu;Menu",
);
let styles = [
0,
QuickDrawTextStyle::BOLD_BIT,
QuickDrawTextStyle::ITALIC_BIT,
QuickDrawTextStyle::UNDERLINE_BIT,
QuickDrawTextStyle::OUTLINE_BIT,
QuickDrawTextStyle::SHADOW_BIT,
QuickDrawTextStyle::CONDENSE_BIT,
QuickDrawTextStyle::EXTEND_BIT,
];
for (item, style) in (1i16..).zip(styles) {
let address =
ppc_menu_item_attribute_address(&mut loaded.memory, menu, item, 3).unwrap();
loaded.memory.write_u8(address, style).unwrap();
}
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let appearances = ppc_menu_item_appearances(&mut loaded.memory, menu, &[], 0);
assert_eq!(
appearances
.iter()
.map(|item| item.height)
.collect::<Vec<_>>(),
vec![16, 16, 16, 16, 16, 21, 16, 16],
);
let state = ppc_begin_tracked_menu_with_appearances(
&mut loaded.memory,
front,
MenuTrackingKind::MenuBar,
menu,
11,
20,
20,
120,
ppc_menu_appearance_height(&appearances),
0,
appearances,
)
.unwrap();
ppc_draw_tracked_menu(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
StandardMenuPaneKind::PullDown,
&state,
0,
);
let pixels_for_item = |memory: &mut PpcSectionMem, item: i16| {
let top = state.popup_top + ppc_tracked_menu_item_offset(&state, item);
let mut pixels = Vec::with_capacity(16 * 48);
for y in 0..16i32 {
for x in 0..48i32 {
pixels.push(
ppc_quickdraw_read_pixel(
memory,
front,
(i32::from(state.popup_left + 18) + x, i32::from(top) + y),
)
.unwrap(),
);
}
}
pixels
};
let plain = pixels_for_item(&mut loaded.memory, 1);
for item in 2..=8 {
assert_ne!(
pixels_for_item(&mut loaded.memory, item),
plain,
"style bit for item {item} did not change its rendered pixels",
);
}
for item in 1..=8 {
let top = state.popup_top + ppc_tracked_menu_item_offset(&state, item);
assert_eq!(
ppc_menu_tracking_item(
&mut loaded.memory,
&state,
PpcInputSnapshot {
mouse_button: true,
mouse_v: top + ppc_tracked_menu_item_height(&state, item) / 2,
mouse_h: state.popup_left + 20,
..PpcInputSnapshot::default()
},
),
item,
);
}
}
#[test]
fn tracked_menu_omits_trailing_separator_rows() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Apple",
b"About;-",
);
let appearances = ppc_menu_item_appearances(&mut loaded.memory, menu, &[], 0);
assert_eq!(appearances.len(), 1);
assert_eq!(ppc_menu_appearance_height(&appearances), 16);
ppc_calc_menu_size(&mut loaded.memory, menu);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(16));
}
#[test]
fn native_calc_menu_size_uses_shared_macos_8_1_width_policy() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Alpha;Parent/\x1b",
);
let parent_width = ppc_text_bytes_advance_for_font(
b"Parent",
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
);
assert_eq!(
parent_width,
TrapDispatcher::fb_measure_string("Parent", 0, 12),
"PPC and 68k adapters should resolve the same bundled font metric",
);
assert_eq!(
ppc_menu_item(&mut loaded.memory, menu, 2).and_then(|(address, length)| {
ppc_memory_read_bytes(&mut loaded.memory, address + 1, u32::from(length))
}),
Some(b"Parent".to_vec()),
);
ppc_calc_menu_size(&mut loaded.memory, menu);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(
loaded.memory.read_u16_be(menu_ptr + 2),
Some((parent_width + 64) as u16),
);
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(32));
}
#[test]
fn native_calc_menu_size_caps_oversized_menu_height_from_profile_geometry() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let description = (0..40).map(|_| "A").collect::<Vec<_>>().join(";");
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
description.as_bytes(),
);
ppc_calc_menu_size(&mut loaded.memory, menu);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(560));
}
#[test]
fn native_calc_menu_size_calls_powerpc_custom_mdef_size_message() {
let pef = synthetic_pef_with_import(b"CalcMenuSize");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Custom",
b"Ignored",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
let callback_rtoc = PPC_DATA_BASE + 0x7300;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
d_form_u(32, 6, 4, 0),
d_form_u(14, 7, 0, 123),
d_form_u(44, 7, 6, 2),
d_form_u(14, 7, 0, 45),
d_form_u(44, 7, 6, 4),
BLR,
],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
loaded.cpu.gpr[3] = menu;
run_test_import(&mut loaded, PpcImportDispatcherTarget::CalcMenuSize);
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(45));
assert!(loaded
.process_memory_manager
.0
.borrow()
.native_ptr_records()
.iter()
.all(|record| record.ptr != loaded.cpu.gpr[5]));
assert!(loaded.guest_calls().is_empty());
}
#[test]
fn nested_native_mdef_preserves_outer_by_reference_arguments() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"CalcMenuSize")).unwrap();
let outer = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 140, b"Outer", b"A");
let inner = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x2000, 141, b"Inner", b"B");
let marker = PPC_DATA_BASE + 0x7800;
loaded.memory.add_region(marker, vec![0; 4]);
let outer_code = [
0x9421_ffa0, // stwu r1,-96(r1)
0x7c08_02a6, // mflr r0
0x9001_0064, // stw r0,100(r1)
0x90a1_0038, // stw r5,56(r1): retain outer menuRect pointer
0x3920_1122, // li r9,0x1122
0xb125_0000, // sth r9,0(r5)
0x3c60_0000 | (inner >> 16),
0x6063_0000 | (inner & 0xffff),
0x3d80_0000 | (PPC_IMPORT_TRAP_BASE >> 16),
0x618c_0000 | (PPC_IMPORT_TRAP_BASE & 0xffff),
0x7d89_03a6, // mtctr r12
0x4e80_0421, // bctrl: nested CalcMenuSize
0x80a1_0038, // lwz r5,56(r1)
0xa125_0000, // lhz r9,0(r5)
0x3d40_0000 | (marker >> 16),
0x614a_0000 | (marker & 0xffff),
0x912a_0000, // stw r9,0(r10)
0x8001_0064, // lwz r0,100(r1)
0x7c08_03a6, // mtlr r0
0x3821_0060, // addi r1,r1,96
BLR,
];
let inner_code = [0x3920_3344, 0xb125_0000, BLR];
for (index, menu, code) in [
(0, outer, outer_code.as_slice()),
(1, inner, inner_code.as_slice()),
] {
let storage = PPC_DATA_BASE + 0x7000 + index * 0x400;
loaded.memory.add_region(storage, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
storage + 0x100,
storage + 0x180,
PPC_CODE_BASE + 0x4000 + index * 0x100,
0,
0x0000_ff80,
code,
);
loaded
.memory
.write_u32_be(storage, storage + 0x100)
.unwrap();
let record = loaded.memory.read_u32_be(menu).unwrap();
loaded.memory.write_u32_be(record + 6, storage).unwrap();
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = outer;
let probe = loaded.run_with_hle_imports(256);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(probe.handled_import_count, 2);
assert_eq!(loaded.cpu.pc, PPC_HALT_PC);
assert!(loaded.guest_calls().is_empty());
assert_eq!(
loaded.memory.read_u32_be(marker),
Some(0x1122),
"nested MDEF scratch must not alias its caller"
);
}
#[test]
fn nested_classic_mdef_adapters_keep_live_workspaces_disjoint() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"CalcMenuSize")).unwrap();
let menu = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 140, b"Custom", b"A");
let handle = PPC_DATA_BASE + 0x7000;
let descriptor = handle + 0x100;
loaded.memory.add_region(handle, vec![0; 4]);
install_test_m68k_callback(
&mut loaded,
descriptor,
PPC_CODE_BASE + 0x4000,
MenuDefinitionInvocation::PASCAL_PROC_INFO,
0,
&[0x4e74, 18],
);
loaded.memory.write_u32_be(handle, descriptor).unwrap();
let record = loaded.memory.read_u32_be(menu).unwrap();
loaded.memory.write_u32_be(record + 6, handle).unwrap();
let manager_handle = loaded.process_memory_manager.0.clone();
let mut manager = manager_handle.borrow_mut();
let initial_count = manager.native_ptr_records().len();
let heap = manager.native_heap_state().unwrap();
let mut cursor = heap.heap_cursor;
let invocation = MenuDefinitionInvocation {
message: crate::menu_manager::MenuDefinitionMessage::Size,
menu_handle: menu,
menu_rect: (1, 2, 3, 4),
hit_point: 0,
which_item: 0,
};
let mut intervals = Vec::new();
for index in 0..2 {
let action = ppc_dispatch_native_menu_definition(
&mut loaded.cpu,
Some(manager.native_mut()),
&mut loaded.memory,
&mut cursor,
heap.heap_limit,
&loaded.process_file_system.vfs_resources,
&mut loaded.toolbox_startup,
invocation,
PPC_HALT_PC,
)
.unwrap();
assert!(matches!(action, PpcImportAction::Halt));
let pending = loaded.toolbox_startup.execution.calls().activate_m68k().unwrap();
loaded
.memory
.write_u32_be(pending.initial_sp - 100, 0x1122 + index)
.unwrap();
intervals.push(pending);
}
let outer = intervals[0];
let inner = intervals[1];
assert_ne!(outer.entry, inner.entry);
assert!(outer.final_sp <= inner.entry || inner.final_sp <= outer.entry);
assert_eq!(
loaded.memory.read_u32_be(outer.initial_sp - 100),
Some(0x1122)
);
assert_eq!(
loaded.memory.read_u32_be(inner.initial_sp - 100),
Some(0x1123)
);
assert_eq!(manager.native_ptr_records().len(), initial_count + 2);
for (index, pending) in intervals.into_iter().rev().enumerate() {
assert!(loaded
.toolbox_startup.execution.calls()
.complete_m68k_operation_for_powerpc(
pending.return_pc,
pending.final_sp,
None,
&mut loaded.cpu,
&mut loaded.memory,
manager.native_mut(),
));
assert_eq!(
manager.native_ptr_records().len(),
initial_count + 1 - index
);
}
assert!(loaded.toolbox_startup.execution.calls().is_empty());
assert_eq!(loaded.toolbox_startup.mixed_mode_m68k.storage_pair(), (0, 0));
}
#[test]
fn native_custom_mdef_adapter_marshals_shared_choose_invocation() {
let pef = synthetic_pef_with_import(b"CalcMenuSize");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Custom",
b"Ignored",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
let callback_rtoc = PPC_DATA_BASE + 0x7300;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[BLR],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
let invocation = MenuDefinitionInvocation {
message: crate::menu_manager::MenuDefinitionMessage::Choose,
menu_handle: menu,
menu_rect: (20, 30, 120, 180),
hit_point: 0x0050_0060,
which_item: 4,
};
let final_pc = 0x1234_5678;
let manager_handle = loaded.process_memory_manager.0.clone();
let mut manager = manager_handle.borrow_mut();
let heap = manager.native_heap_state().unwrap();
let mut cursor = heap.heap_cursor;
let action = ppc_dispatch_native_menu_definition(
&mut loaded.cpu,
Some(manager.native_mut()),
&mut loaded.memory,
&mut cursor,
heap.heap_limit,
&loaded.process_file_system.vfs_resources,
&mut loaded.toolbox_startup,
invocation,
final_pc,
)
.expect("native custom MDEF should be callable");
assert!(matches!(action, PpcImportAction::Continue));
assert_eq!(loaded.cpu.pc, callback_entry);
assert_eq!(loaded.cpu.gpr[2], callback_rtoc);
assert_eq!(loaded.toolbox_startup.execution.calls().len(), 1);
let scratch = loaded.cpu.gpr[5];
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, scratch, 10),
Some(invocation.scratch_bytes().to_vec())
);
assert_eq!(
&loaded.cpu.gpr[3..8],
&[1, menu, scratch, invocation.hit_point, scratch + 8,]
);
loaded.cpu.pc = PPC_GUEST_CALL_RETURN_PC;
assert!(loaded
.toolbox_startup.execution.calls()
.complete_powerpc_resuming_operation(
&mut loaded.cpu,
manager.native_mut(),
|operation, result| {
let crate::guest_call::ManagerContinuation::Menu(
crate::guest_call::MenuManagerContinuation::Definition(operation),
) = operation
else {
panic!("MDEF continuation");
};
operation.complete(&mut loaded.memory);
result
},
));
assert_eq!(loaded.cpu.pc, final_pc);
assert!(manager
.native_ptr_records()
.iter()
.all(|record| record.ptr != scratch));
}
#[test]
fn configured_native_startup_keeps_empty_menu_ownership_pristine() {
let pef = synthetic_pef_with_import(b"InitMenus");
for screen_depth in [1, 2, 4, 8, 16] {
let mut loaded = load_pef_application_with_config(
&pef,
PpcLoadConfig {
screen_depth,
..PpcLoadConfig::default()
},
)
.unwrap();
assert!(
loaded.toolbox_startup.execution.calls().is_pristine(),
"depth {screen_depth}"
);
let mut context = crate::process_context::ProcessContext::default();
loaded.attach_unconverted_process_services(&mut context);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert!(loaded.guest_calls().is_pristine());
assert!(context.menu_tracking().is_none());
}
}
#[test]
fn nested_native_menu_select_preserves_outer_tracking_and_return() {
for (nested_point, nested_result) in
[(u32::MAX, 0), ((10u32 << 16) | 12, (131u32 << 16) | 1)]
{
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
131,
b"Custom",
b"Opaque definition data",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
loaded.memory.write_u16_be(menu_ptr + 2, 80).unwrap();
loaded.memory.write_u16_be(menu_ptr + 4, 32).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
let marker = PPC_DATA_BASE + 0x7800;
loaded.memory.add_region(marker, vec![0; 8]);
loaded.memory.write_u32_be(marker + 4, u32::MAX).unwrap();
let mut code = vec![
0x9421_ffa0, // stwu r1,-96(r1)
0x7c08_02a6, // mflr r0
0x9001_0064, // stw r0,100(r1)
0x90e1_0038, // save whichItem pointer
0x3d20_0000 | (marker >> 16),
0x6129_0000 | (marker & 0xffff),
0x8109_0000, // lwz r8,0(r9)
0x2c08_0000, // cmpwi r8,0
0, // bne: only the first callback starts a nested entry
0x3900_0001,
0x9109_0000,
0x3c60_0000 | (nested_point >> 16),
0x6063_0000 | (nested_point & 0xffff),
0x3d80_0000 | (PPC_IMPORT_TRAP_BASE >> 16),
0x618c_0000 | (PPC_IMPORT_TRAP_BASE & 0xffff),
0x7d89_03a6,
0x4e80_0421,
0x3d20_0000 | (marker >> 16),
0x6129_0000 | (marker & 0xffff),
0x9069_0004, // record nested result
0x80e1_0038,
0x3900_0001,
0xb107_0000, // choose first outer item
0x8001_0064,
0x7c08_03a6,
0x3821_0060,
BLR,
];
code[8] = 0x4082_0000 | ((20 - 8) * 4);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&code,
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = 0x1234_0000);
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = 0x1234_1000);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let restored_start = front.base_addr + 20 * front.row_bytes;
let restored_len = front.row_bytes * (front.height - 20);
let before =
ppc_memory_read_bytes(&mut loaded.memory, restored_start, restored_len).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = (10u32 << 16) | 12;
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..16 {
let probe = loaded.run_with_hle_imports(256);
assert_eq!(probe.unsupported_import_index, None);
if matches!(probe.result, PpcRunResult::Halted { .. }) {
break;
}
}
assert_eq!(
loaded.memory.read_u32_be(marker + 4),
Some(nested_result),
"nested selection result"
);
assert_eq!(loaded.cpu.pc, PPC_HALT_PC, "outer caller return");
assert_eq!(loaded.cpu.gpr[3], (131u32 << 16) | 1, "outer selection");
assert!(loaded.guest_calls().is_empty());
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(*loaded.current_gworld, 0x1234_0000);
assert_eq!(*loaded.current_gdevice, 0x1234_1000);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, restored_start, restored_len),
Some(before),
"nested menus restore the original pixels"
);
}
}
#[test]
fn native_menu_select_retains_custom_mdef_draw_and_choose_until_release() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
131,
b"Custom",
b"Opaque definition data",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
loaded.memory.write_u16_be(menu_ptr + 2, 80).unwrap();
loaded.memory.write_u16_be(menu_ptr + 4, 32).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[d_form_u(14, 8, 0, 2), d_form_u(44, 8, 7, 0), BLR],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
let return_address = loaded.cpu.lr;
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = 0x1234_0000);
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = 0x1234_1000);
loaded.cpu.gpr[3] = (10u32 << 16) | 12;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.active_menu_definition()
.unwrap()
.which_item(),
2
);
assert_eq!(*loaded.current_gworld, PPC_MAIN_GWORLD);
assert_eq!(*loaded.current_gdevice, PPC_MAIN_GDEVICE);
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before.clone())
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(256);
assert_eq!(
probe.handled_import_count, 0,
"retained custom tracking bypasses public entry"
);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.flash_remaining,
6
);
let mut phases = vec![6];
for _ in 0..64 {
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(256);
assert_eq!(probe.handled_import_count, 0, "retained custom tracking bypasses public entry");
let remaining = loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map_or(0, |state| state.flash_remaining);
if phases.last() != Some(&remaining) {
phases.push(remaining);
}
if matches!(probe.result, PpcRunResult::Halted { .. }) {
break;
}
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert_eq!(phases, [6, 5, 4, 3, 2, 1, 0]);
assert_eq!(loaded.cpu.gpr[3], (131u32 << 16) | 2);
assert_eq!(loaded.cpu.lr, return_address);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().definition,
None
);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_menu(),
None
);
assert_eq!(*loaded.current_gworld, 0x1234_0000);
assert_eq!(*loaded.current_gdevice, 0x1234_1000);
let mut restored = Vec::new();
for y in 0..i32::from(tracking.saved_height) {
for x in 0..i32::from(tracking.saved_width) {
restored.push(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left) + x,
i32::from(tracking.popup_top) + y,
),
)
.unwrap(),
);
}
}
assert_eq!(restored, *tracking.saved_pixels);
}
#[test]
fn native_menu_select_routes_hierarchical_child_through_its_custom_mdef() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
let root = install_test_menu(&mut loaded, scratch, 140, b"File", b"Custom child");
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x100,
b"Child",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x180,
b"Opaque definition data",
));
let child = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
141,
scratch + 0x100,
);
assert_ne!(child, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
child,
scratch + 0x180,
i16::MAX,
),
PPC_NO_ERR,
);
loaded.cpu.gpr[3] = root;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x1B;
ppc_set_item_cmd(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
);
loaded.cpu.gpr[5] = 141;
ppc_set_item_mark(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
child,
-1,
),
PPC_NO_ERR,
);
let child_ptr = loaded.memory.read_u32_be(child).unwrap();
loaded.memory.write_u16_be(child_ptr + 2, 72).unwrap();
loaded.memory.write_u16_be(child_ptr + 4, 32).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[d_form_u(14, 8, 0, 2), d_form_u(44, 8, 7, 0), BLR],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(child_ptr + 6, mdef_handle)
.unwrap();
let return_address = loaded.cpu.lr;
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = 0x1234_0000);
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = 0x1234_1000);
loaded.cpu.gpr[3] = (10u32 << 16) | 12;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let root_rect = loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.dropdown_rect();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: root_rect.0 + 8,
mouse_h: root_rect.1 + 16,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(512);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let child_rect = tracking.submenus[0].dropdown_rect();
assert_eq!(child_rect.3 - child_rect.1, 72);
assert_eq!(child_rect.2 - child_rect.0, 32);
assert_eq!(
tracking.active_definition_pane(),
Some(MenuDefinitionPane::Submenu(0))
);
assert_eq!(tracking.active_definition().unwrap().menu_handle(), child);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(512);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert!(loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.submenus
.is_empty());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().caller_isa(),
Some(GuestIsa::PowerPc)
);
assert_eq!(*loaded.current_gworld, 0x1234_0000);
assert_eq!(*loaded.current_gdevice, 0x1234_1000);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: root_rect.0 + 8,
mouse_h: root_rect.1 + 16,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(512);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.active_definition_pane(),
Some(MenuDefinitionPane::Submenu(0))
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: child_rect.0 + 8,
mouse_h: child_rect.1 + 8,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.active_menu_definition()
.unwrap()
.which_item(),
2
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: child_rect.0 + 8,
mouse_h: child_rect.1 + 8,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
loaded
.toolbox_startup
.execution
.with_menu_state_mut(|state| {
assert_eq!(state.flash_result, (141u32 << 16) | 2);
state.flash_remaining = 1;
state.flash_deadline = state.flash_tick.unwrap_or(0);
})
.unwrap();
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], (141u32 << 16) | 2);
assert_eq!(loaded.cpu.lr, return_address);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().caller_isa(),
None
);
assert_eq!(*loaded.current_gworld, 0x1234_0000);
assert_eq!(*loaded.current_gdevice, 0x1234_1000);
}
#[test]
fn native_popup_menu_select_runs_custom_popup_draw_and_choose_sequence() {
for (top, left, requested_item) in [
(40i16, 30i16, 4i16),
(-40, -30, -1),
(i16::MIN, i16::MAX, 0),
] {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
132,
b"Custom",
b"Opaque definition data",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
PPC_CODE_BASE + 0x4000,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
d_form_u(14, 8, 0, 40),
d_form_u(44, 8, 5, 0),
d_form_u(14, 8, 0, 30),
d_form_u(44, 8, 5, 2),
d_form_u(14, 8, 0, 72),
d_form_u(44, 8, 5, 4),
d_form_u(14, 8, 0, 110),
d_form_u(44, 8, 5, 6),
d_form_u(14, 8, 0, 2),
d_form_u(44, 8, 7, 0),
BLR,
],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 0x1234_0000 | u32::from(top as u16);
loaded.cpu.gpr[5] = 0x5678_0000 | u32::from(left as u16);
loaded.cpu.gpr[6] = 0x9ABC_0000 | u32::from(requested_item as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 52,
mouse_h: 45,
..PpcInputSnapshot::default()
});
for _ in 0..32 {
if loaded.cpu.pc == PPC_CODE_BASE + 0x4000 {
break;
}
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(1);
assert_eq!(probe.unsupported_import_index, None);
}
assert_eq!(loaded.cpu.pc, PPC_CODE_BASE + 0x4000);
assert_eq!(loaded.cpu.gpr[3], 3);
assert_eq!(loaded.cpu.gpr[4], menu);
assert_eq!(
loaded.cpu.gpr[6],
(u32::from(top as u16) << 16) | u32::from(left as u16)
);
assert_eq!(
loaded.memory.read_u16_be(loaded.cpu.gpr[7]),
Some(requested_item as u16)
);
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(512);
assert_eq!(probe.handled_import_count, 0, "retained custom tracking bypasses public entry");
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.active_menu_definition()
.unwrap()
.which_item(),
2
);
assert_eq!(
loaded
.toolbox_startup
.active_menu_definition()
.unwrap()
.menu_rect(),
(40, 30, 72, 110)
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 52,
mouse_h: 45,
..PpcInputSnapshot::default()
});
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(512);
assert_eq!(probe.handled_import_count, 0, "retained custom tracking bypasses public entry");
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.flash_remaining,
6
);
let mut phases = vec![6];
for _ in 0..64 {
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(512);
assert_eq!(
probe.handled_import_count, 0,
"retained custom tracking bypasses public entry"
);
let remaining = loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map_or(0, |state| state.flash_remaining);
if phases.last() != Some(&remaining) {
phases.push(remaining);
}
if matches!(probe.result, PpcRunResult::Halted { .. }) {
break;
}
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert_eq!(phases, [6, 5, 4, 3, 2, 1, 0]);
assert_eq!(loaded.cpu.gpr[3], (132u32 << 16) | 2);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().definition,
None
);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_popup(),
None
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before)
);
}
}
#[test]
fn tracked_menu_resolves_icon_precedence_and_variable_rows_at_supported_depths() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let _menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Normal^1;Reduced^2/\x1d;Small^3/\x1e;Color^4;Script^5/\x1c",
);
loaded.set_current_resource_refnum(5);
let record = |res_type: [u8; 4], res_id: i16, data: Vec<u8>| PpcVfsResourceRecord {
ref_num: 5,
path: "Menu Icons".to_owned(),
res_type: u32::from_be_bytes(res_type),
res_id,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
};
let mut normal_icon = vec![0; 128];
normal_icon[0] = 0x80;
let mut reduced_icon = vec![0; 128];
reduced_icon[0] = 0x80;
let mut small_icon = vec![0; 32];
small_icon[0] = 0x80;
loaded.process_file_system.extend_vfs_resources([
record(*b"ICON", 257, normal_icon),
record(*b"ICON", 258, reduced_icon),
record(*b"SICN", 259, small_icon),
record(*b"ICON", 260, vec![0xff; 128]),
record(*b"cicn", 260, test_one_bit_cicon()),
record(*b"cicn", 261, test_one_bit_cicon()),
]);
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
ppc_track_menu_while_held_with_resources(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(
tracking
.item_appearances
.iter()
.map(|item| item.height)
.collect::<Vec<_>>(),
vec![34, 16, 16, 16, 16],
);
assert!(matches!(
tracking.item_appearances[0].icon,
Some(PpcTrackedMenuIcon::Icon { reduced: false, .. })
));
assert!(matches!(
tracking.item_appearances[1].icon,
Some(PpcTrackedMenuIcon::Icon { reduced: true, .. })
));
assert!(matches!(
tracking.item_appearances[2].icon,
Some(PpcTrackedMenuIcon::SmallIcon(_))
));
assert!(matches!(
tracking.item_appearances[3].icon,
Some(PpcTrackedMenuIcon::CIcon(_))
));
assert_eq!(
tracking.item_appearances[4].icon_kind,
StandardMenuIconKind::None,
"$1C makes the icon byte a script code even when a matching cicn exists",
);
assert_eq!(tracking.item_appearances[4].icon, None);
assert_eq!(tracking.popup_height, 98);
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
for item in 1..=3 {
let top = tracking.popup_top + ppc_tracked_menu_item_offset(&tracking, item);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(tracking.popup_left + 2), i32::from(top)),
),
Some(black),
"{depth}bpp item {item} icon did not draw",
);
assert_eq!(
ppc_menu_tracking_item(
&mut loaded.memory,
&tracking,
PpcInputSnapshot {
mouse_button: true,
mouse_v: top + ppc_tracked_menu_item_height(&tracking, item) / 2,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
},
),
item,
);
}
if depth > 1 {
let red = ppc_physical_screen_color_pixel(
front,
PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
},
&loaded.screen_clut,
)
.unwrap();
let top = tracking.popup_top + ppc_tracked_menu_item_offset(&tracking, 4);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(tracking.popup_left + 2), i32::from(top)),
),
Some(red),
"{depth}bpp cicn pixel did not map through its embedded ColorTable",
);
}
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
},
),
Some(0),
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before),
"{depth}bpp icon menu did not restore its save-under",
);
}
}
#[test]
fn tracked_submenu_aligns_after_a_variable_height_icon_row() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
install_test_menu(
&mut loaded,
scratch,
128,
b"File",
b"Icon^1;Parent/\x1b!\xc9",
);
loaded.memory.add_region(scratch + 0x200, vec![0; 0x200]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x200,
b"Recent",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x280,
b"Child",
));
let submenu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
201,
scratch + 0x200,
);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
submenu,
scratch + 0x280,
i16::MAX,
),
PPC_NO_ERR,
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
submenu,
-1,
),
PPC_NO_ERR,
);
loaded.set_current_resource_refnum(5);
let mut icon = vec![0; 128];
icon[0] = 0x80;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: 5,
path: "Menu Icons".to_owned(),
res_type: u32::from_be_bytes(*b"ICON"),
res_id: 257,
name: Vec::new(),
data: icon,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
ppc_track_menu_while_held_with_resources(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
);
let root = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(root.item_appearances[0].height, 34);
let parent_top = root.popup_top + root.item_appearances[0].height;
ppc_track_menu_while_held_with_resources(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: parent_top + 8,
mouse_h: root.popup_left + 20,
..PpcInputSnapshot::default()
},
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let child = tracking.submenus.first().expect("submenu did not open");
assert_eq!(tracking.highlighted_item, 2);
assert_eq!(child.popup_top, parent_top);
}
#[test]
fn menu_tracking_round_trips_unaligned_popup_boundaries_at_supported_depths() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Open/O!\x12;Disabled(;-;Parent/\x1b!\xc9",
);
let item_glyph_pixels = {
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, 'O').unwrap();
let mut pixels = Vec::new();
for row in 0..glyph.height as usize {
for col in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + col;
if index < data.len() && data[index] >= 128 {
pixels.push((
i32::from(glyph.origin_x) + col as i32,
i32::from(glyph.origin_y) + row as i32,
));
}
}
}
assert!(!pixels.is_empty());
pixels
};
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
assert_eq!(front.depth, depth);
let active_len = usize::try_from(front.row_bytes * front.height).unwrap();
let pattern = (0..active_len)
.map(|index| {
(index as u8)
.wrapping_mul(37)
.wrapping_add((depth as u8).wrapping_mul(11))
^ 0xa5
})
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let before = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(tracking.front_buffer, Some(front.into()));
assert_eq!(tracking.popup_left, STANDARD_MENU_BAR_FIRST_TITLE_LEFT);
assert_eq!(tracking.saved_width, tracking.popup_width + 1);
assert_eq!(tracking.saved_height, tracking.popup_height + 1);
assert_eq!(
tracking.saved_pixels.len(),
usize::try_from(i32::from(tracking.saved_width) * i32::from(tracking.saved_height))
.unwrap(),
);
if depth < 8 {
let pixels_per_byte = 8 / depth;
assert_ne!(
u32::try_from(tracking.popup_left).unwrap() % pixels_per_byte,
0,
"{depth}bpp popup did not exercise an unaligned packed boundary",
);
}
let opened = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
assert_ne!(opened, before, "{depth}bpp popup did not draw");
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left.saturating_add(1)),
i32::from(tracking.popup_top),
),
),
Some(white),
"{depth}bpp attached pull-down should not draw a separate top border",
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left),
i32::from(tracking.popup_top),
),
),
Some(black),
"{depth}bpp attached pull-down should retain its left frame",
);
let item_origin = (
i32::from(tracking.popup_left.saturating_add(15)),
i32::from(tracking.popup_top.saturating_add(11)),
);
let normal_item_ink = item_glyph_pixels
.iter()
.filter(|&&(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(item_origin.0 + dx, item_origin.1 + dy),
) == Some(black)
})
.count();
assert_eq!(
normal_item_ink,
item_glyph_pixels.len(),
"{depth}bpp popup item glyph did not draw in black",
);
let selected = PpcInputSnapshot {
mouse_button: true,
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_menu_tracking_item(&mut loaded.memory, &tracking, selected),
1,
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
selected,
);
let highlighted = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
assert_ne!(
highlighted, opened,
"{depth}bpp item highlight did not draw",
);
let highlighted_item_ink = item_glyph_pixels
.iter()
.filter(|&&(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(item_origin.0 + dx, item_origin.1 + dy),
) == Some(white)
})
.count();
assert_eq!(
highlighted_item_ink,
item_glyph_pixels.len(),
"{depth}bpp highlighted popup item glyph did not reverse to white",
);
let cancelled = PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
cancelled,
),
Some(0),
);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
),
Some(before),
"{depth}bpp cancellation did not round-trip the full framebuffer",
);
}
}
#[test]
fn menu_tracking_opens_selects_and_restores_hierarchical_submenu() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
install_test_menu(
&mut loaded,
scratch,
128,
b"File",
b"Parent/\x1b!\xc9;Cancel",
);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x100,
b"Recent",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x180,
b"First/F;Disabled(;Second/S",
));
let submenu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
201,
scratch + 0x100,
);
assert_ne!(submenu, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
submenu,
scratch + 0x180,
i16::MAX,
),
PPC_NO_ERR,
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
submenu,
-1,
),
PPC_NO_ERR,
);
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let active_len = usize::try_from(front.row_bytes * front.height).unwrap();
let pattern = (0..active_len)
.map(|index| (index as u8).wrapping_mul(29).wrapping_add(depth as u8))
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let before = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let root = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
let parent_hover = PpcInputSnapshot {
mouse_button: true,
mouse_v: root.popup_top + 8,
mouse_h: root.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
parent_hover,
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
let child = tracking.submenus.first().expect("submenu did not open");
assert_eq!(tracking.highlighted_item, 1);
assert_eq!(child.menu_handle, submenu);
assert_eq!(child.parent_item, 1);
assert_eq!(
child.popup_left,
tracking.popup_left + tracking.popup_width - 4
);
assert_eq!(child.popup_top, tracking.popup_top + 7);
let disabled_hover = PpcInputSnapshot {
mouse_button: true,
mouse_v: child.popup_top + 16 + 8,
mouse_h: child.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
disabled_hover,
);
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.and_then(|state| state.submenus.first())
.map(|child| child.highlighted_item),
Some(0),
);
let selected = PpcInputSnapshot {
mouse_v: child.popup_top + 8,
mouse_h: child.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
..selected
},
);
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
selected,
),
Some((201 << 16) | 1),
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(201));
let highlighted = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
assert_ne!(
highlighted, before,
"{depth}bpp root title was not highlighted"
);
assert!(draw_current_test_menu_bar(&mut loaded));
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
),
Some(highlighted),
"{depth}bpp DrawMenuBar lost the root title for submenu TheMenu",
);
let menu_list = ppc_current_menu_list(&mut loaded.memory);
ppc_set_menu_title_highlight(
&mut loaded.memory,
&loaded.gworlds,
menu_list,
0,
&loaded.screen_clut,
false,
);
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
),
Some(before.clone()),
"{depth}bpp submenu selection did not restore the framebuffer",
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
parent_hover,
);
assert!(loaded
.toolbox_startup
.execution.menu()
.as_ref()
.is_some_and(|state| !state.submenus.is_empty()));
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: 10,
mouse_h: i16::MAX,
..PpcInputSnapshot::default()
},
),
Some(0),
);
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
),
Some(before),
"{depth}bpp submenu cancellation did not restore the framebuffer",
);
}
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let menu_list = ppc_current_menu_list(&mut loaded.memory);
let parent_menu = ppc_menu_list_definition(&mut loaded.memory, menu_list)
.unwrap()
.regular_handles()
.next()
.unwrap();
let mut parent =
ppc_begin_menu_bar_tracking(&mut loaded.memory, front, parent_menu, 400).unwrap();
parent.popup_left = ppc_u32_to_i16_saturating(front.width).saturating_sub(10);
let flipped =
ppc_begin_submenu_tracking(&mut loaded.memory, menu_list, front, &parent, 1).unwrap();
assert_eq!(
flipped.popup_left,
ppc_u32_to_i16_saturating(front.width) - flipped.popup_width - 8,
);
ppc_restore_tracked_menu(&mut loaded.memory, Some(front.into()), &flipped);
}
#[test]
fn menu_tracking_selects_nested_submenus_and_restores_every_depth() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
install_test_menu(
&mut loaded,
scratch,
128,
b"Game",
b"Options/\x1b!\xc9;Cancel",
);
loaded.memory.add_region(scratch + 0x200, vec![0; 0x400]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x200,
b"Options",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x280,
b"Speed/\x1b!\xca;Plain",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x300,
b"Speed",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x380,
b"Cycle/\x1b!\xc9;Fast/F",
));
let options = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
201,
scratch + 0x200,
);
let speed = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
202,
scratch + 0x300,
);
for (menu, items) in [(options, scratch + 0x280), (speed, scratch + 0x380)] {
assert_ne!(menu, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu,
items,
i16::MAX,
),
PPC_NO_ERR,
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
-1,
),
PPC_NO_ERR,
);
}
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
for (selected, expected_root) in [(128, 128), (201, 128), (202, 128), (999, 0)] {
assert_eq!(
ppc_root_menu_id_for_selection(&mut loaded.memory, menu_list_handle, selected,),
expected_root,
);
}
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let active_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(active_len).unwrap())
.map(|index| (index as u8).wrapping_mul(43).wrapping_add(depth as u8))
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, active_len).unwrap();
let track = |loaded: &mut PpcLoadedApp, point: (i16, i16)| {
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: point.0,
mouse_h: point.1,
..PpcInputSnapshot::default()
},
);
};
track(&mut loaded, (10, 12));
let root = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
track(&mut loaded, (root.popup_top + 8, root.popup_left + 20));
let first = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(first.submenus.len(), 1);
assert_eq!(first.submenus[0].menu_handle, options);
let options_pane = first.submenus[0].clone();
track(
&mut loaded,
(options_pane.popup_top + 8, options_pane.popup_left + 20),
);
let nested = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(nested.submenus.len(), 2);
assert_eq!(nested.submenus[0].highlighted_item, 1);
assert_eq!(nested.submenus[1].menu_handle, speed);
track(
&mut loaded,
(
options_pane.popup_top + 16 + 8,
options_pane.popup_left + 20,
),
);
let switched = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(switched.submenus.len(), 1);
assert_eq!(switched.submenus[0].highlighted_item, 2);
track(
&mut loaded,
(options_pane.popup_top + 8, options_pane.popup_left + 20),
);
let reopened = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(reopened.submenus.len(), 2);
let speed_pane = reopened.submenus[1].clone();
track(
&mut loaded,
(speed_pane.popup_top + 8, speed_pane.popup_left + 20),
);
let cycle = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(cycle.submenus.len(), 2, "circular submenu grew the chain");
assert_eq!(cycle.submenus[1].highlighted_item, 1);
assert_eq!(
ppc_tracked_menu_selection(&mut loaded.memory, &cycle),
None,
"hierarchical parent became selectable",
);
let leaf = PpcInputSnapshot {
mouse_v: speed_pane.popup_top + 16 + 8,
mouse_h: speed_pane.popup_left + 20,
..PpcInputSnapshot::default()
};
track(&mut loaded, (leaf.mouse_v, leaf.mouse_h));
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
leaf,
),
Some((202 << 16) | 2),
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(202));
let menu_list = ppc_current_menu_list(&mut loaded.memory);
ppc_set_menu_title_highlight(
&mut loaded.memory,
&loaded.gworlds,
menu_list,
0,
&loaded.screen_clut,
false,
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, active_len),
Some(before),
"{depth}bpp nested menu did not restore every saved pane",
);
}
loaded.cpu.gpr[3] = u32::from(b'f');
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuKey);
assert_eq!(loaded.cpu.gpr[3], (202 << 16) | 2);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(202));
loaded
.toolbox_startup
.pending_native_menu_selection
.stage((202, 2));
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuSelect);
assert_eq!(loaded.cpu.gpr[3], (202 << 16) | 2);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(202));
}
#[test]
fn short_menu_bar_system_mark_does_not_bleed_below_the_bar() {
let pef = synthetic_pef_with_import(b"DrawMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, &[0x14], b"");
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded
.memory
.write_u16_be(PPC_MBAR_HEIGHT_ADDR, 12)
.unwrap();
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let active_len = usize::try_from(front.row_bytes * front.height).unwrap();
let sentinel = (0..active_len)
.map(|index| (index as u8).wrapping_mul(13) ^ 0x5a)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &sentinel)
.unwrap();
let below_bar = front.base_addr + front.row_bytes * 12;
let below_bar_len = front.row_bytes * front.height.saturating_sub(12);
let below_bar_before =
ppc_memory_read_bytes(&mut loaded.memory, below_bar, below_bar_len).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, below_bar, below_bar_len),
Some(below_bar_before),
"{depth}bpp system mark painted below MBarHeight=12",
);
let [red, green, blue] = crate::ui_art::RETRO_COMPUTER_MENU_MARK_PALETTE[0];
let outline = ppc_physical_screen_color_pixel(
front,
PpcRgbColor { red, green, blue },
&loaded.screen_clut,
)
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(
STANDARD_MENU_BAR_FIRST_TITLE_LEFT
+ STANDARD_MENU_BAR_TITLE_ORIGIN_INSET
+ 1,
),
0,
),
),
Some(outline),
"{depth}bpp system mark did not draw at its clipped top",
);
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (0, 11)),
Some(black),
"{depth}bpp short menu bar lost its bottom border",
);
}
}
#[test]
fn menu_tracking_uses_the_live_main_set_port_pix_destination() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
let scratch = PPC_DATA_BASE + 0x20_000;
let live_pixmap_handle = scratch;
let live_pixmap = scratch + 0x10;
let live_pixels = scratch + 0x100;
let live_width = 128u32;
let live_height = 96u32;
let live_row_bytes = live_width;
loaded.memory.add_region(scratch, vec![0; 0x4000]);
loaded
.memory
.write_u32_be(live_pixmap_handle, live_pixmap)
.unwrap();
ppc_write_pixmap(
&mut loaded.memory,
live_pixmap,
live_pixels,
live_row_bytes,
0,
0,
live_height as i16,
live_width as i16,
8,
)
.unwrap();
loaded
.memory
.write_u32_be(live_pixmap + 42, PPC_MAIN_CTABLE_HANDLE)
.unwrap();
let cached = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert_eq!(cached.base_addr, PPC_MAIN_SCREEN_BASE);
let cached_len = cached.row_bytes * cached.height;
loaded
.memory
.write_bytes(cached.base_addr, &vec![0x3c; cached_len as usize])
.unwrap();
let cached_before =
ppc_memory_read_bytes(&mut loaded.memory, cached.base_addr, cached_len).unwrap();
let live_len = live_row_bytes * live_height;
let live_pattern = (0..live_len as usize)
.map(|index| (index as u8).wrapping_mul(29) ^ 0x96)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(live_pixels, &live_pattern)
.unwrap();
ppc_set_port_bits(
&mut loaded.memory,
PPC_MAIN_GWORLD,
live_pixmap_handle,
true,
);
let live =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
assert_eq!(
live,
PpcFrontBuffer {
base_addr: live_pixels,
row_bytes: live_row_bytes,
width: live_width,
height: live_height,
depth: 8,
},
);
assert!(draw_current_test_menu_bar(&mut loaded));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, cached.base_addr, cached_len),
Some(cached_before.clone()),
"DrawMenuBar touched the stale cached main framebuffer",
);
let live_before =
ppc_memory_read_bytes(&mut loaded.memory, live.base_addr, live_len).unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(tracking.front_buffer, Some(live.into()));
let selected = PpcInputSnapshot {
mouse_button: true,
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
selected,
);
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, live.base_addr, live_len),
Some(live_before.clone()),
"tracked popup did not draw into the live main PixMap",
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, cached.base_addr, cached_len),
Some(cached_before.clone()),
"tracked popup touched the stale cached main framebuffer",
);
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
},
),
Some(0),
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, live.base_addr, live_len),
Some(live_before),
"live main PixMap did not round-trip after cancellation",
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, cached.base_addr, cached_len),
Some(cached_before),
"cancellation touched the stale cached main framebuffer",
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
}
#[test]
fn hle_import_runner_get_new_mbar_rejects_a_truncated_declared_menu_sequence() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 1001,
name: Vec::new(),
data: vec![0, 2, 0, 128],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 1001;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.test_resource_error(), PPC_RES_NOT_FOUND_ERR);
}
#[test]
fn hle_import_runner_builds_and_draws_mbar_resources() {
fn menu_resource(menu_id: i16, title: &[u8]) -> Vec<u8> {
let mut data = vec![0; 14];
data[0..2].copy_from_slice(&menu_id.to_be_bytes());
data[10..14].copy_from_slice(&u32::MAX.to_be_bytes());
data.push(title.len() as u8);
data.extend_from_slice(title);
data.push(0);
data
}
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 1000,
name: Vec::new(),
data: vec![0, 2, 0, 128, 0, 129],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 128,
name: Vec::new(),
data: menu_resource(128, &[0x14]),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 129,
name: Vec::new(),
data: {
let mut data = menu_resource(129, b"File");
data.pop();
data.extend_from_slice(&[4, b'O', b'p', b'e', b'n', 0, 0, 0, 0, 0]);
data
},
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 1000;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let menu_list_handle = loaded.cpu.gpr[3];
ppc_set_current_menu_list(&mut loaded.memory, menu_list_handle);
let menu_list = loaded.memory.read_u32_be(menu_list_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_list), Some(12));
assert_eq!(loaded.memory.read_u16_be(menu_list + 4), Some(1000));
let file_menu = ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 128);
assert_ne!(file_menu, 0);
assert_ne!(
ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 129),
0
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetMenu;
loaded.cpu.gpr[3] = 128;
let get_menu_probe = loaded.run_with_hle_imports(64);
assert_eq!(get_menu_probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], file_menu);
assert!(ppc_draw_menu_bar(
&mut loaded.memory,
&loaded.gworlds,
menu_list_handle,
&loaded.screen_clut,
));
let white = ppc_rgb_color_to_8bpp_index(PPC_RGB_WHITE);
let black = ppc_rgb_color_to_8bpp_index(PPC_RGB_BLACK);
assert_eq!(loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE), Some(black));
assert_eq!(loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE + 5), Some(white));
let mark_outline = pict::closest_clut_index(
crate::ui_art::RETRO_COMPUTER_MENU_MARK_PALETTE[0][0],
crate::ui_art::RETRO_COMPUTER_MENU_MARK_PALETTE[0][1],
crate::ui_art::RETRO_COMPUTER_MENU_MARK_PALETTE[0][2],
&loaded.screen_clut,
);
assert_eq!(
loaded
.memory
.read_u8(PPC_MAIN_SCREEN_BASE + 3 * ppc_main_screen_row_bytes() + 19),
Some(mark_outline)
);
assert_eq!(standard_menu_title_advance(&[0x14]), 11);
let snapshot = loaded.guest_menu_snapshot();
assert_eq!(snapshot.menus.len(), 2);
assert_eq!(snapshot.menus[0].title, "Systemless");
assert_eq!(snapshot.menus[1].title, "File");
assert_eq!(snapshot.menus[1].items[0].text, "Open");
assert!(loaded.queue_native_menu_selection(129, 1));
assert_eq!(
loaded.toolbox_startup.pending_native_menu_selection,
Some((129, 1))
);
let popup_probe = PPC_MAIN_SCREEN_BASE + 20 * ppc_main_screen_row_bytes() + 35;
let popup_before = loaded.memory.read_u8(popup_probe).unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
42,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 42,
..PpcInputSnapshot::default()
},
);
assert!(loaded.toolbox_startup.execution.menu().is_some());
assert_ne!(loaded.memory.read_u8(popup_probe), Some(popup_before));
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: 23,
mouse_h: 42,
..PpcInputSnapshot::default()
},
),
Some((129 << 16) | 1)
);
assert_eq!(loaded.memory.read_u8(popup_probe), Some(popup_before));
assert_eq!(
loaded
.memory
.read_u8(PPC_MAIN_SCREEN_BASE + 19 * ppc_main_screen_row_bytes()),
Some(black)
);
assert!((3..19).any(|y| {
(42..100).any(|x| {
loaded
.memory
.read_u8(PPC_MAIN_SCREEN_BASE + y * ppc_main_screen_row_bytes() + x)
== Some(black)
})
}));
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
}
#[test]
fn menu_tracking_rejects_disabled_items_and_dividers_and_clears_cancellation() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 0x100]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch,
b"File"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x20,
b"Open;Disabled(;\x2d"
));
let menu_handle = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
128,
scratch,
);
assert_ne!(menu_handle, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu_handle,
scratch + 0x20,
i16::MAX,
),
PPC_NO_ERR
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu_handle,
0,
),
PPC_NO_ERR
);
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
assert!(ppc_draw_menu_bar(
&mut loaded.memory,
&loaded.gworlds,
menu_list_handle,
&loaded.screen_clut,
));
let menu_bar_len = u32::from(loaded.memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap())
* ppc_main_screen_row_bytes();
let unhighlighted_bar =
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_len).unwrap();
for (label, item) in [("disabled item", 2i16), ("divider", 3i16)] {
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let input = PpcInputSnapshot {
mouse_button: true,
mouse_v: tracking.popup_top + (item - 1) * 16 + 4,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
};
let background_point = (i32::from(input.mouse_h), i32::from(input.mouse_v));
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let background = ppc_quickdraw_read_pixel(&mut loaded.memory, front, background_point);
assert_eq!(
ppc_menu_tracking_item(&mut loaded.memory, tracking, input),
0,
"{label} became the tracked selection"
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
input,
);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, background_point),
background,
"{label} was drawn highlighted"
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
input,
),
Some(0),
"{label} was returned as a menu choice"
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_len),
Some(unhighlighted_bar.clone()),
"{label} cancellation left the title highlighted"
);
}
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let outside = PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
outside,
),
Some(0)
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_len),
Some(unhighlighted_bar.clone())
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let enabled = PpcInputSnapshot {
mouse_v: tracking.popup_top + 6,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
enabled,
),
Some((128u32 << 16) | 1)
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_len),
Some(unhighlighted_bar),
"a valid choice did not retain its documented title highlight"
);
}
#[test]
fn import_bindings_classify_menu_bar_imports() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetMenuBar"),
PpcImportDispatcherTarget::GetMenuBar
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetNewMBar"),
PpcImportDispatcherTarget::GetNewMBar
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ClearMenuBar"),
PpcImportDispatcherTarget::ClearMenuBar
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetMenuBar"),
PpcImportDispatcherTarget::SetMenuBar
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetMenuHandle"),
PpcImportDispatcherTarget::GetMenuHandle
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DrawMenuBar"),
PpcImportDispatcherTarget::DrawMenuBar
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FlashMenuBar"),
PpcImportDispatcherTarget::FlashMenuBar
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetMenuFlash"),
PpcImportDispatcherTarget::SetMenuFlash
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMGetMenuFlash"),
PpcImportDispatcherTarget::LMGetMenuFlash
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMGetDefltStack"),
PpcImportDispatcherTarget::LMGetDefltStack
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMGetCurStackBase"),
PpcImportDispatcherTarget::LMGetCurStackBase
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMSetMenuFlash"),
PpcImportDispatcherTarget::SetMenuFlash
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "InvalMenuBar"),
PpcImportDispatcherTarget::InvalMenuBar
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "AppendResMenu"),
PpcImportDispatcherTarget::AppendResMenu
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "AddResMenu"),
PpcImportDispatcherTarget::AppendResMenu
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "InsertResMenu"),
PpcImportDispatcherTarget::InsertResMenu
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HMGetHelpMenuHandle"),
PpcImportDispatcherTarget::HMGetHelpMenuHandle
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "MenuChoice"),
PpcImportDispatcherTarget::MenuChoice
);
}
#[test]
fn native_inval_menu_bar_defers_and_coalesces_one_draw_until_an_event_scan() {
let pef = synthetic_pef_with_import(b"InvalMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
assert!(ppc_quickdraw_write_pixel(
&mut loaded.memory,
front,
(100, 5),
PPC_RGB_BLACK,
));
let dirty = ppc_quickdraw_read_pixel(&mut loaded.memory, front, (100, 5));
run_test_import(&mut loaded, PpcImportDispatcherTarget::InvalMenuBar);
run_test_import(&mut loaded, PpcImportDispatcherTarget::InvalMenuBar);
assert!(loaded.event_queue.menu_bar_is_invalid());
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 0);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (100, 5)),
dirty,
"InvalMenuBar must not draw synchronously"
);
let event = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(event, vec![0xaa; 16]);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::OSEventAvail);
assert!(
loaded.event_queue.menu_bar_is_invalid(),
"low-level OS event scans must not consume Toolbox redraw work"
);
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 0);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = event;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::GetNextEvent),
);
assert!(!loaded.event_queue.menu_bar_is_invalid());
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 1);
assert_ne!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (100, 5)),
dirty,
"the next Toolbox event scan must perform DrawMenuBar"
);
assert!(ppc_quickdraw_write_pixel(
&mut loaded.memory,
front,
(100, 5),
PPC_RGB_BLACK,
));
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = event;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::GetNextEvent),
);
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 1);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (100, 5)),
dirty,
"the deferred redraw must be consumed exactly once"
);
run_test_import(&mut loaded, PpcImportDispatcherTarget::InvalMenuBar);
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
assert!(!loaded.event_queue.menu_bar_is_invalid());
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 2);
}
#[test]
fn process_owner_shares_one_retained_menu_continuation_between_adapters() {
let (prepared, mut classic_cpu, mut classic_bus) = setup_with_port();
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
let mut classic = TrapDispatcher::new_with_migrated_handles(context.migrated_handles());
classic
.scrap
.set_clipboard_writable(prepared.scrap.clipboard_writable_for_test());
let (base, row_bytes, width, height, depth) = prepared.screen_mode;
classic.set_screen_mode_for_test(base, row_bytes, width, height, depth);
classic.read_tick_count(&classic_bus);
classic.attach_unconverted_process_services(&mut context);
let plan = native
.preflight_migrated_services(&context, classic_bus.read_long(0x016a))
.unwrap();
native.commit_migrated_services(&context, plan);
native.attach_unconverted_process_services(&mut context);
let mut tracking = crate::menu_manager::test_process_menu_tracking(0x0012_3456);
tracking.highlighted_item = 2;
context.set_menu_tracking(Some(tracking));
classic.menu_tracking.with_context_mut(|menu_context| {
menu_context.call = Some(MenuTrackingCall {
request: MenuTrackingRequest::MenuSelect { initial_point: 0 },
origin: MenuTrackingOrigin::M68k {
stack_pointer: TEST_SP,
return_address: 0x1234,
},
});
});
// A drawing surface cannot turn a classic operation into a native one.
let native_front = native.current_front_buffer().unwrap();
context
.with_menu_tracking_mut(|tracking| tracking.front_buffer = Some(native_front.into()))
.unwrap();
assert_eq!(
classic
.menu_tracking
.as_ref()
.map(|tracking| (tracking.menu_handle, tracking.highlighted_item)),
Some((0x0012_3456, 2))
);
assert_eq!(
context
.menu_tracking()
.map(|tracking| (tracking.menu_handle, tracking.highlighted_item)),
Some((0x0012_3456, 2))
);
native.cpu.gpr[3] = 0;
run_test_import(&mut native, PpcImportDispatcherTarget::MenuSelect);
assert!(native.is_constructed_from_migrated_handles(&context.migrated_handles()));
native
.toolbox_startup
.execution
.with_menu_state_mut(|tracking| tracking.highlighted_item = 4)
.unwrap();
assert_eq!(classic.menu_tracking.as_ref().unwrap().highlighted_item, 4);
assert_eq!(
context
.menu_tracking()
.map(|tracking| tracking.highlighted_item),
Some(4)
);
let call = ppc_menu_select_call(&native.cpu, 0);
native
.toolbox_startup
.execution
.with_menu_context_mut(|context| context.call = Some(call));
// Nor can an absent native surface turn its caller into a classic one.
context
.with_menu_tracking_mut(|tracking| tracking.front_buffer = None)
.unwrap();
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_bus.write_long(TEST_SP, 0);
classic_bus.write_long(TEST_SP + 4, u32::MAX);
assert!(classic
.dispatch_menu(true, 0x13D, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_long(TEST_SP + 4), 0);
assert_eq!(
context.menu_tracking().map(|tracking| tracking.menu_handle),
Some(0x0012_3456),
"the classic slice must retain the process-owned continuation"
);
context.take_menu_tracking();
assert!(classic.menu_tracking.is_none());
assert!(native.toolbox_startup.execution.menu().is_none());
assert!(native.is_constructed_from_migrated_handles(&context.migrated_handles()));
}
#[test]
fn attached_68k_and_powerpc_event_adapters_share_fifo_and_menu_bar_invalidation() {
let (mut classic, _, _) = setup_with_port();
let pef = synthetic_pef_with_import(b"InvalMenuBar");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
assert!(!context.event_queue().menu_bar_is_invalid());
classic.event_queue.push_back(QueuedEvent {
what: 1,
message: 0x1111,
when: 0,
where_v: 10,
where_h: 20,
modifiers: 0,
});
native.event_queue.push_back(QueuedEvent {
what: 2,
message: 0x2222,
when: 0,
where_v: 30,
where_h: 40,
modifiers: 0,
});
classic.event_queue.invalidate_menu_bar();
assert_eq!(context.event_queue().len(), 2);
assert_eq!(native.event_queue.get(0).unwrap().message, 0x1111);
assert_eq!(native.event_queue.get(1).unwrap().message, 0x2222);
assert!(context.event_queue().menu_bar_is_invalid());
assert_eq!(native.event_queue.pop_front().unwrap().message, 0x1111);
assert_eq!(classic.event_queue.front().unwrap().message, 0x2222);
assert!(native.event_queue.take_menu_bar_invalidation());
assert_eq!(context.event_queue().len(), 1);
assert!(!context.event_queue().menu_bar_is_invalid());
}
#[test]
fn attached_event_launch_state_shares_native_first_and_classic_first_oapp_once() {
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let pef = synthetic_pef_with_import(b"GetNextEvent");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
assert!(classic
.apple_event_launch_state
.ptr_eq(&native.apple_events.apple_event_launch_state));
let low_memory = classic_bus
.shared_ram_region(0, 0x0010_0000)
.expect("classic adapter owns low memory");
context.attach_memory(0, low_memory, &mut native.memory);
let native_event = PPC_DATA_BASE + 0x3000;
native.memory.add_region(native_event, vec![0; 16]);
let classic_event = 0x0020_0000;
let detached = native.apple_events.apple_event_launch_state.clone();
// Native-first: the classic gateway must observe the same claimed
// OAPP after native GetNextEvent consumes it.
classic
.apple_event_launch_state
.reset_for_launch(true);
native.cpu.gpr[3] = u32::from(PPC_HIGH_LEVEL_EVENT_MASK);
native.cpu.gpr[4] = native_event;
run_test_import(
&mut native,
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::GetNextEvent),
);
assert_eq!(native.cpu.gpr[3], 1);
assert!(context.event_queue().is_empty());
assert!(classic
.apple_event_launch_state
.is_open_application_event_sent());
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_bus.write_long(TEST_SP, classic_event);
classic_bus.write_word(TEST_SP + 4, u32::from(PPC_HIGH_LEVEL_EVENT_MASK) as u16);
classic_bus.write_word(TEST_SP + 6, 0xbeef);
assert!(classic
.dispatch_toolbox(true, 0x170, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_word(TEST_SP + 6), 0);
assert_eq!(classic_bus.read_word(classic_event), 0);
assert!(context.event_queue().is_empty());
// Classic-first: reset only the process launch state, then make the
// native gateway poll after classic GetNextEvent consumed OAPP.
classic
.apple_event_launch_state
.reset_for_launch(true);
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_bus.write_long(TEST_SP, classic_event);
classic_bus.write_word(TEST_SP + 4, u32::from(PPC_HIGH_LEVEL_EVENT_MASK) as u16);
classic_bus.write_word(TEST_SP + 6, 0);
assert!(classic
.dispatch_toolbox(true, 0x170, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_word(TEST_SP + 6), 0x0100);
assert_eq!(classic_bus.read_word(classic_event), 23);
assert!(context.event_queue().is_empty());
native.cpu.gpr[3] = u32::from(PPC_HIGH_LEVEL_EVENT_MASK);
native.cpu.gpr[4] = native_event;
run_test_import(
&mut native,
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::GetNextEvent),
);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(native.memory.read_u16_be(native_event), Some(0));
assert!(context.event_queue().is_empty());
assert!(!detached.is_high_level_event_aware());
assert!(!detached.is_open_application_event_sent());
}
#[test]
fn attached_event_launch_state_shares_eventavail_peek_without_duplicate_oapp() {
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let pef = synthetic_pef_with_import(b"EventAvail");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let low_memory = classic_bus
.shared_ram_region(0, 0x0010_0000)
.expect("classic adapter owns low memory");
context.attach_memory(0, low_memory, &mut native.memory);
let native_event = PPC_DATA_BASE + 0x3100;
native.memory.add_region(native_event, vec![0; 16]);
let classic_event = 0x0020_0000;
classic
.apple_event_launch_state
.reset_for_launch(true);
native.cpu.gpr[3] = u32::from(PPC_HIGH_LEVEL_EVENT_MASK);
native.cpu.gpr[4] = native_event;
run_test_import(&mut native, PpcImportDispatcherTarget::EventAvail);
assert_eq!(native.cpu.gpr[3], 1);
assert_eq!(context.event_queue().len(), 1);
assert_eq!(native.memory.read_u16_be(native_event), Some(23));
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_bus.write_long(TEST_SP, classic_event);
classic_bus.write_word(TEST_SP + 4, u32::from(PPC_HIGH_LEVEL_EVENT_MASK) as u16);
classic_bus.write_word(TEST_SP + 6, 0);
assert!(classic
.dispatch_toolbox(true, 0x171, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_word(TEST_SP + 6), 0x0100);
assert_eq!(classic_bus.read_word(classic_event), 23);
assert_eq!(context.event_queue().len(), 1);
native.cpu.gpr[3] = u32::from(PPC_HIGH_LEVEL_EVENT_MASK);
native.cpu.gpr[4] = native_event;
run_test_import(&mut native, PpcImportDispatcherTarget::EventAvail);
assert_eq!(native.cpu.gpr[3], 1);
assert_eq!(context.event_queue().len(), 1);
assert!(native
.apple_events
.apple_event_launch_state
.is_open_application_event_sent());
}
#[test]
fn attached_event_launch_state_requires_awareness_and_high_level_mask() {
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let pef = synthetic_pef_with_import(b"GetNextEvent");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let low_memory = classic_bus
.shared_ram_region(0, 0x0010_0000)
.expect("classic adapter owns low memory");
context.attach_memory(0, low_memory, &mut native.memory);
let native_event = PPC_DATA_BASE + 0x3200;
native.memory.add_region(native_event, vec![0; 16]);
let classic_event = 0x0020_0000;
classic
.apple_event_launch_state
.reset_for_launch(false);
native.cpu.gpr[3] = u32::from(PPC_HIGH_LEVEL_EVENT_MASK);
native.cpu.gpr[4] = native_event;
run_test_import(
&mut native,
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::GetNextEvent),
);
assert_eq!(native.cpu.gpr[3], 0);
assert!(!native
.apple_events
.apple_event_launch_state
.is_open_application_event_sent());
assert!(context.event_queue().is_empty());
classic
.apple_event_launch_state
.reset_for_launch(true);
native.cpu.gpr[3] = 0x0008;
native.cpu.gpr[4] = native_event;
run_test_import(
&mut native,
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::GetNextEvent),
);
assert_eq!(native.cpu.gpr[3], 0);
assert!(!native
.apple_events
.apple_event_launch_state
.is_open_application_event_sent());
assert!(context.event_queue().is_empty());
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_bus.write_long(TEST_SP, classic_event);
classic_bus.write_word(TEST_SP + 4, 0x0008);
classic_bus.write_word(TEST_SP + 6, 0xbeef);
assert!(classic
.dispatch_toolbox(true, 0x170, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_word(TEST_SP + 6), 0);
assert!(!classic
.apple_event_launch_state
.is_open_application_event_sent());
assert!(context.event_queue().is_empty());
}
#[test]
fn attached_68k_and_powerpc_adapters_share_live_input_without_runner_copy() {
let (mut classic, _, _) = setup_with_port();
let pef = synthetic_pef_with_import(b"Button");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let detached = native.clone();
classic.input_state.set_mouse_position_for_test((123, 456));
classic.input_state.set_mouse_button_for_test(true);
classic.input_state.set_key_map_byte_for_test(6, 0x20);
assert_eq!(
native.current_input_snapshot(),
PpcInputSnapshot {
key_map: {
let mut key_map = [0; 16];
key_map[6] = 0x20;
key_map
},
mouse_button: true,
mouse_v: 123,
mouse_h: 456,
}
);
let probe = native.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(native.cpu.gpr[3], 1);
native.process_input.set_mouse_position_for_test((-20, 99));
native.process_input.set_mouse_button_for_test(false);
native.process_input.set_key_map_byte_for_test(1, 0x08);
assert!(classic.input_state.ptr_eq(&native.process_input));
assert_eq!(classic.input_state.mouse_position(), (-20, 99));
assert!(!classic.input_state.mouse_button_pressed());
assert_eq!(classic.input_state.key_map_snapshot()[1], 0x08);
assert!(!native.process_input.ptr_eq(&detached.process_input));
assert_eq!(detached.current_input_snapshot(), PpcInputSnapshot::default());
}
#[test]
fn attached_68k_and_powerpc_adapters_share_display_color_state_without_runner_copy() {
let (mut classic, _, _) = setup_with_port();
let pef = synthetic_pef_with_import(b"GetCTable");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let detached = native.clone();
native.screen_clut.set_entry(7, [0x1111, 0x2222, 0x3333]);
native.color_manager_clut.set_entry(9, [0x4444, 0x5555, 0x6666]);
let mut native_gamma = native.display_gamma.table();
native_gamma[1][42] = 0x7f;
native.display_gamma.install(native_gamma);
assert!(classic.device_clut.ptr_eq(&native.screen_clut));
assert!(classic
.color_manager_clut
.ptr_eq(&native.color_manager_clut));
assert!(classic.display_gamma.ptr_eq(&native.display_gamma));
assert_eq!(classic.device_clut[7], [0x1111, 0x2222, 0x3333]);
assert_eq!(classic.color_manager_clut[9], [0x4444, 0x5555, 0x6666]);
assert_eq!(classic.display_gamma.table()[1][42], 0x7f);
assert!(classic.display_gamma.is_explicit());
classic.device_clut.set_entry(3, [0xaaaa, 0xbbbb, 0xcccc]);
let mut classic_gamma = classic.display_gamma.table();
classic_gamma[2][99] = 0x55;
classic.display_gamma.install(classic_gamma);
assert_eq!(native.screen_clut[3], [0xaaaa, 0xbbbb, 0xcccc]);
assert_eq!(native.display_gamma.table()[2][99], 0x55);
assert!(!native.screen_clut.ptr_eq(&detached.screen_clut));
assert!(!native.display_gamma.ptr_eq(&detached.display_gamma));
assert_eq!(
detached.screen_clut,
crate::display::standard_mac_8bpp_clut()
);
assert_eq!(
detached.display_gamma.table(),
crate::display::default_display_gamma()
);
assert!(!detached.display_gamma.is_explicit());
}
#[test]
fn attached_68k_and_powerpc_adapters_share_quickdraw_selection_without_runner_copy() {
let (mut classic, _, mut classic_bus) = setup_with_port();
let pef = synthetic_pef_with_import(b"GetGWorld");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let detached = native.clone();
assert!(classic.current_port.ptr_eq(&native.current_gworld));
assert!(classic
.current_gdevice
.ptr_eq(&native.current_gdevice));
assert_eq!(*classic.current_port, PPC_MAIN_GWORLD);
assert_eq!(*classic.current_gdevice, PPC_MAIN_GDEVICE);
classic.main_gdevice_handle = 0;
let classic_main_gdevice = classic.ensure_main_gdevice(&mut classic_bus);
assert_ne!(classic_main_gdevice, PPC_MAIN_GDEVICE);
assert_eq!(*classic.current_gdevice, PPC_MAIN_GDEVICE);
native
.current_gworld
.with_mut(|current_gworld| *current_gworld = 0x0030_0000);
native
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = 0x0030_1000);
assert_eq!(*classic.current_port, 0x0030_0000);
assert_eq!(*classic.current_gdevice, 0x0030_1000);
classic
.current_port
.with_mut(|current_port| *current_port = 0x0040_0000);
classic
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = 0x0040_1000);
assert_eq!(*native.current_gworld, 0x0040_0000);
assert_eq!(*native.current_gdevice, 0x0040_1000);
assert!(!native.current_gworld.ptr_eq(&detached.current_gworld));
assert!(!native.current_gdevice.ptr_eq(&detached.current_gdevice));
assert_eq!(*detached.current_gworld, PPC_MAIN_GWORLD);
assert_eq!(*detached.current_gdevice, PPC_MAIN_GDEVICE);
}
#[test]
fn attached_quickdraw_port_draw_state_crosses_isa_immediately() {
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let mut native =
load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let low_memory = classic_bus
.shared_ram_region(0, 0x0010_0000)
.expect("classic adapter owns low memory");
context.attach_memory(0, low_memory, &mut native.memory);
let process_port = 0x0003_0000;
initialize_test_cgraf_port(&mut classic_bus, process_port);
native
.current_gworld
.with_mut(|current_gworld| *current_gworld = process_port);
let classic_color = 0x0002_8000;
classic_bus.write_word(classic_color, 0x1111);
classic_bus.write_word(classic_color + 2, 0x2222);
classic_bus.write_word(classic_color + 4, 0x3333);
classic_bus.write_word(TEST_SP, 23);
classic_bus.write_word(TEST_SP + 2, 17);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_quickdraw(true, 0x093, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
classic_bus.write_word(TEST_SP, 2);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_quickdraw(true, 0x089, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
classic_bus.write_word(TEST_SP, 18);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_quickdraw(true, 0x08a, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
classic_bus.write_long(TEST_SP, classic_color);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_quickdraw(true, 0x214, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
let native_output = PPC_DATA_BASE + 0x2800;
native.memory.add_region(native_output, vec![0; 16]);
native.cpu.gpr[3] = native_output;
run_test_import(&mut native, PpcImportDispatcherTarget::GetPen);
assert_eq!(native.memory.read_u16_be(native_output), Some(23));
assert_eq!(native.memory.read_u16_be(native_output + 2), Some(17));
native.cpu.gpr[3] = native_output;
run_test_import(&mut native, PpcImportDispatcherTarget::GetForeColor);
assert_eq!(
ppc_read_rgb_color(&mut native.memory, native_output),
Some(PpcRgbColor {
red: 0x1111,
green: 0x2222,
blue: 0x3333,
})
);
assert_eq!(native.quickdraw_text_mode, 2);
assert_eq!(native.quickdraw_text_size, 18);
native.cpu.gpr[3] = 41;
native.cpu.gpr[4] = 29;
run_test_import(&mut native, PpcImportDispatcherTarget::MoveTo);
let native_color = PpcRgbColor {
red: 0xaaaa,
green: 0xbbbb,
blue: 0xcccc,
};
ppc_write_rgb_color(&mut native.memory, native_output, native_color).unwrap();
native.cpu.gpr[3] = native_output;
run_test_import(&mut native, PpcImportDispatcherTarget::RGBForeColor);
native.cpu.gpr[3] = 4;
run_test_import(&mut native, PpcImportDispatcherTarget::TextMode);
let classic_output = 0x0002_8100;
classic_bus.write_long(TEST_SP, classic_output);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_quickdraw(true, 0x09a, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_word(classic_output), 29);
assert_eq!(classic_bus.read_word(classic_output + 2), 41);
classic_bus.write_long(TEST_SP, classic_output);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_quickdraw(true, 0x219, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_word(classic_output), native_color.red);
assert_eq!(classic_bus.read_word(classic_output + 2), native_color.green);
assert_eq!(classic_bus.read_word(classic_output + 4), native_color.blue);
assert_eq!(classic.tx_mode, 4);
}
#[test]
fn attached_quickdraw_port_state_is_per_port_and_detaches_with_clone() {
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let mut native =
load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let low_memory = classic_bus
.shared_ram_region(0, 0x0010_0000)
.expect("classic adapter owns low memory");
context.attach_memory(0, low_memory, &mut native.memory);
let main_port = 0x0003_0000;
let second_port = 0x0003_1000;
initialize_test_cgraf_port(&mut classic_bus, main_port);
initialize_test_cgraf_port(&mut classic_bus, second_port);
classic.cport_ports.insert(main_port);
classic.cport_ports.insert(second_port);
native
.current_gworld
.with_mut(|current_gworld| *current_gworld = main_port);
native.cpu.gpr[3] = second_port;
run_test_import(&mut native, PpcImportDispatcherTarget::SetPort);
native.cpu.gpr[3] = 71;
native.cpu.gpr[4] = 53;
run_test_import(&mut native, PpcImportDispatcherTarget::MoveTo);
native.cpu.gpr[3] = main_port;
run_test_import(&mut native, PpcImportDispatcherTarget::SetPort);
native.cpu.gpr[3] = 19;
native.cpu.gpr[4] = 11;
run_test_import(&mut native, PpcImportDispatcherTarget::MoveTo);
classic_bus.write_long(TEST_SP, second_port);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_quickdraw(true, 0x073, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
let classic_output = 0x0002_8200;
classic_bus.write_long(TEST_SP, classic_output);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_quickdraw(true, 0x09a, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_word(classic_output), 53);
assert_eq!(classic_bus.read_word(classic_output + 2), 71);
let mut detached = native.clone();
detached
.memory
.write_u16_be(second_port + PPC_CGRAF_PORT_PN_LOC_OFFSET, 101)
.unwrap();
detached
.memory
.write_u16_be(second_port + PPC_CGRAF_PORT_PN_LOC_OFFSET + 2, 103)
.unwrap();
let detached_output = PPC_DATA_BASE + 0x2a00;
detached.memory.add_region(detached_output, vec![0; 4]);
detached.cpu.gpr[3] = detached_output;
run_test_import(&mut detached, PpcImportDispatcherTarget::GetPen);
assert_eq!(detached.memory.read_u16_be(detached_output), Some(101));
assert_eq!(detached.memory.read_u16_be(detached_output + 2), Some(103));
native.cpu.gpr[3] = detached_output;
native.memory.add_region(detached_output, vec![0; 4]);
run_test_import(&mut native, PpcImportDispatcherTarget::GetPen);
assert_eq!(native.memory.read_u16_be(detached_output), Some(53));
assert_eq!(native.memory.read_u16_be(detached_output + 2), Some(71));
}
#[test]
fn attached_quickdraw_pixel_states_cross_isa_and_detach_with_clone() {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 6-32--6-38:
// the PixMapHandle state word is process-visible independently of
// which CPU gateway performs LockPixels or SetPixelsState.
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let mut native =
load_pef_application(&synthetic_pef_with_import(b"GetPixelsState")).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
assert!(classic
.gworld_pixel_states
.ptr_eq(&native.gworld_pixel_states));
let detached = native.clone();
assert!(!native
.gworld_pixel_states
.ptr_eq(&detached.gworld_pixel_states));
let pmh = PPC_MAIN_PIXMAP_HANDLE;
assert_eq!(native.gworld_pixel_states.quickdraw_pixel_state(pmh), 0);
// Classic SetPixelsState publishes keepLocal + pixelsPurgeable to
// the process registry; native GetPixelsState must observe both bits.
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_cpu.write_reg(Register::D0, 0x0008_000E);
classic_bus.write_long(TEST_SP, (1 << 3) | (1 << 6));
classic_bus.write_long(TEST_SP + 4, pmh);
assert!(classic
.dispatch_quickdraw(true, 0x31D, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(native.gworld_pixel_states.quickdraw_pixel_state(pmh), 0x48);
native.cpu.gpr[3] = pmh;
run_test_import(&mut native, PpcImportDispatcherTarget::LockPixels);
assert_eq!(native.cpu.gpr[3], 1);
assert_eq!(native.gworld_pixel_states.quickdraw_pixel_state(pmh), 0xc8);
// The classic selector sees the native LockPixels transition through
// the same attached process handle.
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_cpu.write_reg(Register::D0, 0x0004_000D);
classic_bus.write_long(TEST_SP, pmh);
classic_bus.write_long(TEST_SP + 4, 0);
assert!(classic
.dispatch_quickdraw(true, 0x31D, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_long(TEST_SP + 4), 0xc8);
native.cpu.gpr[3] = pmh;
run_test_import(&mut native, PpcImportDispatcherTarget::NoPurgePixels);
assert_eq!(native.gworld_pixel_states.quickdraw_pixel_state(pmh), 0x88);
assert_eq!(detached.gworld_pixel_states.quickdraw_pixel_state(pmh), 0);
}
#[test]
fn attached_quickdraw_error_crosses_isa_and_detaches_with_clone() {
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let mut native =
load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let mut detached = native.clone();
assert!(classic
.quickdraw_error
.ptr_eq(&native.toolbox_startup.last_quickdraw_error));
assert!(!classic
.quickdraw_error
.ptr_eq(&detached.toolbox_startup.last_quickdraw_error));
native
.toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = PPC_PARAM_ERR);
classic_bus.write_word(TEST_SP, 0);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_quickdraw(true, 0x240, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_word(TEST_SP) as i16, PPC_PARAM_ERR);
classic
.quickdraw_error
.with_mut(|error| *error = PPC_C_RES_ERR);
run_test_import(&mut native, PpcImportDispatcherTarget::QDError);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_C_RES_ERR));
run_test_import(&mut detached, PpcImportDispatcherTarget::QDError);
assert_eq!(detached.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
detached
.toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = PPC_MEM_FULL_ERR);
assert_eq!(*classic.quickdraw_error, PPC_C_RES_ERR);
assert_eq!(*native.toolbox_startup.last_quickdraw_error, PPC_C_RES_ERR);
}
#[test]
fn attached_ppc_event_queue_remains_shared_through_panic() {
let pef = synthetic_pef_with_import(b"InvalMenuBar");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
context.shared_event_queue().push_back(QueuedEvent {
what: 1,
message: 0x1111,
when: 0,
where_v: 10,
where_h: 20,
modifiers: 0,
});
native.attach_unconverted_process_services(&mut context);
let panic_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
native.event_queue.push_back(QueuedEvent {
what: 2,
message: 0x2222,
when: 0,
where_v: 30,
where_h: 40,
modifiers: 0,
});
native.event_queue.invalidate_menu_bar();
panic!("simulated panic inside PPC guest execution");
}));
assert!(panic_result.is_err());
assert_eq!(context.event_queue().len(), 2);
assert_eq!(context.event_queue().get(0).unwrap().message, 0x1111);
assert_eq!(context.event_queue().get(1).unwrap().message, 0x2222);
assert!(context.event_queue().menu_bar_is_invalid());
assert_eq!(native.event_queue.len(), 2);
assert!(native.event_queue.menu_bar_is_invalid());
}
#[test]
fn attached_native_adapters_share_process_file_mutations_immediately() {
let pef = synthetic_pef_with_import(b"GetEOF");
let mut first = load_pef_application(&pef).unwrap();
first.push_test_vfs_file(PpcVfsFileRecord {
path: "Shared Data".to_string(),
data: (b"first".to_vec()).into(),
creator: 0,
file_type: 0,
finder_flags: 0,
dirty: false,
});
let mut second = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
first.attach_unconverted_process_services(&mut context);
second.attach_unconverted_process_services(&mut context);
assert!(first
.process_file_system
.ptr_eq(&second.process_file_system));
second
.with_test_vfs_file_mut(0, |file| {
file.data
.with_mut(|data| data.extend_from_slice(b"-second"));
})
.expect("seeded shared file");
second.push_test_deleted_vfs_file_path("Obsolete Data".to_string());
second.push_vfs_resource(PpcVfsResourceRecord {
ref_num: 128,
path: "Shared Data".to_string(),
res_type: u32::from_be_bytes(*b"TEST"),
res_id: 1,
name: b"Shared".to_vec(),
data: b"resource".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
second.vfs_directories.push(PpcVfsDirectory {
dir_id: PPC_FIRST_DYNAMIC_DIR_ID,
parent_dir_id: PPC_ROOT_DIR_ID,
path: "Shared Folder".to_string(),
creator: u32::from_be_bytes(*b"TEST"),
file_type: u32::from_be_bytes(*b"fold"),
finder_flags: 0x0400,
dirty: true,
});
second
.next_vfs_dir_id
.with_mut(|next_dir_id| *next_dir_id = PPC_FIRST_DYNAMIC_DIR_ID + 1);
second
.default_dir_id
.with_mut(|default_dir_id| *default_dir_id = PPC_FIRST_DYNAMIC_DIR_ID);
assert_eq!(first.vfs_files[0].data, b"first-second");
assert_eq!(first.deleted_vfs_file_paths, ["Obsolete Data"]);
assert_eq!(first.vfs_resources[0].data, b"resource");
assert_eq!(first.vfs_directories.last().unwrap().path, "Shared Folder");
assert_eq!(first.next_vfs_dir_id, PPC_FIRST_DYNAMIC_DIR_ID + 1);
assert_eq!(first.default_dir_id, PPC_FIRST_DYNAMIC_DIR_ID);
}
#[test]
fn process_file_records_remain_canonical_during_native_execution_panic_cross_isa() {
let pef = synthetic_pef_with_import(b"TestImport");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic = TrapDispatcher::new();
classic.attach_unconverted_process_services(&mut context);
native.push_test_open_file(crate::process_context::ProcessOpenFileRecord {
ref_num: PPC_FIRST_FILE_REF_NUM,
path: "Shared/Native.bin".to_string(),
position: 4,
});
native.insert_test_stdio_stream(
0x2200,
crate::process_context::ProcessStdioStreamRecord {
ref_num: Some(PPC_FIRST_FILE_REF_NUM),
path: Some("Shared/Native.bin".to_string()),
position: 4,
standard: false,
readable: true,
writable: true,
append: false,
closed: false,
eof: false,
error: false,
},
);
native.push_test_vfs_file(PpcVfsFileRecord {
path: "Shared/Native.bin".to_string(),
data: b"native".to_vec().into(),
creator: 0,
file_type: 0,
finder_flags: 0,
dirty: false,
});
native.push_test_deleted_vfs_file_path("Shared/Deleted.bin".to_string());
assert_eq!(
classic
.open_files
.get(&(PPC_FIRST_FILE_REF_NUM as u16))
.map(String::as_str),
Some("Shared/Native.bin")
);
assert_eq!(
classic
.vfs
.get("Shared/Native.bin")
.map(Vec::as_slice),
Some(b"native".as_slice())
);
// Drive the native return-import path with an intentionally empty
// process Memory Manager. The return handler expects a native heap,
// so this reliably unwinds execution after the file records have
// been made live. A process-owned collection must remain populated
// even when a native execution slice exits abnormally.
let action = GuestCallEffect::call_guest(
GuestCallRequest::new(GuestCallTarget {
isa: GuestIsa::PowerPc,
entry: native.entry_pc,
rtoc: native.rtoc,
}),
GuestCallContinuation::to_powerpc(
PPC_GUEST_CALL_RETURN_PC,
native.entry_pc,
native.rtoc,
PpcNativeReturnGpr3::Preserve,
),
)
.into_ppc_import_action()
.expect("native test request should adapt to the PPC ABI");
assert!(matches!(
native.toolbox_startup.execution.calls()
.externalize_powerpc_action(&mut native.cpu, action),
PpcImportAction::Continue
));
native.cpu.pc = PPC_GUEST_CALL_RETURN_PC;
let mut empty_memory_manager = ProcessMemoryManager::default();
let panic_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
native.run_with_process_memory_manager(
64,
false,
false,
&mut empty_memory_manager,
);
}));
assert!(panic_result.is_err());
assert_eq!(native.files.len(), 1);
assert_eq!(
native.process_file_system.stdio_streams[&0x2200].position,
4
);
assert_eq!(native.vfs_files[0].data, b"native");
assert_eq!(native.deleted_vfs_file_paths, ["Shared/Deleted.bin"]);
assert_eq!(
classic
.open_files
.get(&(PPC_FIRST_FILE_REF_NUM as u16))
.map(String::as_str),
Some("Shared/Native.bin")
);
}
#[test]
fn attached_native_adapters_share_process_resource_mutations_immediately() {
let pef = synthetic_pef_with_import(b"TestImport");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic = TrapDispatcher::new();
classic.attach_unconverted_process_services(&mut context);
native.push_resource_file(PpcResourceFileRecord {
ref_num: PPC_FIRST_FILE_REF_NUM,
path: "Shared/Native.rsrc".to_string(),
});
native.push_vfs_resource_file(PpcVfsResourceFileRecord {
path: "Shared/Native.rsrc".to_string(),
creator: u32::from_be_bytes(*b"TEST"),
file_type: u32::from_be_bytes(*b"rsrc"),
finder_flags: 0x0200,
resource_len: 4,
raw_data: Some(b"fork".to_vec().into()),
map_attrs: 0,
dirty: true,
});
native.push_vfs_resource(PpcVfsResourceRecord {
ref_num: PPC_FIRST_FILE_REF_NUM,
path: "Shared/Native.rsrc".to_string(),
res_type: u32::from_be_bytes(*b"TEST"),
res_id: 128,
name: b"Shared".to_vec(),
data: b"resource".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0x2200,
});
native.set_test_next_file_ref_num(PPC_FIRST_FILE_REF_NUM + 1);
assert_eq!(classic.resource_files[0].path, "Shared/Native.rsrc");
assert_eq!(classic.vfs_resource_files[0].finder_flags, 0x0200);
assert_eq!(
classic
.vfs_resource_files
.fork("Shared/Native.rsrc")
.map(AsRef::<[u8]>::as_ref),
Some(b"fork".as_slice())
);
assert_eq!(classic.vfs_resources[0].data, b"resource");
assert_eq!(
classic.allocate_process_file_refnum(),
(PPC_FIRST_FILE_REF_NUM + 1) as u16
);
assert_eq!(native.next_file_ref_num, PPC_FIRST_FILE_REF_NUM + 2);
classic.with_resource_manager_mut(|resource_manager| {
resource_manager.vfs_resources[0].attrs = 0x0040;
resource_manager.vfs_resource_files[0].dirty = false;
});
assert_eq!(native.vfs_resources[0].attrs, 0x0040);
assert!(!native.vfs_resource_files[0].dirty);
}
#[test]
fn launched_application_path_crosses_adapters_and_native_imports_without_clone_aliasing() {
let pef = synthetic_pef_with_import(b"LMGetCurApName");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic = TrapDispatcher::new();
classic.attach_unconverted_process_services(&mut context);
classic.set_launched_app_path("Apps/Classic App");
assert_eq!(native.launched_app_path(), Some("Apps/Classic App"));
run_test_import(
&mut native,
PpcImportDispatcherTarget::SystemCompatibility(
PpcSystemCompatibilityOperation::LmGetCurApName,
),
);
assert_eq!(
ppc_read_pstring_bytes(&mut native.memory, PPC_IMPORT_CUR_AP_NAME),
Some(b"Classic App".to_vec())
);
native.set_launched_app_path("Apps/Native App");
assert_eq!(classic.launched_app_path(), Some("Apps/Native App"));
run_test_import(
&mut native,
PpcImportDispatcherTarget::SystemCompatibility(
PpcSystemCompatibilityOperation::LmGetCurApName,
),
);
assert_eq!(
ppc_read_pstring_bytes(&mut native.memory, PPC_IMPORT_CUR_AP_NAME),
Some(b"Native App".to_vec())
);
let detached_clone = native.clone();
native.set_launched_app_path("Apps/Current App");
assert_eq!(classic.launched_app_path(), Some("Apps/Current App"));
assert_eq!(detached_clone.launched_app_path(), Some("Apps/Native App"));
}
#[test]
fn process_resource_records_remain_canonical_during_native_execution_panic_cross_isa() {
let pef = synthetic_pef_with_import(b"TestImport");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic = TrapDispatcher::new();
classic.attach_unconverted_process_services(&mut context);
native.push_resource_file(PpcResourceFileRecord {
ref_num: PPC_FIRST_FILE_REF_NUM,
path: "Shared/Native.rsrc".to_string(),
});
native.push_vfs_resource_file(PpcVfsResourceFileRecord {
path: "Shared/Native.rsrc".to_string(),
creator: 0,
file_type: 0,
finder_flags: 0,
resource_len: 0,
raw_data: None,
map_attrs: 0,
dirty: false,
});
native.push_vfs_resource(PpcVfsResourceRecord {
ref_num: PPC_FIRST_FILE_REF_NUM,
path: "Shared/Native.rsrc".to_string(),
res_type: u32::from_be_bytes(*b"TEST"),
res_id: 128,
name: b"Shared".to_vec(),
data: b"resource".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
native.set_test_next_file_ref_num(PPC_FIRST_FILE_REF_NUM + 1);
assert_eq!(classic.resource_files.len(), 1);
assert_eq!(classic.vfs_resource_files.len(), 1);
assert_eq!(classic.vfs_resources.len(), 1);
assert_eq!(native.next_file_ref_num, PPC_FIRST_FILE_REF_NUM + 1);
// The return handler expects a native heap. Running it with an empty
// process Memory Manager reliably unwinds execution after the native
// records are live. Process-owned Resource Manager records must stay
// visible to the classic adapter even on this early exit.
let action = GuestCallEffect::call_guest(
GuestCallRequest::new(GuestCallTarget {
isa: GuestIsa::PowerPc,
entry: native.entry_pc,
rtoc: native.rtoc,
}),
GuestCallContinuation::to_powerpc(
PPC_GUEST_CALL_RETURN_PC,
native.entry_pc,
native.rtoc,
PpcNativeReturnGpr3::Preserve,
),
)
.into_ppc_import_action()
.expect("native test request should adapt to the PPC ABI");
assert!(matches!(
native.toolbox_startup.execution.calls()
.externalize_powerpc_action(&mut native.cpu, action),
PpcImportAction::Continue
));
native.cpu.pc = PPC_GUEST_CALL_RETURN_PC;
let mut empty_memory_manager = ProcessMemoryManager::default();
struct ResourceRecordProbe<'a> {
classic: &'a TrapDispatcher,
observed: &'a std::cell::Cell<bool>,
}
impl Drop for ResourceRecordProbe<'_> {
fn drop(&mut self) {
self.observed.set(
self.classic.resource_files.len() == 1
&& self.classic.vfs_resource_files.len() == 1
&& self.classic.vfs_resources.len() == 1
&& self.classic.vfs_resources[0].data == b"resource",
);
}
}
let observed_during_unwind = std::cell::Cell::new(false);
let panic_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _probe = ResourceRecordProbe {
classic: &classic,
observed: &observed_during_unwind,
};
native.run_with_process_memory_manager(
64,
false,
false,
&mut empty_memory_manager,
);
}));
assert!(panic_result.is_err());
assert!(
observed_during_unwind.get(),
"classic Resource Manager lost native records during unwind"
);
assert_eq!(native.resource_files.len(), 1);
assert_eq!(native.vfs_resource_files.len(), 1);
assert_eq!(native.vfs_resources.len(), 1);
assert_eq!(native.next_file_ref_num, PPC_FIRST_FILE_REF_NUM + 1);
assert_eq!(classic.resource_files[0].path, "Shared/Native.rsrc");
assert_eq!(classic.vfs_resource_files[0].path, "Shared/Native.rsrc");
assert_eq!(classic.vfs_resources[0].data, b"resource");
assert_eq!(
classic.allocate_process_file_refnum(),
(PPC_FIRST_FILE_REF_NUM + 1) as u16
);
assert_eq!(native.next_file_ref_num, PPC_FIRST_FILE_REF_NUM + 2);
}
#[test]
fn open_file_sessions_cross_cpu_adapters_and_detach_with_clone() {
let pef = synthetic_pef_with_import(b"GetEOF");
let mut native = load_pef_application(&pef).unwrap();
native.push_test_open_file(crate::process_context::ProcessOpenFileRecord {
ref_num: PPC_FIRST_FILE_REF_NUM,
path: "Shared Data".to_string(),
position: 4,
});
native
.process_file_system
.writable_refnums
.insert(PPC_FIRST_FILE_REF_NUM as u16);
native.set_test_next_file_ref_num(PPC_FIRST_FILE_REF_NUM + 1);
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let detached = native.clone();
let mut classic = TrapDispatcher::new();
classic.attach_unconverted_process_services(&mut context);
assert!(classic.open_files.ptr_eq(&native.files));
assert!(classic
.write_refnums
.ptr_eq(&native.process_file_system.writable_refnums));
assert_eq!(
classic
.open_files
.get(&(PPC_FIRST_FILE_REF_NUM as u16))
.map(String::as_str),
Some("Shared Data")
);
classic
.file_positions
.insert(PPC_FIRST_FILE_REF_NUM as u16, 9);
assert_eq!(native.files[0].position, 9);
classic
.write_refnums
.remove(&(PPC_FIRST_FILE_REF_NUM as u16));
assert!(!native
.process_file_system
.writable_refnums
.contains(&(PPC_FIRST_FILE_REF_NUM as u16)));
native
.with_test_open_file_mut(0, |file| file.position = 12)
.expect("seeded native open file");
assert_eq!(
classic
.file_positions
.get(&(PPC_FIRST_FILE_REF_NUM as u16)),
Some(&12)
);
let next_refnum = classic.allocate_process_file_refnum();
assert_eq!(next_refnum, (PPC_FIRST_FILE_REF_NUM + 1) as u16);
assert_eq!(native.next_file_ref_num, PPC_FIRST_FILE_REF_NUM + 2);
classic
.open_files
.insert(next_refnum, "Classic Data".to_string());
classic.file_positions.insert(next_refnum, 3);
native
.process_file_system
.writable_refnums
.insert(next_refnum);
assert_eq!(native.files.last().unwrap().path, "Classic Data");
assert_eq!(native.files.last().unwrap().position, 3);
assert!(classic.write_refnums.contains(&next_refnum));
assert_eq!(detached.files.len(), 1);
assert_eq!(detached.files[0].position, 4);
assert!(detached
.process_file_system
.writable_refnums
.contains(&(PPC_FIRST_FILE_REF_NUM as u16)));
assert!(!detached
.process_file_system
.writable_refnums
.contains(&next_refnum));
assert_eq!(detached.next_file_ref_num, PPC_FIRST_FILE_REF_NUM + 1);
}
#[test]
fn catalogue_mutations_cross_cpu_adapters_without_runner_sync() {
let pef = synthetic_pef_with_import(b"GetEOF");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let executing_directories = native.vfs_directories.shared_handle();
let executing_volumes = native.vfs_volumes.shared_handle();
let executing_next_volume_ref_num =
native.next_vfs_volume_ref_num.shared_handle();
let executing_next_dir_id = native.next_vfs_dir_id.shared_handle();
let executing_default_dir_id = native.default_dir_id.shared_handle();
let executing_working_directories = native.working_directories.shared_handle();
let executing_application_wd_ref_num = native
.application_working_directory_ref_num
.shared_handle();
let detached = native.clone();
let mut classic = TrapDispatcher::new();
classic.attach_unconverted_process_services(&mut context);
assert!(classic.vfs_directories.ptr_eq(&executing_directories));
assert!(classic.next_vfs_dir_id.ptr_eq(&executing_next_dir_id));
native.vfs_directories.push(PpcVfsDirectory {
dir_id: PPC_FIRST_DYNAMIC_DIR_ID,
parent_dir_id: PPC_ROOT_DIR_ID,
path: "Shared Folder".to_string(),
creator: u32::from_be_bytes(*b"TEST"),
file_type: u32::from_be_bytes(*b"fold"),
finder_flags: 0x0400,
dirty: true,
});
native.push_test_vfs_file(PpcVfsFileRecord {
path: "Shared Folder/Native Data".to_string(),
data: b"native".to_vec().into(),
creator: u32::from_be_bytes(*b"TEST"),
file_type: u32::from_be_bytes(*b"DATA"),
finder_flags: 0x0200,
dirty: true,
});
native.vfs_volumes.push(PpcVfsVolumeRecord {
ref_num: -2,
name: "Read Only".to_string(),
root_dir_id: PPC_FIRST_DYNAMIC_DIR_ID,
attributes: 0x0080,
file_count: 1,
allocation_block_count: 16,
allocation_block_size: 4096,
clump_size: 4096,
free_blocks: 0,
bitmap_start: 3,
allocation_pointer: 4,
allocation_start: 5,
next_catalog_id: PPC_FIRST_DYNAMIC_DIR_ID + 1,
created_date: 1,
modified_date: 2,
});
native
.next_vfs_dir_id
.with_mut(|next_dir_id| *next_dir_id = PPC_FIRST_DYNAMIC_DIR_ID + 1);
native
.default_dir_id
.with_mut(|default_dir_id| *default_dir_id = PPC_FIRST_DYNAMIC_DIR_ID);
// Directory records are canonical process state, so the classic
// adapter observes native mutations before any file compatibility
// publication pass.
let shared_directory = classic
.directory_entry_for_id(PPC_FIRST_DYNAMIC_DIR_ID)
.cloned()
.expect("native directory should be visible to classic adapter");
assert_eq!(shared_directory.path, "Shared Folder");
assert_eq!(shared_directory.parent_dir_id, PPC_ROOT_DIR_ID);
assert_eq!(shared_directory.creator, u32::from_be_bytes(*b"TEST"));
assert_eq!(shared_directory.file_type, u32::from_be_bytes(*b"fold"));
assert_eq!(shared_directory.finder_flags, 0x0400);
assert!(shared_directory.dirty);
// Volume records are canonical process state, so the classic adapter
// observes this native mutation before any catalogue publication pass.
assert_eq!(
classic.vfs_volume_for_ref_num(-2).map(|volume| volume.name.as_str()),
Some("Read Only")
);
native.publish_test_native_vfs_catalogue();
assert_eq!(
classic.directory_path_for_id(PPC_FIRST_DYNAMIC_DIR_ID),
Some("Shared Folder")
);
let metadata = classic
.vfs_file_metadata("Shared Folder/Native Data")
.unwrap();
assert_eq!(metadata.parent_dir_id, PPC_FIRST_DYNAMIC_DIR_ID);
assert_eq!(metadata.creator, u32::from_be_bytes(*b"TEST"));
assert_eq!(metadata.file_type, u32::from_be_bytes(*b"DATA"));
assert_eq!(metadata.finder_flags, 0x0200);
assert_eq!(*classic.default_dir_id, PPC_FIRST_DYNAMIC_DIR_ID);
assert_eq!(classic.vfs_volume_for_ref_num(-2).unwrap().name, "Read Only");
let classic_dir_id = classic.ensure_vfs_directory("Classic Folder");
let classic_directory = native
.vfs_directories
.iter()
.find(|directory| directory.dir_id == classic_dir_id)
.cloned()
.expect("classic-created directory should be visible to native adapter");
assert_eq!(classic_directory.path, "Classic Folder");
assert_eq!(classic_directory.parent_dir_id, PPC_ROOT_DIR_ID);
assert_eq!(classic_directory.creator, u32::from_be_bytes(*b"MACS"));
assert_eq!(classic_directory.file_type, u32::from_be_bytes(*b"fold"));
assert!(classic_directory.dirty);
let classic_volume_ref = classic.mount_vfs_volume(
"Classic Disk",
0,
0,
16,
4096,
4096,
8,
3,
4,
5,
PPC_FIRST_DYNAMIC_DIR_ID + 3,
10,
11,
);
assert_eq!(
native
.process_file_system
.vfs_volumes
.iter()
.find(|volume| volume.ref_num == classic_volume_ref)
.map(|volume| volume.name.as_str()),
Some("Classic Disk")
);
classic
.vfs
.insert("Classic Folder/Classic Data".to_string(), b"classic".to_vec());
classic.set_vfs_entry_metadata(
"Classic Folder/Classic Data",
*b"TEXT",
*b"ttxt",
0x0100,
);
classic.set_launched_app_path("Classic Folder/Classic Data");
let classic_wd_ref_num = *classic.app_wd_refnum;
assert!(classic
.working_directories
.ptr_eq(&native.working_directories));
assert!(classic
.app_wd_refnum
.ptr_eq(&native.application_working_directory_ref_num));
assert_eq!(*executing_application_wd_ref_num, classic_wd_ref_num);
assert_eq!(
executing_working_directories[&classic_wd_ref_num].dir_id,
classic_dir_id
);
let wd_vref_ptr = PPC_DATA_BASE + 0x2800;
let wd_dir_id_ptr = wd_vref_ptr + 4;
let wd_proc_id_ptr = wd_vref_ptr + 8;
native.memory.add_region(wd_vref_ptr, vec![0; 12]);
native.cpu.gpr[3] = classic_wd_ref_num as u16 as u32;
native.cpu.gpr[4] = wd_vref_ptr;
native.cpu.gpr[5] = wd_dir_id_ptr;
native.cpu.gpr[6] = wd_proc_id_ptr;
native
.memory
.write_u32_be(crate::memory::globals::addr::CUR_DIR_STORE, classic_dir_id)
.unwrap();
run_test_import(&mut native, PpcImportDispatcherTarget::GetWDInfo);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
native.memory.read_u16_be(wd_vref_ptr),
Some(PPC_BOOT_VOLUME_REF_NUM as u16)
);
assert_eq!(native.memory.read_u32_be(wd_dir_id_ptr), Some(classic_dir_id));
assert_eq!(native.memory.read_u32_be(wd_proc_id_ptr), Some(0));
assert!(native.vfs_directories.iter().any(|directory| {
directory.dir_id == classic_dir_id && directory.path == "Classic Folder"
}));
assert!(executing_directories.iter().any(|directory| {
directory.dir_id == classic_dir_id && directory.path == "Classic Folder"
}));
assert!(executing_volumes.iter().any(|volume| {
volume.ref_num == classic_volume_ref && volume.name == "Classic Disk"
}));
assert_eq!(*executing_next_volume_ref_num, classic_volume_ref - 1);
assert_eq!(*executing_next_dir_id, *classic.next_vfs_dir_id);
assert_eq!(*executing_default_dir_id, classic_dir_id);
assert_eq!(*detached.next_vfs_volume_ref_num, -2);
assert!(!detached
.vfs_directories
.iter()
.any(|directory| directory.path == "Classic Folder"));
assert!(!detached
.vfs_volumes
.iter()
.any(|volume| volume.name == "Classic Disk"));
assert_ne!(*detached.next_vfs_dir_id, *executing_next_dir_id);
assert_ne!(*detached.default_dir_id, *executing_default_dir_id);
assert!(detached.working_directories.is_empty());
assert_eq!(*detached.application_working_directory_ref_num, -1);
assert!(!detached
.working_directories
.ptr_eq(&executing_working_directories));
run_test_import(&mut native, PpcImportDispatcherTarget::GetEOF);
assert!(native.vfs_directories.ptr_eq(&executing_directories));
assert!(native.vfs_volumes.ptr_eq(&executing_volumes));
assert!(native
.next_vfs_volume_ref_num
.ptr_eq(&executing_next_volume_ref_num));
assert!(native.next_vfs_dir_id.ptr_eq(&executing_next_dir_id));
assert!(native.default_dir_id.ptr_eq(&executing_default_dir_id));
let classic_file = native
.vfs_files
.iter()
.find(|file| file.path == "Classic Folder/Classic Data")
.unwrap();
assert_eq!(classic_file.data, b"classic");
assert_eq!(classic_file.file_type, u32::from_be_bytes(*b"TEXT"));
assert_eq!(classic_file.creator, u32::from_be_bytes(*b"ttxt"));
assert_eq!(classic_file.finder_flags, 0x0100);
classic
.vfs
.with_entry_mut("Classic Folder/Classic Data", |bytes| {
bytes.extend_from_slice(b"-shared");
})
.unwrap();
assert_eq!(
native
.vfs_files
.iter()
.find(|file| file.path == "Classic Folder/Classic Data")
.unwrap()
.data,
b"classic-shared"
);
native.cpu.gpr[3] = 0;
native.cpu.gpr[4] = PPC_BOOT_VOLUME_REF_NUM as u16 as u32;
native.cpu.gpr[5] = PPC_FIRST_DYNAMIC_DIR_ID;
run_test_import(&mut native, PpcImportDispatcherTarget::HSetVol);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(*classic.default_dir_id, PPC_FIRST_DYNAMIC_DIR_ID);
let native_wd_ref_num = *classic.app_wd_refnum;
assert_eq!(
classic.working_directories[&native_wd_ref_num].dir_id,
PPC_FIRST_DYNAMIC_DIR_ID
);
assert_eq!(
*native.application_working_directory_ref_num,
native_wd_ref_num
);
classic
.locked_files
.insert("Shared Folder/Native Data".to_string());
// Native Delete removes the canonical record before queueing its notice.
native.process_file_system.with_mut(|file_system| {
file_system.vfs_files.retain(|file| file.path != "Shared Folder/Native Data");
});
native.push_test_deleted_vfs_file_path("Shared Folder/Native Data".to_string());
native.publish_test_native_vfs_catalogue();
assert!(!classic
.vfs_metadata
.contains_key("Shared Folder/Native Data"));
assert!(!classic
.locked_files
.contains("Shared Folder/Native Data"));
assert!(classic.remove_vfs_path("Classic Folder/Classic Data"));
assert!(!native
.vfs_files
.iter()
.any(|file| file.path == "Classic Folder/Classic Data"));
}
#[test]
fn detached_native_app_clones_keep_independent_file_systems() {
let pef = synthetic_pef_with_import(b"GetEOF");
let mut original = load_pef_application(&pef).unwrap();
original.push_test_vfs_file(PpcVfsFileRecord {
path: "Detached Data".to_string(),
data: (b"before".to_vec()).into(),
creator: 0,
file_type: 0,
finder_flags: 0,
dirty: false,
});
original.push_vfs_resource(PpcVfsResourceRecord {
ref_num: 128,
path: "Detached Data".to_string(),
res_type: u32::from_be_bytes(*b"TEST"),
res_id: 1,
name: Vec::new(),
data: b"resource".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
original.vfs_directories.push(PpcVfsDirectory {
dir_id: PPC_FIRST_DYNAMIC_DIR_ID,
parent_dir_id: PPC_ROOT_DIR_ID,
path: "Detached Folder".to_string(),
creator: 0,
file_type: 0,
finder_flags: 0,
dirty: false,
});
let detached = original.clone();
original
.with_test_vfs_file_mut(0, |file| {
file.data.with_mut(|data| data.copy_from_slice(b"change"));
})
.expect("seeded detached file");
original.with_resource_manager_mut(|resource_manager| {
resource_manager.vfs_resources[0]
.data
.copy_from_slice(b"changed!");
});
original.vfs_directories.with_mut(|directories| {
directories.last_mut().unwrap().path = "Changed Folder".to_string();
});
original
.next_vfs_dir_id
.with_mut(|next_dir_id| *next_dir_id += 1);
assert!(!original
.process_file_system
.ptr_eq(&detached.process_file_system));
assert_eq!(original.vfs_files[0].data, b"change");
assert_eq!(detached.vfs_files[0].data, b"before");
assert_eq!(original.vfs_resources[0].data, b"changed!");
assert_eq!(detached.vfs_resources[0].data, b"resource");
assert_eq!(original.vfs_directories.last().unwrap().path, "Changed Folder");
assert_eq!(detached.vfs_directories.last().unwrap().path, "Detached Folder");
assert_eq!(
*original.next_vfs_dir_id,
*detached.next_vfs_dir_id + 1
);
}
#[test]
fn adopted_ppc_execution_pair_shares_and_snapshot_detaches_coherently() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
context.set_menu_tracking(Some(crate::menu_manager::test_process_menu_tracking(
0x0012_3456,
)));
let plan = native.preflight_migrated_services(&context, 0).unwrap();
native.commit_migrated_services(&context, plan);
let detached = native.clone();
native
.toolbox_startup
.execution
.with_menu_state_mut(|tracking| tracking.highlighted_item = 3)
.unwrap();
assert_eq!(
context
.menu_tracking()
.map(|tracking| tracking.highlighted_item),
Some(3)
);
assert_eq!(
native
.toolbox_startup
.execution
.menu()
.as_ref()
.unwrap()
.highlighted_item,
3
);
assert!(!native
.toolbox_startup
.execution
.menu()
.ptr_eq(detached.toolbox_startup.execution.menu()));
assert_eq!(
detached
.toolbox_startup
.execution
.menu()
.as_ref()
.unwrap()
.highlighted_item,
1
);
}
#[test]
fn adopted_ppc_execution_pair_remains_shared_through_panic() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
context.set_menu_tracking(Some(crate::menu_manager::test_process_menu_tracking(
0x0012_3456,
)));
let plan = native.preflight_migrated_services(&context, 0).unwrap();
native.commit_migrated_services(&context, plan);
let panic_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
native
.toolbox_startup
.execution
.with_menu_state_mut(|tracking| tracking.highlighted_item = 5)
.unwrap();
panic!("simulated panic inside PPC guest execution");
}));
assert!(panic_result.is_err());
assert_eq!(
context
.menu_tracking()
.map(|tracking| tracking.highlighted_item),
Some(5)
);
assert_eq!(
native
.toolbox_startup
.execution
.menu()
.as_ref()
.unwrap()
.highlighted_item,
5
);
}
#[test]
fn native_operation_uses_canonical_allocator_without_slice_handoff() {
let pef = synthetic_pef_with_import(b"NewHandle");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 32;
run_test_import(
&mut native,
PpcImportDispatcherTarget::NewHandle { clear: false },
);
let handle = native.cpu.gpr[3];
assert_ne!(handle, 0);
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle();
let expected_cursor = native.heap_cursor() + 16;
{
let mut manager = memory_manager.borrow_mut();
manager.set_state_for_handle(handle, 0xa0);
let mut canonical = manager.native_allocation(handle).unwrap();
canonical.size = 24;
canonical.capacity = 40;
manager.set_native_allocation(canonical);
manager.mutate_native_allocator(|allocator| {
allocator.heap.heap_cursor = expected_cursor;
allocator.ptrs.push(ProcessPtrRecord {
ptr: PPC_HEAP_BASE + 4,
size: 8,
});
allocator.free_ptr_blocks.push(ProcessPtrRecord {
ptr: PPC_HEAP_BASE + 12,
size: 4,
});
allocator.free_handle_blocks.push(ProcessHandleRecord {
handle: PPC_HEAP_BASE + 16,
ptr: PPC_HEAP_BASE + 20,
size: 4,
capacity: 8,
});
});
}
native.with_process_memory_manager(
|_native, memory_manager| {
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.heap_cursor),
Some(expected_cursor)
);
let allocator = memory_manager.native_allocator().unwrap();
assert_eq!(allocator.ptrs.last().map(|record| record.size), Some(8));
assert_eq!(
allocator.free_ptr_blocks.last().map(|record| record.size),
Some(4)
);
assert_eq!(
allocator
.free_handle_blocks
.last()
.map(|record| record.capacity),
Some(8)
);
memory_manager.mutate_native_allocator(|allocator| {
allocator.heap.heap_cursor += 8;
});
let allocation = memory_manager
.native_handle_records()
.iter()
.find(|record| record.handle == handle)
.expect("canonical allocation materialized for native handle");
assert_eq!((allocation.size, allocation.capacity), (24, 40));
let mut state = memory_manager.native_handle_state(handle);
assert!(state.locked);
assert!(state.no_purge);
assert!(state.resource);
state.locked = false;
state.high_locked = false;
state.no_purge = false;
state.resource = false;
memory_manager.set_native_handle_state(state);
},
);
let manager = memory_manager.borrow();
assert_eq!(manager.state_for_handle(handle), Some(0x40));
assert_eq!(
manager
.native_allocator()
.map(|allocator| allocator.heap.heap_cursor),
Some(expected_cursor + 8)
);
assert_eq!(
manager.native_allocation(handle),
native
.handles()
.iter()
.copied()
.find(|record| record.handle == handle)
);
}
#[test]
fn attached_native_memory_manager_survives_panic_without_runner_handoff() {
let pef = synthetic_pef_with_import(b"NewPtr");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
let panic_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = 24;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
panic!("simulated panic after a native Memory Manager import");
});
}));
assert!(panic_result.is_err());
let ptr = native.cpu.gpr[3];
assert_ne!(ptr, 0);
assert!(native.process_memory_manager.ptr_eq(&memory_manager));
assert!(memory_manager
.borrow()
.native_allocator()
.unwrap()
.ptrs
.iter()
.any(|record| record.ptr == ptr && record.size == 24));
}
#[test]
fn detached_native_handle_state_remains_independent() {
let handle = PPC_HEAP_BASE + 0x20;
let record = ProcessHandleRecord {
handle,
ptr: PPC_HEAP_BASE + 0x40,
size: 16,
capacity: 16,
};
let stale_state = PpcHandleStateRecord {
handle,
locked: false,
high_locked: false,
no_purge: false,
resource: false,
};
let mut memory_manager = ProcessMemoryManager::default();
memory_manager.register_native_handle_records([(
record,
ppc_process_handle_state_bits(&[stale_state], handle),
)]);
let detached = memory_manager.detached_clone();
memory_manager.lock_process_handle(handle, true);
let state = memory_manager.native_handle_state(handle);
assert!(state.locked);
assert!(state.high_locked);
assert!(!state.no_purge);
assert!(!state.resource);
assert_eq!(detached.state_for_handle(handle), Some(0x40));
assert!(!detached.native_handle_state(handle).high_locked);
}
#[test]
fn resource_disposal_is_immediately_process_owned() {
let pef = synthetic_pef_with_import(b"NewHandle");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 24;
run_test_import(
&mut native,
PpcImportDispatcherTarget::NewHandle { clear: false },
);
let handle = native.cpu.gpr[3];
let ptr = native.memory.read_u32_be(handle).unwrap();
let shared_manager = native.process_memory_manager.0.clone();
let mut memory_manager = shared_manager.borrow_mut();
let detached = memory_manager.detached_clone();
let allocator = memory_manager.native_allocator_snapshot().unwrap();
let mut heap_cursor = allocator.heap.heap_cursor;
let heap_limit = allocator.heap.heap_limit;
let mut last_mem_error = allocator.heap.last_mem_error;
let mut handles = memory_manager.native_handle_records().to_vec();
let mut resources = [PpcVfsResourceRecord {
ref_num: 1,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"TEST"),
res_id: 128,
name: b"owned".to_vec(),
data: vec![0; 24],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle,
}];
let mut last_resource_error = PPC_RES_NOT_FOUND_ERR;
native.cpu.gpr[3] = handle;
ppc_release_resource(
&mut native.cpu,
&mut memory_manager,
&mut native.memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
&mut resources,
&mut last_resource_error,
);
assert_eq!(last_resource_error, PPC_NO_ERR);
assert_eq!(resources[0].handle, 0);
assert_eq!(native.memory.read_u32_be(handle), Some(0));
assert_eq!(memory_manager.native_allocation(handle), None);
assert_eq!(memory_manager.recover_handle(ptr), None);
assert!(memory_manager
.native_allocator()
.unwrap()
.free_handle_blocks
.iter()
.any(|record| record.handle == handle));
assert!(handles.iter().all(|record| record.handle != handle));
assert_eq!(
detached.native_allocation(handle).map(|record| record.ptr),
Some(ptr)
);
assert_eq!(detached.recover_handle(ptr), Some(handle));
}
#[test]
fn standalone_and_attached_memory_imports_share_process_manager_semantics() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut standalone = load_pef_application(&pef).unwrap();
let mut attached = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
attached.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
standalone.cpu.gpr[3] = 24;
attached.cpu.gpr[3] = 24;
run_test_import(
&mut standalone,
PpcImportDispatcherTarget::NewPtr { clear: true },
);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::NewPtr { clear: true },
&memory_manager,
);
let ptr = standalone.cpu.gpr[3];
assert_eq!(attached.cpu.gpr[3], ptr);
assert_eq!(standalone.ptrs(), attached.ptrs());
assert_eq!(standalone.heap_cursor(), attached.heap_cursor());
assert_eq!(
ppc_memory_read_bytes(&mut standalone.memory, ptr, 24),
ppc_memory_read_bytes(&mut attached.memory, ptr, 24),
);
standalone.cpu.gpr[3] = ptr;
attached.cpu.gpr[3] = ptr;
run_test_import(&mut standalone, PpcImportDispatcherTarget::GetPtrSize);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::GetPtrSize,
&memory_manager,
);
assert_eq!(standalone.cpu.gpr[3], 24);
assert_eq!(attached.cpu.gpr[3], 24);
standalone.cpu.gpr[3] = 13;
attached.cpu.gpr[3] = 13;
run_test_import(
&mut standalone,
PpcImportDispatcherTarget::NewHandle { clear: true },
);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::NewHandle { clear: true },
&memory_manager,
);
let handle = standalone.cpu.gpr[3];
assert_eq!(attached.cpu.gpr[3], handle);
assert_eq!(standalone.handles(), attached.handles());
assert_eq!(standalone.heap_cursor(), attached.heap_cursor());
standalone.cpu.gpr[3] = handle;
attached.cpu.gpr[3] = handle;
run_test_import(&mut standalone, PpcImportDispatcherTarget::HLock);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::HLock,
&memory_manager,
);
assert_eq!(standalone.handle_states(), attached.handle_states());
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x80));
standalone.cpu.gpr[3] = handle;
standalone.cpu.gpr[4] = 48;
attached.cpu.gpr[3] = handle;
attached.cpu.gpr[4] = 48;
run_test_import(&mut standalone, PpcImportDispatcherTarget::SetHandleSize);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(standalone.handles(), attached.handles());
assert_eq!(standalone.heap_cursor(), attached.heap_cursor());
assert_eq!(standalone.last_mem_error(), attached.last_mem_error());
standalone.cpu.gpr[3] = handle;
attached.cpu.gpr[3] = handle;
run_test_import(&mut standalone, PpcImportDispatcherTarget::DisposeHandle);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::DisposeHandle,
&memory_manager,
);
assert_eq!(standalone.handles(), attached.handles());
assert_eq!(
standalone.free_handle_blocks(),
attached.free_handle_blocks()
);
assert_eq!(standalone.memory.read_u32_be(handle), Some(0));
assert_eq!(attached.memory.read_u32_be(handle), Some(0));
}
#[test]
fn standalone_native_runs_retain_the_process_memory_manager() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 24;
run_test_import(
&mut native,
PpcImportDispatcherTarget::NewHandle { clear: true },
);
let handle = native.cpu.gpr[3];
let retained = native.process_memory_manager.0.clone();
assert_eq!(retained.borrow().state_for_handle(handle), Some(0));
retained.borrow_mut().set_state_for_handle(handle, 0xa0);
native.cpu.gpr[3] = handle;
run_test_import(&mut native, PpcImportDispatcherTarget::HGetState);
assert_eq!(native.cpu.gpr[3], 0xa0);
assert!(native.process_memory_manager.0.ptr_eq(&retained));
}
#[test]
fn ppc_handle_state_imports_preserve_process_owned_classic_handles() {
let pef = synthetic_pef_with_import(b"HLock");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let shared = native.memory.shared_view();
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
classic_bus.attach_guest_address_space(shared);
context.attach_classic_memory_bus(&mut classic_bus);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 19)
.unwrap();
classic_bus.write_byte(ptr, 0x5a);
native.memory.add_region(ptr & !0x0fff, vec![0; 0x1000]);
native.memory.write_u32_be(handle, ptr).unwrap();
native.memory.write_u8(ptr, 0x5a).unwrap();
let memory_manager = context.memory_manager_handle();
// HLock and HGetState operate on the live relocatable block while the
// stable handle continues to identify its master pointer. Inside
// Macintosh: Memory (1992), pp. 1-18--1-19 and 2-45--2-49.
classic.set_handle_state_bits(handle, 0x40);
let detached = memory_manager.detached_clone();
native.with_process_memory_manager(
|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HGetState;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(native.cpu.gpr[3], 0x40);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetHandleSize;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(native.cpu.gpr[3], 19);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HLock;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HGetState;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(native.cpu.gpr[3], 0xc0);
},
);
assert_eq!(classic.handle_state_bits(handle), Some(0xc0));
assert_eq!(detached.borrow().state_for_handle(handle), Some(0x40));
}
#[test]
fn ppc_empty_handle_releases_a_process_owned_classic_block_atomically() {
let pef = synthetic_pef_with_import(b"EmptyHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x2000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 24)
.unwrap();
classic_bus.write_bytes(ptr, b"classic process handle");
let memory_manager = context.memory_manager_handle().clone();
memory_manager.borrow_mut().set_state_for_handle(handle, 0xc0);
let mut detached = native.clone();
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_PUR_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(ptr));
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(24));
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0xc0));
memory_manager.set_state_for_handle(handle, 0x40);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(0));
assert_eq!(memory_manager.classic_allocation_size(handle), Some(4));
assert_eq!(memory_manager.classic_allocation_size(ptr), None);
assert_eq!(memory_manager.recover_handle(ptr), None);
assert_eq!(memory_manager.state_for_handle(handle), Some(0x40));
});
assert_eq!(classic_bus.read_long(handle), 0);
assert_eq!(classic_bus.get_alloc_size(handle), Some(4));
assert_eq!(classic_bus.get_alloc_size(ptr), None);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(detached_manager.classic_allocation_size(handle), Some(4));
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(24));
assert_eq!(detached_manager.recover_handle(ptr), Some(handle));
assert_eq!(detached_manager.state_for_handle(handle), Some(0xc0));
}
#[test]
fn ppc_dispose_handle_releases_classic_storage_and_preserves_stale_slot_rules() {
let pef = synthetic_pef_with_import(b"DisposeHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x2000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
classic_bus.write_bytes(ptr, b"disposed classic");
let memory_manager = context.memory_manager_handle().clone();
memory_manager.borrow_mut().set_state_for_handle(handle, 0x80);
let mut detached = native.clone();
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(ptr));
assert_eq!(memory_manager.classic_allocation_size(handle), None);
assert_eq!(memory_manager.classic_allocation_size(ptr), None);
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), None);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], handle);
});
assert_eq!(classic_bus.read_long(handle), ptr);
let reused = context
.memory_manager_mut()
.new_empty_classic_handle(&mut classic_bus)
.unwrap();
assert_eq!(reused, handle);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(ptr), None);
});
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(detached_manager.classic_allocation_size(handle), Some(4));
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.recover_handle(ptr), Some(handle));
assert_eq!(detached_manager.state_for_handle(handle), Some(0x80));
}
#[test]
fn ppc_handle_release_does_not_bypass_classic_resource_manager_ownership() {
let pef = synthetic_pef_with_import(b"DisposeHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x2000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let ptr = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.write_bytes(ptr, b"classic resource");
let handle =
classic.get_or_create_resource_handle(&mut classic_bus, *b"TEST", 128, ptr);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_process_handle_purgeable(handle, false);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x20));
native.with_process_memory_manager(|native, memory_manager| {
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(ptr));
assert_eq!(memory_manager.classic_allocation_size(handle), Some(4));
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x20));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NIL_HANDLE_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(ptr));
assert_eq!(memory_manager.classic_allocation_size(handle), Some(4));
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x20));
});
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.read_bytes(ptr, 16), b"classic resource");
let mut classic_cpu = crate::trap::test_helpers::MockCpu::new();
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_bus.write_long(TEST_SP, handle);
assert!(classic
.dispatch_toolbox(true, 0x1ad, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_cpu.read_reg(Register::A7), TEST_SP + 4);
assert_eq!(classic_bus.read_word(0x0a60), 0);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0));
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.classic_allocation_size(handle), None);
assert_eq!(memory_manager.classic_allocation_size(ptr), None);
assert_eq!(memory_manager.state_for_handle(handle), None);
});
}
#[test]
fn ppc_dispose_handle_does_not_claim_an_external_pef_master_pointer() {
let pef = synthetic_pef_with_loader_and_data(
synthetic_loader(b"InterfaceLib", b"DisposeHandle"),
&[0; 0x80],
);
let mut native = load_pef_application(&pef).unwrap();
let handle = PPC_DATA_BASE + 0x40;
let before = ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80).unwrap();
native.with_process_memory_manager(|native, memory_manager| {
let ptr = memory_manager.new_native_ptr(&mut native.memory, 32, true);
assert_ne!(ptr, 0);
PpcMemory::write_u32_be(&mut native.memory, handle, ptr).unwrap();
let heap_cursor = memory_manager.native_heap_state().unwrap().heap_cursor;
memory_manager.publish_external_native_resource_handle(handle, ptr, heap_cursor);
let expected =
ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80).unwrap();
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80),
Some(expected.clone())
);
assert!(memory_manager
.native_allocator()
.unwrap()
.ptrs
.iter()
.any(|record| record.ptr == ptr && record.size == 32));
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x60));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NIL_HANDLE_ERR)
);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80),
Some(expected)
);
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x60));
});
let after = ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80).unwrap();
assert_ne!(after, before);
assert_eq!(&after[..0x40], &before[..0x40]);
assert_eq!(&after[0x44..], &before[0x44..]);
}
#[test]
fn ppc_pointer_imports_observe_process_owned_classic_allocations() {
let pef = synthetic_pef_with_import(b"GetPtrSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let ptr = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 37);
assert_ne!(ptr, 0);
classic_bus.fill_bytes(ptr, 37, 0x5a);
assert_eq!(
context
.memory_manager_mut()
.set_process_ptr_size(&mut classic_bus, ptr, 36),
0
);
assert_eq!(classic_bus.read_byte(ptr + 36), 0);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = ptr;
let probe = native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(native.cpu.gpr[3], 36);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposePtr;
native.cpu.gpr[3] = ptr;
let probe = native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(memory_manager.classic_allocation_size(ptr), None);
});
assert_eq!(classic_bus.get_alloc_size(ptr), None);
}
#[test]
fn ppc_set_handle_size_resizes_process_owned_classic_handle_across_isa() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let original = (0x10..=0x1f).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &original);
let neighbor = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.fill_bytes(neighbor, 16, 0xa5);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(handle, 0x40);
let mut detached = native.clone();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 8;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], handle);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(8));
assert_eq!(
classic_bus.read_bytes(ptr, 16),
[original[..8].to_vec(), vec![0; 8]].concat()
);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x40));
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 12;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(12));
assert_eq!(
classic_bus.read_bytes(ptr, 12),
[original[..8].to_vec(), vec![0; 4]].concat()
);
classic_bus.write_bytes(ptr + 8, &[0x81, 0x82, 0x83, 0x84]);
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
let moved_ptr = classic_bus.read_long(handle);
assert_ne!(moved_ptr, ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), None);
assert_eq!(classic_bus.get_alloc_size(moved_ptr), Some(48));
assert_eq!(
classic_bus.read_bytes(moved_ptr, 12),
[original[..8].to_vec(), vec![0x81, 0x82, 0x83, 0x84]].concat()
);
assert_eq!(classic_bus.read_bytes(neighbor, 16), vec![0xa5; 16]);
assert_eq!(
PpcMemory::read_u32_be(&mut native.memory, handle),
Some(moved_ptr)
);
assert_eq!(
memory_manager.borrow().classic_allocation_size(moved_ptr),
Some(48)
);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), None);
assert_eq!(
memory_manager.borrow().handle_for_ptr(moved_ptr),
Some(handle)
);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x40));
assert_eq!(
classic_bus.read_bytes(moved_ptr, 12),
ppc_memory_read_bytes(&mut native.memory, moved_ptr, 12).unwrap()
);
native.cpu.gpr[3] = ptr;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::RecoverHandle,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], 0);
native.cpu.gpr[3] = moved_ptr;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::RecoverHandle,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], handle);
native.cpu.gpr[3] = handle;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::GetHandleSize,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], 48);
assert_eq!(
classic_bus.read_bytes(moved_ptr, 12),
ppc_memory_read_bytes(&mut native.memory, moved_ptr, 12).unwrap()
);
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(handle), Some(4));
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.classic_allocation_size(moved_ptr), None);
assert_eq!(detached_manager.handle_for_ptr(ptr), Some(handle));
assert_eq!(detached_manager.handle_for_ptr(moved_ptr), None);
assert_eq!(detached_manager.state_for_handle(handle), Some(0x40));
assert_eq!(
ppc_memory_read_bytes(&mut detached.memory, ptr, 16),
Some(original)
);
}
#[test]
fn ppc_set_handle_size_keeps_zero_size_empty_classic_handle_empty() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let handle = context
.memory_manager_mut()
.new_empty_classic_handle(&mut classic_bus)
.unwrap();
let memory_manager = context.memory_manager_handle().clone();
let cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 0;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(classic_bus.read_long(handle), 0);
assert_eq!(classic_bus.get_alloc_size(handle), Some(4));
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(0), None);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
}
#[test]
fn ppc_set_handle_size_preserves_classic_state_on_atomic_failure() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 3 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let payload = (0xa0..=0xaf).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &payload);
let neighbor = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.fill_bytes(neighbor, 16, 0x5a);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(handle, 0x40);
let mut detached = native.clone();
let handle_bytes = classic_bus.read_bytes(handle, 4);
let cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 0x0010_0000;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_FULL_ERR)
);
assert_eq!(classic_bus.read_bytes(handle, 4), handle_bytes);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(handle), Some(4));
assert_eq!(classic_bus.get_alloc_size(ptr), Some(16));
assert_eq!(classic_bus.read_bytes(ptr, 16), payload);
assert_eq!(classic_bus.read_bytes(neighbor, 16), vec![0x5a; 16]);
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().handle_for_ptr(neighbor), None);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x40));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(
ppc_memory_read_bytes(&mut detached.memory, ptr, 16),
Some((0xa0..=0xaf).collect::<Vec<_>>())
);
}
#[test]
fn ppc_set_handle_size_rejects_a_guest_mutated_classic_master_pointer() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let payload = (0xb0..=0xbf).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &payload);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(handle, 0x40);
let mut detached = native.clone();
let invalid_ptr = 0xdead_beefu32;
classic_bus.write_long(handle, invalid_ptr);
let cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_WZ_ERR)
);
assert_eq!(classic_bus.read_long(handle), invalid_ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(16));
assert_eq!(classic_bus.read_bytes(ptr, 16), payload);
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x40));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.handle_for_ptr(ptr), Some(handle));
}
#[test]
fn ppc_set_handle_size_rejects_another_classic_handles_data_block() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let (other_handle, other_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 24)
.unwrap();
let original = (0x20..=0x2f).collect::<Vec<_>>();
let other = (0x80..=0x97).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &original);
classic_bus.write_bytes(other_ptr, &other);
classic_bus.write_long(handle, other_ptr);
let memory_manager = context.memory_manager_handle().clone();
let cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_WZ_ERR)
);
assert_eq!(classic_bus.read_long(handle), other_ptr);
assert_eq!(classic_bus.read_long(other_handle), other_ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(16));
assert_eq!(classic_bus.get_alloc_size(other_ptr), Some(24));
assert_eq!(classic_bus.read_bytes(ptr, 16), original);
assert_eq!(classic_bus.read_bytes(other_ptr, 24), other);
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(
memory_manager.borrow().handle_for_ptr(other_ptr),
Some(other_handle)
);
}
#[test]
fn ppc_set_handle_size_rejects_locked_classic_relocation_without_mutation() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let payload = (0xc0..=0xcf).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &payload);
let neighbor = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.fill_bytes(neighbor, 16, 0x6b);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(handle, 0x80);
let mut detached = native.clone();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 8;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(8));
assert_eq!(
classic_bus.read_bytes(ptr, 16),
[payload[..8].to_vec(), vec![0; 8]].concat()
);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x80));
let before_handle = classic_bus.read_bytes(handle, 4);
let before_data = classic_bus.read_bytes(ptr, 16);
let before_cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_FULL_ERR)
);
assert_eq!(classic_bus.read_bytes(handle, 4), before_handle);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(8));
assert_eq!(classic_bus.read_bytes(ptr, 16), before_data);
assert_eq!(classic_bus.read_bytes(neighbor, 16), vec![0x6b; 16]);
assert_eq!(context.classic_heap_bump_ptr(), before_cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x80));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.state_for_handle(handle), Some(0x80));
}
#[test]
fn ppc_set_handle_size_does_not_bypass_classic_resource_ownership() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let ptr = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
let payload = (0xd0..=0xdf).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &payload);
let handle = classic.get_or_create_resource_handle(&mut classic_bus, *b"TEST", 128, ptr);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_process_handle_purgeable(handle, false);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x20));
let mut detached = native.clone();
let before_handle = classic_bus.read_bytes(handle, 4);
let before_cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NIL_HANDLE_ERR)
);
assert_eq!(classic_bus.read_bytes(handle, 4), before_handle);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(handle), Some(4));
assert_eq!(classic_bus.get_alloc_size(ptr), Some(16));
assert_eq!(classic_bus.read_bytes(ptr, 16), payload);
assert_eq!(context.classic_heap_bump_ptr(), before_cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x20));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.state_for_handle(handle), Some(0x20));
}
#[test]
fn ppc_set_handle_size_does_not_claim_an_external_pef_master_pointer() {
let pef = synthetic_pef_with_loader_and_data(
synthetic_loader(b"InterfaceLib", b"SetHandleSize"),
&[0; 0x80],
);
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
classic_bus.attach_guest_address_space(native.memory.shared_view());
let handle = PPC_DATA_BASE + 0x40;
let memory_manager = context.memory_manager_handle().clone();
let ptr = native.with_process_memory_manager(|native, memory_manager| {
let ptr = memory_manager.new_native_ptr(&mut native.memory, 32, true);
assert_ne!(ptr, 0);
native
.memory
.write_bytes(ptr, b"external PEF payload")
.unwrap();
PpcMemory::write_u32_be(&mut native.memory, handle, ptr).unwrap();
let heap_cursor = memory_manager.native_heap_state().unwrap().heap_cursor;
memory_manager.publish_external_native_resource_handle(handle, ptr, heap_cursor);
ptr
});
let mut detached = native.clone();
let before_handle = PpcMemory::read_u32_be(&mut native.memory, handle);
let expected_pef = ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80).unwrap();
let detached_pef =
ppc_memory_read_bytes(&mut detached.memory, PPC_DATA_BASE, 0x80).unwrap();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 64;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NIL_HANDLE_ERR)
);
assert_eq!(
PpcMemory::read_u32_be(&mut native.memory, handle),
before_handle
);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80),
Some(expected_pef)
);
assert_eq!(memory_manager.borrow().native_allocation(handle), None);
assert!(memory_manager
.borrow()
.native_ptr_records()
.iter()
.any(|record| record.ptr == ptr && record.size == 32));
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x60));
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, ptr, b"external PEF payload".len() as u32),
Some(b"external PEF payload".to_vec())
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(
ppc_memory_read_bytes(&mut detached.memory, PPC_DATA_BASE, 0x80),
Some(detached_pef)
);
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(detached_manager.native_allocation(handle), None);
assert!(detached_manager
.native_ptr_records()
.iter()
.any(|record| record.ptr == ptr && record.size == 32));
assert_eq!(
ppc_memory_read_bytes(
&mut detached.memory,
ptr,
b"external PEF payload".len() as u32,
),
Some(b"external PEF payload".to_vec())
);
}
#[test]
fn ppc_set_ptr_size_mutates_a_classic_pointer_without_moving_it() {
let pef = synthetic_pef_with_import(b"SetPtrSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x1000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let original = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 64);
classic_bus.fill_bytes(original, 64, 0x6a);
context
.memory_manager_mut()
.dispose_process_ptr(&mut classic_bus, original);
let ptr = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
assert_eq!(ptr, original);
classic_bus.fill_bytes(ptr, 16, 0x5a);
let neighbor = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.fill_bytes(neighbor, 16, 0xa5);
let cursor = context.classic_heap_bump_ptr();
let mut detached = native.clone();
context
.memory_manager_mut()
.set_native_mem_error(PPC_PARAM_ERR);
assert_eq!(
context
.memory_manager_mut()
.set_process_ptr_size(&mut classic_bus, ptr, 12),
PPC_NO_ERR
);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::MemError;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
});
assert_eq!(
context
.memory_manager_mut()
.set_process_ptr_size(&mut classic_bus, ptr, 65),
PPC_MEM_FULL_ERR
);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::MemError;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_MEM_FULL_ERR));
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetPtrSize;
});
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = ptr;
native.cpu.gpr[4] = 8;
let probe = native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(native.cpu.gpr[3], ptr);
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(8));
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::MemError;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetPtrSize;
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = ptr;
native.cpu.gpr[4] = 48;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ptr);
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(48));
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
let bytes_before_failure = ppc_memory_read_bytes(&mut native.memory, ptr, 64).unwrap();
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = ptr;
native.cpu.gpr[4] = 65;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ptr);
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(48));
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_FULL_ERR)
);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, ptr, 64),
Some(bytes_before_failure)
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::MemError;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_MEM_FULL_ERR));
});
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(48));
assert_eq!(classic_bus.read_bytes(ptr, 8), vec![0x5a; 8]);
assert_eq!(classic_bus.read_bytes(ptr + 8, 8), vec![0; 8]);
assert_eq!(classic_bus.read_bytes(neighbor, 16), vec![0xa5; 16]);
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.classic_allocation_size(ptr),
Some(16)
);
assert_eq!(
ppc_memory_read_bytes(&mut detached.memory, ptr, 16),
Some(vec![0x5a; 16])
);
}
#[test]
fn attaching_and_cloning_native_adapters_preserves_process_ownership() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut native = load_pef_application(&pef).unwrap();
let standalone_memory_manager = native.process_memory_manager.0.clone();
native.cpu.gpr[3] = 24;
run_test_import(
&mut native,
PpcImportDispatcherTarget::NewHandle { clear: true },
);
let handle = native.cpu.gpr[3];
let mut detached = native.clone();
assert!(!detached
.process_memory_manager
.0
.ptr_eq(&native.process_memory_manager.0));
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let process_memory_manager = context.memory_manager_handle().clone();
assert!(native
.process_memory_manager
.ptr_eq(&process_memory_manager));
assert!(!standalone_memory_manager.borrow().has_native_allocator());
assert!(standalone_memory_manager
.borrow()
.native_handle_records()
.is_empty());
let attached_heap = process_memory_manager.borrow().native_heap_state().unwrap();
let expected_free = ppc_heap_free_capacity(
&mut native.memory,
attached_heap.heap_cursor,
attached_heap.heap_limit,
)
.0;
assert_eq!(
native.memory.read_u32_be(PPC_APPLICATION_ZONE + 12),
Some(expected_free)
);
assert_eq!(
native.memory.read_u32_be(PPC_SYSTEM_ZONE + 12),
Some(expected_free)
);
let detached_heap_cursor = detached.heap_cursor();
let detached_handle_record = detached.handles()[0];
let attached_heap_cursor = native.heap_cursor() + 0x80;
let attached_heap_limit = native.heap_limit() - 0x1000;
process_memory_manager
.borrow_mut()
.set_native_handle_state(PpcHandleStateRecord {
handle,
locked: true,
high_locked: true,
no_purge: true,
resource: true,
});
process_memory_manager
.borrow_mut()
.mutate_native_allocator(|allocator| {
allocator.heap.heap_cursor = attached_heap_cursor;
allocator.heap.heap_limit = attached_heap_limit;
allocator.heap.last_mem_error = PPC_PARAM_ERR;
allocator.heap.heap_maximized = true;
allocator.heap.master_pointer_blocks_requested = 7;
allocator.ptrs.push(ProcessPtrRecord {
ptr: PPC_HEAP_BASE + 0x100,
size: 16,
});
allocator.free_ptr_blocks.push(ProcessPtrRecord {
ptr: PPC_HEAP_BASE + 0x200,
size: 32,
});
allocator.free_handle_blocks.push(ProcessHandleRecord {
handle: PPC_HEAP_BASE + 0x300,
ptr: PPC_HEAP_BASE + 0x400,
size: 24,
capacity: 48,
});
});
let mut attached_handle_record = process_memory_manager
.borrow()
.native_allocation(handle)
.unwrap();
attached_handle_record.size = 20;
process_memory_manager
.borrow_mut()
.set_native_allocation(attached_handle_record);
assert!(native.heap_maximized());
assert_eq!(native.heap_cursor(), attached_heap_cursor);
assert_eq!(native.heap_limit(), attached_heap_limit);
assert_eq!(native.last_mem_error(), PPC_PARAM_ERR);
assert_eq!(native.master_pointer_blocks_requested(), 7);
assert!(!detached.heap_maximized());
assert_eq!(detached.heap_cursor(), detached_heap_cursor);
assert_eq!(detached.heap_limit(), detached.stack_base);
assert_eq!(detached.last_mem_error(), PPC_NO_ERR);
assert_eq!(detached.master_pointer_blocks_requested(), 0);
assert_eq!(native.ptrs().last().map(|record| record.size), Some(16));
assert_eq!(
native.free_ptr_blocks().last().map(|record| record.size),
Some(32)
);
assert!(detached.ptrs().is_empty());
assert!(detached.free_ptr_blocks().is_empty());
assert_eq!(
native
.free_handle_blocks()
.last()
.map(|record| record.capacity),
Some(48)
);
assert!(detached.free_handle_blocks().is_empty());
assert!(native.handle_states()[0].high_locked);
assert!(!detached.handle_states()[0].high_locked);
assert_eq!(native.handles()[0], attached_handle_record);
assert_eq!(detached.handles()[0], detached_handle_record);
native.cpu.gpr[3] = handle;
run_test_import(&mut native, PpcImportDispatcherTarget::HGetState);
assert_eq!(native.cpu.gpr[3], 0xa0);
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.state_for_handle(handle),
Some(0)
);
detached.cpu.gpr[3] = handle;
run_test_import(&mut detached, PpcImportDispatcherTarget::HGetState);
assert_eq!(detached.cpu.gpr[3], 0);
}
#[test]
fn attaching_a_pristine_native_adapter_retains_the_populated_process_allocator() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut owner = load_pef_application(&pef).unwrap();
owner.cpu.gpr[3] = 24;
run_test_import(
&mut owner,
PpcImportDispatcherTarget::NewPtr { clear: true },
);
let ptr = owner.cpu.gpr[3];
let mut context = ProcessContext::default();
owner.attach_unconverted_process_services(&mut context);
let canonical = context.memory_manager_handle().clone();
let canonical_allocator = canonical.borrow().native_allocator_snapshot();
let mut observer = load_pef_application(&pef).unwrap();
let standalone = observer.process_memory_manager.0.clone();
observer.attach_unconverted_process_services(&mut context);
assert!(observer.process_memory_manager.ptr_eq(&canonical));
assert_eq!(canonical.borrow().native_allocator_snapshot(), canonical_allocator);
assert_eq!(canonical.borrow_mut().native_ptr_size(ptr), 24);
assert!(!standalone.borrow().has_native_allocator());
let heap = canonical.borrow().native_heap_state().unwrap();
let expected_free =
ppc_heap_free_capacity(&mut observer.memory, heap.heap_cursor, heap.heap_limit).0;
assert_eq!(
observer.memory.read_u32_be(PPC_APPLICATION_ZONE + 12),
Some(expected_free)
);
assert_eq!(
observer.memory.read_u32_be(PPC_SYSTEM_ZONE + 12),
Some(expected_free)
);
}
#[test]
fn attaching_two_populated_native_adapters_is_atomic() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut owner = load_pef_application(&pef).unwrap();
owner.cpu.gpr[3] = 24;
run_test_import(
&mut owner,
PpcImportDispatcherTarget::NewPtr { clear: true },
);
let mut context = ProcessContext::default();
owner.attach_unconverted_process_services(&mut context);
let canonical = context.memory_manager_handle().clone();
let mut rejected = load_pef_application(&pef).unwrap();
rejected.cpu.gpr[3] = 48;
run_test_import(
&mut rejected,
PpcImportDispatcherTarget::NewPtr { clear: true },
);
let standalone = rejected.process_memory_manager.0.clone();
let canonical_allocator = canonical.borrow().native_allocator_snapshot();
let standalone_allocator = standalone.borrow().native_allocator_snapshot();
let application_zone = rejected.memory.read_u32_be(PPC_APPLICATION_ZONE + 12);
let system_zone = rejected.memory.read_u32_be(PPC_SYSTEM_ZONE + 12);
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
rejected.attach_unconverted_process_services(&mut context);
}));
assert!(result.is_err());
assert!(!rejected.process_memory_manager.ptr_eq(&canonical));
assert_eq!(canonical.borrow().native_allocator_snapshot(), canonical_allocator);
assert_eq!(standalone.borrow().native_allocator_snapshot(), standalone_allocator);
assert_eq!(
rejected.memory.read_u32_be(PPC_APPLICATION_ZONE + 12),
application_zone
);
assert_eq!(
rejected.memory.read_u32_be(PPC_SYSTEM_ZONE + 12),
system_zone
);
}
#[test]
fn ppc_ptr_imports_mutate_the_process_memory_manager_immediately() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 24;
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(
|native, memory_manager| {
let prior_ptr = memory_manager.new_native_ptr(&mut native.memory, 24, false);
assert_eq!(prior_ptr, PPC_HEAP_BASE);
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
let ptr = native.cpu.gpr[3];
assert_eq!(ptr, PPC_HEAP_BASE + ppc_allocation_size(24).unwrap());
assert_eq!(
memory_manager
.native_allocator()
.and_then(|allocator| allocator.ptrs.last())
.copied(),
Some(ProcessPtrRecord { ptr, size: 24 })
);
assert_eq!(
memory_manager
.native_allocator()
.and_then(|allocator| allocator.ptrs.first())
.copied(),
Some(ProcessPtrRecord {
ptr: prior_ptr,
size: 24,
})
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetPtrSize;
native.cpu.gpr[3] = ptr;
native.cpu.gpr[4] = 40;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_allocator()
.and_then(|allocator| allocator.ptrs.last())
.copied(),
Some(ProcessPtrRecord { ptr, size: 40 })
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetPtrSize;
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 40);
assert_eq!(
memory_manager
.native_allocator()
.map(|allocator| allocator.heap.last_mem_error),
Some(PPC_NO_ERR)
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposePtr;
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
let allocator = memory_manager.native_allocator().unwrap();
assert_eq!(
allocator.ptrs,
vec![ProcessPtrRecord {
ptr: prior_ptr,
size: 24,
}]
);
assert_eq!(
allocator.free_ptr_blocks,
vec![ProcessPtrRecord { ptr, size: 40 }]
);
},
);
}
#[test]
fn ppc_handle_imports_mutate_the_process_memory_manager_immediately() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 24;
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_dispatcher = TrapDispatcher::new();
classic_dispatcher.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(
|native, memory_manager| {
native.run_with_process_memory_manager(64, false, false, memory_manager);
let handle = native.cpu.gpr[3];
let original = memory_manager.native_allocation(handle).unwrap();
let detached_memory_manager = memory_manager.detached_clone();
assert_eq!(original.size, 24);
assert_eq!(classic_dispatcher.handle_state_bits(handle), Some(0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = original.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], handle);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HLock;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.handle_state(handle), 0x80);
assert_eq!(classic_dispatcher.handle_state_bits(handle), Some(0x80));
assert_eq!(detached_memory_manager.state_for_handle(handle), Some(0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HLockHi;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert!(memory_manager.native_handle_state(handle).high_locked);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HNoPurge;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.handle_state(handle), 0x80);
assert_eq!(classic_dispatcher.handle_state_bits(handle), Some(0x80));
memory_manager.set_state_for_handle(handle, 0xa0);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HGetState;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0xa0);
assert!(
(0..32).all(|offset| native.memory.read_u8(original.ptr + offset) == Some(0))
);
native
.memory
.write_bytes(original.ptr, b"process-owned")
.unwrap();
let blocking_ptr = memory_manager.new_native_ptr(&mut native.memory, 16, false);
assert_ne!(blocking_ptr, 0);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetHandleSize;
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 64;
native.run_with_process_memory_manager(64, false, false, memory_manager);
let grown = memory_manager.native_allocation(handle).unwrap();
assert_ne!(grown.ptr, original.ptr);
assert_eq!((grown.size, grown.capacity), (64, 64));
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, grown.ptr, 13),
Some(b"process-owned".to_vec())
);
assert_eq!(native.memory.read_u32_be(handle), Some(grown.ptr));
assert_eq!(
memory_manager
.native_handle_records()
.iter()
.find(|record| record.handle == handle)
.copied(),
Some(grown)
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = original.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = grown.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], handle);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetHandleSize;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 64);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(-112)
);
assert_eq!(native.memory.read_u32_be(handle), Some(grown.ptr));
assert_eq!(memory_manager.native_allocation(handle), Some(grown));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HUnlock;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.state_for_handle(handle), Some(0x20));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(native.memory.read_u32_be(handle), Some(0));
assert_eq!(
memory_manager.native_allocation(handle),
Some(ProcessHandleRecord {
handle,
ptr: 0,
size: 0,
capacity: 0,
})
);
assert_eq!(memory_manager.recover_handle(grown.ptr), None);
assert!(memory_manager
.native_allocator()
.unwrap()
.free_ptr_blocks
.iter()
.any(|record| record.ptr == grown.ptr && record.size == grown.capacity));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.native_allocation(handle), None);
assert_eq!(native.memory.read_u32_be(handle), Some(0));
assert!(!memory_manager
.native_handle_records()
.iter()
.any(|record| record.handle == handle));
assert!(memory_manager
.native_allocator()
.unwrap()
.free_handle_blocks
.iter()
.any(|record| record.handle == handle && record.ptr == 0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = grown.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target =
PpcImportDispatcherTarget::NewHandle { clear: true };
native.cpu.gpr[3] = 32;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], handle);
let reused = memory_manager.native_allocation(handle).unwrap();
assert_ne!(reused.ptr, 0);
assert_eq!((reused.size, reused.capacity), (32, 32));
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, reused.ptr, 32),
Some(vec![0; 32])
);
assert!(!memory_manager
.native_allocator()
.unwrap()
.free_handle_blocks
.iter()
.any(|record| record.handle == handle));
},
);
}
#[test]
fn ppc_resource_imports_mutate_process_handle_state_across_isa() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut native = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let name_ptr = scratch;
native.memory.add_region(scratch, vec![0; 0x40]);
write_ppc_pstring(&mut native.memory, name_ptr, b"Shared");
native.set_current_resource_refnum(PPC_FIRST_FILE_REF_NUM);
native.cpu.gpr[3] = 16;
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic = TrapDispatcher::new();
classic.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(|native, memory_manager| {
native.run_with_process_memory_manager(64, false, false, memory_manager);
let handle = native.cpu.gpr[3];
assert_ne!(handle, 0);
memory_manager.set_state_for_handle(handle, 0xc0);
let detached = memory_manager.detached_clone();
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::AddResource;
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = u32::from_be_bytes(*b"TEST");
native.cpu.gpr[5] = 128;
native.cpu.gpr[6] = 0xdead_beef;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_ADD_RES_FAILED);
assert_eq!(memory_manager.handle_state(handle), 0xc0);
assert_eq!(classic.handle_state_bits(handle), Some(0xc0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[6] = name_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_NO_ERR);
assert_eq!(memory_manager.handle_state(handle), 0xe0);
assert_eq!(classic.handle_state_bits(handle), Some(0xe0));
assert_eq!(detached.state_for_handle(handle), Some(0xc0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target =
PpcImportDispatcherTarget::NewHandle { clear: true };
native.cpu.gpr[3] = 8;
native.run_with_process_memory_manager(64, false, false, memory_manager);
let replacement = native.cpu.gpr[3];
memory_manager.set_state_for_handle(replacement, 0x80);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::AddResource;
native.cpu.gpr[3] = replacement;
native.cpu.gpr[4] = u32::from_be_bytes(*b"TEST");
native.cpu.gpr[5] = 128;
native.cpu.gpr[6] = name_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_NO_ERR);
assert_eq!(memory_manager.handle_state(handle), 0xc0);
assert_eq!(classic.handle_state_bits(handle), Some(0xc0));
assert_eq!(memory_manager.handle_state(replacement), 0xa0);
assert_eq!(classic.handle_state_bits(replacement), Some(0xa0));
assert_eq!(detached.state_for_handle(replacement), None);
native.set_current_resource_refnum(PPC_FIRST_FILE_REF_NUM + 1);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RemoveResource;
native.cpu.gpr[3] = replacement;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_RMV_RES_FAILED);
assert_eq!(memory_manager.handle_state(replacement), 0xa0);
assert_eq!(classic.handle_state_bits(replacement), Some(0xa0));
native.set_current_resource_refnum(PPC_FIRST_FILE_REF_NUM);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_NO_ERR);
assert_eq!(memory_manager.handle_state(handle), 0xc0);
assert_eq!(classic.handle_state_bits(handle), Some(0xc0));
assert_eq!(memory_manager.handle_state(replacement), 0x80);
assert_eq!(classic.handle_state_bits(replacement), Some(0x80));
assert_eq!(detached.state_for_handle(handle), Some(0xc0));
assert!(native.process_file_system.vfs_resources.is_empty());
});
}
#[test]
fn ppc_recover_handle_validates_reused_classic_master_pointer_slots() {
let pef = synthetic_pef_with_import(b"RecoverHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x4000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (old_handle, old_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let mut detached = native.clone();
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = old_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], old_handle);
});
context
.memory_manager_mut()
.dispose_classic_handle(&mut classic_bus, old_handle, true);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = old_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], old_handle);
});
let (new_handle, new_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 32)
.unwrap();
assert_eq!(new_handle, old_handle);
assert_ne!(new_ptr, old_ptr);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = old_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(old_ptr), None);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = new_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], new_handle);
});
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.recover_handle(old_ptr),
Some(old_handle)
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, old_handle),
Some(old_ptr)
);
}
#[test]
fn ppc_recover_handle_rejects_a_guest_mutated_classic_master_pointer_slot() {
let pef = synthetic_pef_with_import(b"RecoverHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x4000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let mut detached = native.clone();
classic_bus.write_long(handle, ptr + 4);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(ptr), None);
});
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.recover_handle(ptr),
Some(handle)
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
}
#[test]
fn ppc_recover_handle_rejects_a_reused_nil_classic_master_pointer_slot() {
let pef = synthetic_pef_with_import(b"RecoverHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x4000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (old_handle, old_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
context
.memory_manager_mut()
.dispose_classic_handle(&mut classic_bus, old_handle, true);
let empty_handle = context
.memory_manager_mut()
.new_empty_classic_handle(&mut classic_bus)
.unwrap();
assert_eq!(empty_handle, old_handle);
assert_eq!(classic_bus.read_long(empty_handle), 0);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = old_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(old_ptr), None);
});
}
#[test]
fn ppc_recover_handle_rejects_a_guest_mutated_native_master_pointer_slot() {
let pef = synthetic_pef_with_import(b"RecoverHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let (handle, ptr) = native.with_process_memory_manager(|native, memory_manager| {
let handle = memory_manager.new_native_handle(&mut native.memory, 24, true);
let ptr = PpcMemory::read_u32_be(&mut native.memory, handle).unwrap();
(handle, ptr)
});
let mut detached = native.clone();
PpcMemory::write_u32_be(&mut native.memory, handle, 0).unwrap();
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(ptr), None);
});
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.recover_handle(ptr),
Some(handle)
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
}
#[test]
fn ppc_recover_handle_rejects_a_directly_disposed_native_handle() {
let pef = synthetic_pef_with_import(b"NewHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = 24;
native.run_with_process_memory_manager(64, false, false, memory_manager);
let handle = native.cpu.gpr[3];
let record = memory_manager.native_allocation(handle).unwrap();
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(0));
assert_eq!(memory_manager.native_allocation(handle), None);
assert_eq!(memory_manager.recover_handle(record.ptr), None);
assert!(memory_manager
.native_allocator()
.unwrap()
.free_handle_blocks
.contains(&record));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = record.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
});
}
#[test]
fn resource_fork_materialization_preserves_live_edits_and_other_paths() {
let fork = serialize_resource_fork(&[
ResourceForkEntry {
res_type: *b"TEST",
id: 1,
name: vec![],
data: b"raw".to_vec(),
attrs: 0,
},
ResourceForkEntry {
res_type: *b"TEST",
id: 2,
name: vec![],
data: b"second".to_vec(),
attrs: 0,
},
ResourceForkEntry {
res_type: *b"DATA",
id: 1,
name: vec![],
data: b"data".to_vec(),
attrs: 0,
},
])
.unwrap();
let files = [PpcVfsResourceFileRecord {
path: "App".into(),
creator: 0,
file_type: 0,
finder_flags: 0,
resource_len: fork.len() as u32,
raw_data: Some(fork.into()),
map_attrs: 0,
dirty: false,
}];
let edited = PpcVfsResourceRecord {
ref_num: 7,
path: "APP".into(),
res_type: u32::from_be_bytes(*b"TEST"),
res_id: 1,
name: b"edited name".to_vec(),
data: b"edited".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 2,
handle: 0x1234,
};
let mut other = edited.clone();
other.path = "Other".into();
other.res_id = 2;
let mut resources = vec![edited, other];
ppc_materialize_resource_records_for_path(&files, &mut resources, "app");
ppc_materialize_resource_records_for_path(&files, &mut resources, "APP");
assert_eq!(resources.len(), 4);
assert_eq!(resources[0].data, b"edited");
assert_eq!(resources[0].name, b"edited name");
assert_eq!(
(
resources[0].ref_num,
resources[0].attrs,
resources[0].handle
),
(7, 2, 0x1234)
);
assert_eq!(resources[1].path, "Other");
assert_eq!(
(resources[2].res_type, resources[2].res_id),
(u32::from_be_bytes(*b"DATA"), 1)
);
assert_eq!(
(resources[3].res_type, resources[3].res_id),
(u32::from_be_bytes(*b"TEST"), 2)
);
assert_eq!(resources[3].data, b"second");
}
#[test]
fn ppc_resource_materialization_mutates_process_manager_immediately() {
let pef = synthetic_pef_with_import(b"GetResource");
let mut native = load_pef_application(&pef).unwrap();
let external_handle = PPC_DATA_BASE + 0x2140;
native.memory.add_region(external_handle, vec![0; 4]);
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_dispatcher = TrapDispatcher::new();
classic_dispatcher.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(
|native, memory_manager| {
let allocator = memory_manager.native_allocator_snapshot().unwrap();
let mut heap_cursor = allocator.heap.heap_cursor;
let heap_limit = allocator.heap.heap_limit;
let mut last_mem_error = allocator.heap.last_mem_error;
let mut handles = memory_manager.native_handle_records().to_vec();
let mut resources = vec![PpcVfsResourceRecord {
ref_num: 0,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"pref"),
res_id: 42,
name: b"Prefs".to_vec(),
data: b"process resource".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
}];
let mut last_resource_error = PPC_NO_ERR;
let canonical_ptr =
memory_manager.new_native_ptr(&mut native.memory, 32, true);
assert_ne!(canonical_ptr, 0);
let cursor_after_canonical_allocation = memory_manager
.native_heap_state()
.unwrap()
.heap_cursor;
let handle = ppc_materialize_vfs_resource_handle(
memory_manager,
&mut native.memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
&mut resources,
0,
false,
&mut last_resource_error,
);
assert_ne!(handle, 0);
assert!(handle >= cursor_after_canonical_allocation);
assert_eq!(memory_manager.native_allocation(handle).unwrap().ptr, 0);
assert_eq!(memory_manager.state_for_handle(handle), Some(0x60));
assert_eq!(classic_dispatcher.handle_state_bits(handle), Some(0x60));
let detached = memory_manager.detached_clone();
let loaded = ppc_materialize_vfs_resource_handle(
memory_manager,
&mut native.memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
&mut resources,
0,
true,
&mut last_resource_error,
);
assert_eq!(loaded, handle);
let record = memory_manager.native_allocation(handle).unwrap();
let shared = native.memory.shared_view();
let mut classic_bus = MacMemoryBus::new(0x2000);
classic_bus.attach_guest_address_space(shared);
assert_eq!(
classic_bus.read_bytes(record.ptr, record.size as usize),
b"process resource"
);
assert_eq!(memory_manager.recover_handle(record.ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x60));
assert_eq!(detached.native_allocation(handle).unwrap().ptr, 0);
assert_eq!(detached.recover_handle(record.ptr), None);
assert_eq!(last_mem_error, PPC_NO_ERR);
assert_eq!(last_resource_error, PPC_NO_ERR);
let mut external_resources = vec![PpcVfsResourceRecord {
ref_num: 0,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"STR "),
res_id: 128,
name: b"External".to_vec(),
data: b"PEF master pointer".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: external_handle,
}];
let materialized = ppc_materialize_vfs_resource_handle(
memory_manager,
&mut native.memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
&mut external_resources,
0,
true,
&mut last_resource_error,
);
assert_eq!(materialized, external_handle);
assert_eq!(memory_manager.native_allocation(external_handle), None);
let external_ptr = native.memory.read_u32_be(external_handle).unwrap();
assert_ne!(external_ptr, 0);
assert_eq!(
memory_manager.recover_handle(external_ptr),
Some(external_handle)
);
assert_eq!(memory_manager.state_for_handle(external_handle), Some(0x60));
assert_eq!(
classic_dispatcher.handle_state_bits(external_handle),
Some(0x60)
);
assert_eq!(
classic_bus.read_bytes(external_ptr, b"PEF master pointer".len()),
b"PEF master pointer"
);
assert_eq!(detached.recover_handle(external_ptr), None);
},
);
}
#[test]
fn ppc_handle_copy_imports_mutate_process_memory_immediately() {
let pef = synthetic_pef_with_import(b"PtrToHand");
let mut native = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x2100;
let source = scratch;
let output = scratch + 0x20;
let handle_variable = scratch + 0x24;
native.memory.add_region(scratch, vec![0; 0x100]);
native.memory.write_bytes(source, b"native").unwrap();
let mut classic_bus = crate::memory::MacMemoryBus::new(0x2000);
let shared = native.memory.shared_view();
classic_bus.attach_guest_address_space(shared);
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(
|native, memory_manager| {
native.cpu.gpr[3] = source;
native.cpu.gpr[4] = output;
native.cpu.gpr[5] = 6;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
let destination = native.memory.read_u32_be(output).unwrap();
let original = memory_manager.native_allocation(destination).unwrap();
assert_eq!(classic_bus.read_bytes(original.ptr, 6), b"native");
assert_eq!(memory_manager.state_for_handle(destination), Some(0));
native
.memory
.write_u32_be(handle_variable, destination)
.unwrap();
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HandToHand;
native.cpu.gpr[3] = handle_variable;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
let source_copy = native.memory.read_u32_be(handle_variable).unwrap();
assert_ne!(source_copy, destination);
let copy = memory_manager.native_allocation(source_copy).unwrap();
assert_eq!(classic_bus.read_bytes(copy.ptr, 6), b"native");
assert_eq!(memory_manager.state_for_handle(source_copy), Some(0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HandAndHand;
native.cpu.gpr[3] = source_copy;
native.cpu.gpr[4] = destination;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
let appended = memory_manager.native_allocation(destination).unwrap();
assert_eq!(appended.size, 12);
assert_eq!(classic_bus.read_long(destination), appended.ptr);
assert_eq!(classic_bus.read_bytes(appended.ptr, 12), b"nativenative");
assert_eq!(
memory_manager
.native_handle_records()
.iter()
.find(|record| record.handle == destination)
.copied(),
Some(appended)
);
assert_eq!(
memory_manager
.native_allocator()
.map(|allocator| allocator.heap.last_mem_error),
Some(PPC_NO_ERR)
);
},
);
}
#[test]
fn ppc_hand_to_hand_copies_a_process_owned_classic_handle_across_isa() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
classic_bus.attach_guest_address_space(native.memory.shared_view());
let payload = b"classic HandToHand source";
let (source_handle, source_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, payload.len() as u32)
.unwrap();
classic_bus.write_bytes(source_ptr, payload);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(source_handle, 0xe0);
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, source_handle)
.unwrap();
let mut detached = native.clone();
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let copy_handle = native.memory.read_u32_be(handle_variable).unwrap();
assert_ne!(copy_handle, source_handle);
let copy_ptr = classic_bus.read_long(copy_handle);
assert_ne!(copy_ptr, 0);
assert_eq!(classic_bus.get_alloc_size(copy_handle), Some(4));
assert_eq!(
classic_bus.get_alloc_size(copy_ptr),
Some(payload.len() as u32)
);
assert_eq!(classic_bus.read_bytes(copy_ptr, payload.len()), payload);
assert_eq!(classic_bus.read_long(source_handle), source_ptr);
assert_eq!(classic_bus.read_bytes(source_ptr, payload.len()), payload);
assert_eq!(memory_manager.borrow().native_allocation(copy_handle), None);
assert_eq!(memory_manager.borrow().handle_for_ptr(copy_ptr), Some(copy_handle));
assert_eq!(memory_manager.borrow().handle_for_ptr(source_ptr), Some(source_handle));
assert_eq!(memory_manager.borrow().state_for_handle(copy_handle), Some(0));
assert_eq!(classic.handle_state_bits(copy_handle), Some(0));
assert_eq!(memory_manager.borrow().state_for_handle(source_handle), Some(0xe0));
let mut classic_cpu = crate::trap::test_helpers::MockCpu::new();
classic_cpu.write_reg(Register::A0, copy_ptr);
classic
.dispatch_memory(false, 0x28, &mut classic_cpu, &mut classic_bus)
.expect("68K RecoverHandle should be handled")
.expect("68K RecoverHandle should succeed");
assert_eq!(classic_cpu.read_reg(Register::A0), copy_handle);
assert_eq!(classic_cpu.read_reg(Register::D0), 0);
assert_eq!(classic.handle_for_ptr(copy_ptr), Some(copy_handle));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, source_handle),
Some(source_ptr)
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle_variable),
Some(source_handle)
);
assert_eq!(detached_manager.classic_allocation_size(source_handle), Some(4));
assert_eq!(
detached_manager.classic_allocation_size(source_ptr),
Some(payload.len() as u32)
);
assert_eq!(detached_manager.classic_allocation_size(copy_handle), None);
assert_eq!(detached_manager.classic_allocation_size(copy_ptr), None);
assert_eq!(detached_manager.native_allocation(copy_handle), None);
assert_eq!(detached_manager.handle_for_ptr(source_ptr), Some(source_handle));
assert_eq!(detached_manager.handle_for_ptr(copy_ptr), None);
assert_eq!(detached_manager.state_for_handle(source_handle), Some(0xe0));
}
#[test]
fn ppc_hand_to_hand_rejects_a_foreign_classic_data_block_atomically() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (source_handle, source_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let (other_handle, other_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 24)
.unwrap();
let source_bytes = (0x20..=0x2f).collect::<Vec<_>>();
let other_bytes = (0x80..=0x97).collect::<Vec<_>>();
classic_bus.write_bytes(source_ptr, &source_bytes);
classic_bus.write_bytes(other_ptr, &other_bytes);
classic_bus.write_long(source_handle, other_ptr);
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, source_handle)
.unwrap();
let memory_manager = context.memory_manager_handle().clone();
let allocator_before = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator is attached");
let handles_before = memory_manager.borrow().native_handle_records().to_vec();
let classic_cursor_before = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_MEM_WZ_ERR));
assert_eq!(native.memory.read_u32_be(handle_variable), Some(source_handle));
assert_eq!(classic_bus.read_long(source_handle), other_ptr);
assert_eq!(classic_bus.read_long(other_handle), other_ptr);
assert_eq!(classic_bus.get_alloc_size(source_ptr), Some(16));
assert_eq!(classic_bus.get_alloc_size(other_ptr), Some(24));
assert_eq!(classic_bus.read_bytes(source_ptr, 16), source_bytes);
assert_eq!(classic_bus.read_bytes(other_ptr, 24), other_bytes);
assert_eq!(context.classic_heap_bump_ptr(), classic_cursor_before);
assert_eq!(memory_manager.borrow().handle_for_ptr(source_ptr), Some(source_handle));
assert_eq!(memory_manager.borrow().handle_for_ptr(other_ptr), Some(other_handle));
assert_eq!(memory_manager.borrow().native_handle_records(), handles_before);
let allocator_after = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator remains attached");
assert_eq!(allocator_after.heap.heap_cursor, allocator_before.heap.heap_cursor);
assert_eq!(allocator_after.ptrs, allocator_before.ptrs);
assert_eq!(allocator_after.free_ptr_blocks, allocator_before.free_ptr_blocks);
assert_eq!(
allocator_after.free_handle_blocks,
allocator_before.free_handle_blocks
);
assert_eq!(allocator_after.heap.last_mem_error, PPC_MEM_WZ_ERR);
}
#[test]
fn ppc_hand_to_hand_rejects_a_disposed_classic_source_atomically() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let payload = b"disposed classic source";
let (source_handle, source_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, payload.len() as u32)
.unwrap();
classic_bus.write_bytes(source_ptr, payload);
let memory_manager = context.memory_manager_handle().clone();
assert!(memory_manager
.borrow_mut()
.dispose_process_handle_from_native_import(&mut native.memory, source_handle));
let stale_master = classic_bus.read_long(source_handle);
let stale_bytes = classic_bus.read_bytes(source_ptr, payload.len());
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, source_handle)
.unwrap();
let classic_cursor_before = context.classic_heap_bump_ptr();
let allocator_before = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator is attached");
let handles_before = memory_manager.borrow().native_handle_records().to_vec();
let reverse_before = memory_manager.borrow().handle_for_ptr(source_ptr);
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NIL_HANDLE_ERR));
assert_eq!(native.memory.read_u32_be(handle_variable), Some(source_handle));
assert_eq!(classic_bus.read_long(source_handle), stale_master);
assert_eq!(classic_bus.read_bytes(source_ptr, payload.len()), stale_bytes);
assert_eq!(context.classic_heap_bump_ptr(), classic_cursor_before);
assert_eq!(memory_manager.borrow().classic_allocation_size(source_handle), None);
assert_eq!(memory_manager.borrow().classic_allocation_size(source_ptr), None);
assert_eq!(memory_manager.borrow().handle_for_ptr(source_ptr), reverse_before);
assert_eq!(memory_manager.borrow().state_for_handle(source_handle), None);
assert_eq!(memory_manager.borrow().native_handle_records(), handles_before);
let allocator_after = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator remains attached");
assert_eq!(allocator_after.heap.heap_cursor, allocator_before.heap.heap_cursor);
assert_eq!(allocator_after.ptrs, allocator_before.ptrs);
assert_eq!(allocator_after.free_ptr_blocks, allocator_before.free_ptr_blocks);
assert_eq!(
allocator_after.free_handle_blocks,
allocator_before.free_handle_blocks
);
assert_eq!(allocator_after.heap.last_mem_error, PPC_NIL_HANDLE_ERR);
}
#[test]
fn ppc_hand_to_hand_rejects_a_readonly_handle_variable_before_allocating() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
let source_handle = memory_manager
.borrow_mut()
.copy_bytes_to_new_native_handle(&mut native.memory, b"source");
assert_ne!(source_handle, 0);
let handle_variable = PPC_DATA_BASE + 0x2100;
native
.memory
.add_readonly_region(handle_variable, source_handle.to_be_bytes().to_vec());
let allocator_before = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator is attached");
let handles_before = memory_manager.borrow().native_handle_records().to_vec();
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(native.memory.read_u32_be(handle_variable), Some(source_handle));
assert_eq!(memory_manager.borrow().native_handle_records(), handles_before);
let allocator_after = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator remains attached");
assert_eq!(allocator_after.heap.heap_cursor, allocator_before.heap.heap_cursor);
assert_eq!(allocator_after.ptrs, allocator_before.ptrs);
assert_eq!(allocator_after.free_ptr_blocks, allocator_before.free_ptr_blocks);
assert_eq!(
allocator_after.free_handle_blocks,
allocator_before.free_handle_blocks
);
assert_eq!(allocator_after.heap.last_mem_error, PPC_PARAM_ERR);
}
#[test]
fn ppc_hand_to_hand_preserves_the_toolbox_color_table_fallback() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
ppc_seed_main_color_table(&mut native.memory).unwrap();
let expected = ppc_memory_read_bytes(
&mut native.memory,
PPC_MAIN_CTABLE,
PPC_MAIN_CTABLE_SIZE,
)
.unwrap();
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, PPC_MAIN_CTABLE_HANDLE)
.unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let copy_handle = native.memory.read_u32_be(handle_variable).unwrap();
assert_ne!(copy_handle, PPC_MAIN_CTABLE_HANDLE);
let copy = memory_manager
.borrow()
.native_allocation(copy_handle)
.expect("Toolbox-owned data should retain the native fallback");
assert_eq!(copy.size, PPC_MAIN_CTABLE_SIZE);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, copy.ptr, copy.size),
Some(expected)
);
assert_eq!(memory_manager.borrow().state_for_handle(copy_handle), Some(0));
}
#[test]
fn ppc_hand_to_hand_color_table_heap_failure_is_atomic() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
ppc_seed_main_color_table(&mut native.memory).unwrap();
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, PPC_MAIN_CTABLE_HANDLE)
.unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
let allocator_before = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator is attached");
memory_manager
.borrow_mut()
.set_native_heap_limit(allocator_before.heap.heap_cursor + PPC_HEAP_ALIGNMENT);
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_MEM_FULL_ERR));
assert_eq!(
native.memory.read_u32_be(handle_variable),
Some(PPC_MAIN_CTABLE_HANDLE)
);
assert!(memory_manager.borrow().native_handle_records().is_empty());
let allocator_after = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator remains attached");
assert_eq!(allocator_after.heap.heap_cursor, allocator_before.heap.heap_cursor);
assert_eq!(allocator_after.ptrs, allocator_before.ptrs);
assert_eq!(allocator_after.free_ptr_blocks, allocator_before.free_ptr_blocks);
assert_eq!(
allocator_after.free_handle_blocks,
allocator_before.free_handle_blocks
);
assert_eq!(allocator_after.heap.last_mem_error, PPC_MEM_FULL_ERR);
}
#[test]
fn native_menu_flash_accessors_use_the_live_low_memory_word() {
let pef = synthetic_pef_with_import(b"SetMenuFlash");
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::MENU_FLASH),
Some(crate::memory::globals::DEFAULT_MENU_FLASH_COUNT)
);
loaded.cpu.gpr[3] = 0xcafe_0001;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuFlash);
assert_eq!(loaded.cpu.gpr[3], 0xcafe_0001);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::MENU_FLASH),
Some(1)
);
loaded.cpu.gpr[3] = 0xdead_beef;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LMGetMenuFlash);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, u16::MAX)
.unwrap();
run_test_import(&mut loaded, PpcImportDispatcherTarget::LMGetMenuFlash);
assert_eq!(loaded.cpu.gpr[3], u32::MAX);
}
#[test]
fn native_lmgetdefltstack_reads_the_live_low_memory_long() {
let pef = synthetic_pef_with_import(b"LMGetDefltStack");
let mut loaded = load_pef_application(&pef).unwrap();
let address = crate::memory::globals::addr::DEFLT_STACK;
assert_eq!(
loaded.memory.read_u32_be(address),
Some(crate::memory::globals::DEFAULT_DEFLT_STACK_SIZE)
);
loaded.memory.write_u32_be(address, 0x1234_5678).unwrap();
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LMGetDefltStack);
assert_eq!(loaded.cpu.gpr[3], 0x1234_5678);
}
#[test]
fn native_lmgetcurstackbase_reads_the_live_low_memory_long() {
let pef = synthetic_pef_with_import(b"LMGetCurStackBase");
let mut loaded = load_pef_application(&pef).unwrap();
let address = crate::memory::globals::addr::CUR_STACK_BASE;
assert_eq!(loaded.memory.read_u32_be(address), Some(loaded.stack_base));
loaded.memory.write_u32_be(address, 0x2345_6780).unwrap();
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LMGetCurStackBase);
assert_eq!(loaded.cpu.gpr[3], 0x2345_6780);
}
#[test]
fn native_insert_and_append_res_menu_share_resource_name_policy() {
let pef = synthetic_pef_with_import(b"InsertResMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Apple",
b"Existing;Tail",
);
let current = *loaded.process_file_system.current_resource_file;
let record = |ref_num, res_id, name: &[u8], byte| PpcVfsResourceRecord {
ref_num,
path: format!("Resources {ref_num}"),
res_type: u32::from_be_bytes(*b"DRVR"),
res_id,
name: name.to_vec(),
data: vec![byte],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
};
loaded.process_file_system.extend_vfs_resources([
record(current, 103, b"Zulu", 1),
record(current, 104, b"Alpha", 2),
record(current, 105, b".Hidden", 3),
record(current, 106, b"Existing", 4),
record(2, 103, b"Shadowed", 5),
record(2, 107, b"Beta", 6),
]);
loaded.policy.set_res_load(false);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"DRVR");
loaded.cpu.gpr[5] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::InsertResMenu);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap();
assert_eq!(
items
.items
.iter()
.map(|item| item.text.as_slice())
.collect::<Vec<_>>(),
[
b"Existing".as_slice(),
b"Alpha".as_slice(),
b"Beta".as_slice(),
b"Zulu".as_slice(),
b"Tail".as_slice(),
]
);
for item in &items.items[1..4] {
assert!(item.enabled);
assert_eq!(
(item.icon, item.command, item.mark, item.style),
(0, 0, 0, 0)
);
}
assert!(loaded.policy.res_load());
for resource in &loaded.process_file_system.vfs_resources {
if resource.name == b"Shadowed" {
assert_eq!(
resource.handle, 0,
"closer type/ID must shadow this resource"
);
} else {
assert_ne!(resource.handle, 0, "matching resources must be loaded");
assert_ne!(loaded.memory.read_u32_be(resource.handle), Some(0));
}
}
loaded.process_file_system.push_vfs_resource(record(2, 108, b"Gamma", 7));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"DRVR");
run_test_import(&mut loaded, PpcImportDispatcherTarget::AppendResMenu);
assert_eq!(
ppc_menu_items_from_memory(&mut loaded.memory, menu)
.unwrap()
.items
.iter()
.map(|item| item.text.as_slice())
.collect::<Vec<_>>(),
[
b"Existing".as_slice(),
b"Alpha".as_slice(),
b"Beta".as_slice(),
b"Zulu".as_slice(),
b"Tail".as_slice(),
b"Gamma".as_slice(),
]
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn native_append_res_menu_gives_fond_names_precedence_and_adds_builtin_fonts() {
let pef = synthetic_pef_with_import(b"AppendResMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 129, b"Font", b"");
let current = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num: current,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"FONT"),
res_id: 7,
name: b"Custom Face".to_vec(),
data: vec![1],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num: current,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"FOND"),
res_id: 8,
name: b"Custom Face".to_vec(),
data: vec![2],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"FONT");
run_test_import(&mut loaded, PpcImportDispatcherTarget::AppendResMenu);
let names = ppc_menu_items_from_memory(&mut loaded.memory, menu)
.unwrap()
.items
.into_iter()
.map(|item| item.text)
.collect::<Vec<_>>();
assert_eq!(
names
.iter()
.filter(|name| name.as_slice() == b"Custom Face")
.count(),
1,
"the FOND name must suppress the later FONT duplicate"
);
for expected in [b"Chicago".as_slice(), b"Geneva", b"Monaco", b"New York"] {
assert!(names.iter().any(|name| name == expected));
}
assert!(!names.iter().any(|name| name == b"Application"));
assert!(loaded
.vfs_resources
.iter()
.all(|resource| resource.handle != 0));
}
#[test]
fn hle_import_runner_menu_choice_returns_menu_disable_without_side_effects() {
let pef = synthetic_pef_with_import(b"MenuChoice");
let mut loaded = load_pef_application(&pef).unwrap();
let original_sp = loaded.cpu.gpr[1];
for expected in [0, (128u32 << 16) | 3, (201u32 << 16) | 0xffff] {
loaded
.memory
.write_u32_be(crate::memory::globals::addr::MENU_DISABLE, expected)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0xdead_beef;
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], expected);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_DISABLE),
Some(expected),
);
}
}
// The native standard MDEF must update the same live MenuDisable value as
// the 68k tracker even though a disabled row cannot become MenuSelect's
// highlighted result. Inside Macintosh Volume V (1986), pp. V-235 and
// V-248--V-249; Macintosh Toolbox Essentials (1992), pp. 3-118--3-119.
#[test]
fn native_menuselect_disabled_item_updates_live_menuchoice_result() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open/O");
ppc_set_menu_item_enabled(
&mut loaded.memory,
&test_handle_records!(loaded),
menu,
1,
false,
);
assert!(draw_current_test_menu_bar(&mut loaded));
let title_h = STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2;
loaded.cpu.gpr[3] = (u32::from(10u16) << 16) | u32::from(title_h as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: title_h,
..PpcInputSnapshot::default()
});
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 6,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0);
assert!(loaded.toolbox_startup.execution.menu().is_none());
let expected = menu_choice_value(128, 1);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_DISABLE),
Some(expected),
);
loaded.cpu.gpr[3] = 0xDEAD_BEEF;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuChoice);
assert_eq!(loaded.cpu.gpr[3], expected);
}
#[test]
fn hm_get_help_menu_handle_clears_output_and_returns_not_initialized() {
let pef = synthetic_pef_with_import(b"HMGetHelpMenuHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(menu_handle_ptr, vec![0xaa; 4]);
loaded.cpu.gpr[3] = menu_handle_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(menu_handle_ptr), Some(0));
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_HM_HELP_MANAGER_NOT_INITED)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_HM_HELP_MANAGER_NOT_INITED)
);
}
#[test]
fn get_menu_bar_returns_an_ordered_caller_owned_snapshot() {
let pef = synthetic_pef_with_import(b"GetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu_handles = [0x1111_0000, 0x2222_0000];
let current = ppc_alloc_menu_list_handle(
&menu_handles,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(current, 0);
ppc_set_current_menu_list(&mut loaded.memory, current);
let stack_pointer = loaded.cpu.gpr[1];
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let snapshot = loaded.cpu.gpr[3];
assert_ne!(snapshot, 0);
assert_ne!(snapshot, current);
assert_eq!(loaded.cpu.gpr[1], stack_pointer);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, snapshot),
Some(menu_handles.to_vec())
);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, current),
Some(menu_handles.to_vec())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn get_menu_bar_returns_a_non_nil_empty_snapshot_without_a_current_list() {
let pef = synthetic_pef_with_import(b"GetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let snapshot = loaded.cpu.gpr[3];
assert_ne!(snapshot, 0);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, snapshot),
Some(Vec::new())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn set_menu_bar_installs_a_copy_independent_of_the_source_handle() {
let pef = synthetic_pef_with_import(b"SetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu_handles = [0x1111_0000, 0x2222_0000];
let source = ppc_alloc_menu_list_handle(
&menu_handles,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(source, 0);
loaded.cpu.gpr[3] = source;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let installed = ppc_current_menu_list(&mut loaded.memory);
assert_ne!(installed, 0);
assert_ne!(installed, source);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, installed),
Some(menu_handles.to_vec())
);
loaded.memory.write_u32_be(source, 0).unwrap();
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, installed),
Some(menu_handles.to_vec())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn clear_menu_bar_empties_and_preserves_the_current_menu_list() {
let pef = synthetic_pef_with_import(b"ClearMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let current = ppc_alloc_menu_list_handle(
&[0x1111_0000, 0x2222_0000],
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(current, 0);
ppc_set_current_menu_list(&mut loaded.memory, current);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(ppc_current_menu_list(&mut loaded.memory), current);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, current),
Some(Vec::new())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn native_menu_bar_snapshot_clear_and_restore_round_trips_both_partitions() {
let pef = synthetic_pef_with_import(b"GetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let original = PpcMenuListDefinition {
last_right: 87,
mb_res_id: 0x108,
regular: vec![
PpcMenuListEntry {
handle: 0x1111_0000,
value: 11,
},
PpcMenuListEntry {
handle: 0x2222_0000,
value: 43,
},
],
menu_title_save: 0x3333_0000,
hierarchical: vec![PpcMenuListEntry {
handle: 0x4444_0000,
value: 0,
}],
};
let current = ppc_alloc_menu_list_definition_handle(
&original,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(current, 0);
ppc_set_current_menu_list(&mut loaded.memory, current);
loaded
.memory
.write_u32_be(crate::memory::globals::addr::MENU_LIST, current)
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let saved = loaded.cpu.gpr[3];
assert_ne!(saved, 0);
assert_ne!(saved, current);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, saved),
Some(original.clone())
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::ClearMenuBar;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(ppc_current_menu_list(&mut loaded.memory), current);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_LIST),
Some(current)
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(PpcMenuListDefinition {
mb_res_id: original.mb_res_id,
..PpcMenuListDefinition::default()
})
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, saved),
Some(original.clone()),
"ClearMenuBar must not mutate a caller-owned snapshot"
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetMenuBar;
loaded.cpu.gpr[3] = saved;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(ppc_current_menu_list(&mut loaded.memory), current);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(original.clone())
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, saved),
Some(original)
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
// MTE 1992 pp. 3-103--3-104: repeated InitMenus calls reuse the current
// MenuList allocation but reset it to the empty standard-menu definition.
#[test]
fn native_init_menus_publishes_and_reinitializes_a_stable_menu_list() {
let pef = synthetic_pef_with_import(b"InitMenus");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.toolbox_startup.host_menu_bar_hidden = true;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(loaded.toolbox_startup.menus_initialized);
let current = ppc_current_menu_list(&mut loaded.memory);
assert_ne!(current, 0);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_LIST),
Some(current)
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(PpcMenuListDefinition::default())
);
assert_eq!(
loaded
.handles()
.iter()
.find(|record| record.handle == current)
.map(|record| record.size),
Some(12)
);
let nonstandard = PpcMenuListDefinition {
last_right: 75,
mb_res_id: 0x108,
regular: vec![PpcMenuListEntry {
handle: 0x1111_0000,
value: 11,
}],
menu_title_save: 0x2222_0000,
hierarchical: vec![PpcMenuListEntry {
handle: 0x3333_0000,
value: 0,
}],
};
assert_eq!(
ppc_replace_menu_list_definition(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
current,
&nonstandard,
),
PPC_NO_ERR
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(ppc_current_menu_list(&mut loaded.memory), current);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_LIST),
Some(current)
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(PpcMenuListDefinition::default())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn native_newmenu_installs_one_callable_standard_mdef_handle() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let title_ptr = PPC_DATA_BASE + 0x6000;
loaded.memory.add_region(title_ptr, vec![0; 32]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
title_ptr,
b"File"
));
loaded.cpu.gpr[3] = 128;
loaded.cpu.gpr[4] = title_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewMenu);
let first_menu = loaded.cpu.gpr[3];
let first_menu_ptr = loaded.memory.read_u32_be(first_menu).unwrap();
let standard_mdef = loaded.memory.read_u32_be(first_menu_ptr + 6).unwrap();
assert_ne!(standard_mdef, 0);
assert_eq!(
ppc_menu_handle_bytes(
&mut loaded.memory,
&test_handle_records!(loaded),
standard_mdef
),
Some(STANDARD_MENU_DEFINITION_SHIM.to_vec())
);
loaded.cpu.gpr[3] = 129;
loaded.cpu.gpr[4] = title_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewMenu);
let second_menu_ptr = loaded.memory.read_u32_be(loaded.cpu.gpr[3]).unwrap();
assert_eq!(
loaded.memory.read_u32_be(second_menu_ptr + 6),
Some(standard_mdef),
"NewMenu must reuse the loaded standard MDEF resource Handle"
);
assert_eq!(
loaded
.vfs_resources
.iter()
.filter(|resource| {
resource.res_type == u32::from_be_bytes(*b"MDEF") && resource.res_id == 0
})
.count(),
1
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
}
#[test]
fn native_getmenu_loads_and_resolves_mdefs_when_resload_is_disabled() {
let pef = synthetic_pef_with_import(b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.policy.set_res_load(false);
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 128,
name: Vec::new(),
data: test_menu_resource(128, b"File"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 129,
name: Vec::new(),
data: test_menu_resource_with_mdef(129, 256, b"Custom"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: vec![0x4e, 0x75],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
let standard_menu = loaded.cpu.gpr[3];
let standard_menu_ptr = loaded.memory.read_u32_be(standard_menu).unwrap();
let standard_mdef = loaded.memory.read_u32_be(standard_menu_ptr + 6).unwrap();
assert_eq!(
ppc_menu_handle_bytes(
&mut loaded.memory,
&test_handle_records!(loaded),
standard_mdef
),
Some(STANDARD_MENU_DEFINITION_SHIM.to_vec())
);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
let custom_menu = loaded.cpu.gpr[3];
let custom_menu_ptr = loaded.memory.read_u32_be(custom_menu).unwrap();
let custom_mdef = loaded.memory.read_u32_be(custom_menu_ptr + 6).unwrap();
let custom_resource = loaded
.vfs_resources
.iter()
.find(|resource| {
resource.res_type == u32::from_be_bytes(*b"MDEF") && resource.res_id == 256
})
.unwrap();
assert_eq!(custom_mdef, custom_resource.handle);
assert_eq!(
ppc_menu_handle_bytes(
&mut loaded.memory,
&test_handle_records!(loaded),
custom_mdef
),
Some(vec![0x4e, 0x75])
);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
assert_eq!(loaded.cpu.gpr[3], custom_menu);
assert_eq!(
loaded.memory.read_u32_be(custom_menu_ptr + 6),
Some(custom_mdef),
"a repeated GetMenu must preserve both resource Handle identities"
);
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
}
#[test]
fn native_getmenu_sizes_a_new_custom_menu_through_its_mdef() {
let pef = synthetic_pef_with_import(b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
PPC_CODE_BASE + 0x4000,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
d_form_u(32, 6, 4, 0),
d_form_u(14, 7, 0, 123),
d_form_u(44, 7, 6, 2),
d_form_u(14, 7, 0, 45),
d_form_u(44, 7, 6, 4),
BLR,
],
);
let descriptor_bytes =
ppc_memory_read_bytes(&mut loaded.memory, descriptor, 0x100).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 129,
name: Vec::new(),
data: test_menu_resource_with_mdef(129, 256, b"Custom"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: descriptor_bytes,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
let menu_handle = loaded.cpu.gpr[3];
let menu = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
assert!(loaded
.process_memory_manager
.0
.borrow()
.native_ptr_records()
.iter()
.all(|record| record.ptr != loaded.cpu.gpr[5]));
}
#[test]
fn native_getmenu_sizes_through_a_classic_resource_mdef() {
let pef = synthetic_pef_with_import(b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
// MOVEA.L 16(SP),A0; MOVEA.L (A0),A0;
// MOVE.W #123,2(A0); MOVE.W #45,4(A0); RTD #18.
let mdef = vec![
0x20, 0x6f, 0x00, 0x10, 0x20, 0x50, 0x31, 0x7c, 0x00, 0x7b, 0x00, 0x02, 0x31, 0x7c,
0x00, 0x2d, 0x00, 0x04, 0x4e, 0x74, 0x00, 0x12,
];
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 129,
name: Vec::new(),
data: test_menu_resource_with_mdef(129, 256, b"Classic"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: mdef,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
let menu = loaded.memory.read_u32_be(loaded.cpu.gpr[3]).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
assert!(loaded.guest_calls().is_empty());
assert_eq!(loaded.toolbox_startup.mixed_mode_m68k.storage_pair(), (0, 0));
}
#[test]
fn mixed_mode_storage_does_not_publish_a_partial_pair_on_allocation_failure() {
let mut memory = PpcSectionMem::new();
let storage = SharedProcessMixedModeM68kState::default();
let initial_heap_cursor = 0x1000;
let mut heap_cursor = initial_heap_cursor;
let gateway_size = ppc_allocation_size(PPC_MIXED_MODE_M68K_GATEWAY_SIZE).unwrap();
let heap_limit = initial_heap_cursor + gateway_size + 16;
assert_eq!(
ppc_mixed_mode_m68k_storage(
None,
&mut memory,
&mut heap_cursor,
heap_limit,
&storage,
),
None
);
assert_eq!(storage.storage_pair(), (0, 0));
assert_eq!(heap_cursor, initial_heap_cursor);
}
#[test]
fn attached_mixed_mode_adapters_reuse_storage_without_allocating() {
let pef = synthetic_pef_with_import(b"TestImport");
let mut first = load_pef_application(&pef).unwrap();
let mut second = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
first.attach_unconverted_process_services(&mut context);
second.attach_unconverted_process_services(&mut context);
assert!(first
.toolbox_startup
.mixed_mode_m68k
.ptr_eq(&second.toolbox_startup.mixed_mode_m68k));
let first_manager_handle = first.process_memory_manager.0.clone();
let mut first_manager = first_manager_handle.borrow_mut();
let initial_heap = first_manager.native_heap_state().unwrap();
let mut heap_cursor = initial_heap.heap_cursor;
let pair = ppc_mixed_mode_m68k_storage(
Some(first_manager.native_mut()),
&mut first.memory,
&mut heap_cursor,
initial_heap.heap_limit,
&first.toolbox_startup.mixed_mode_m68k,
)
.unwrap();
drop(first_manager);
assert_eq!(second.toolbox_startup.mixed_mode_m68k.storage_pair(), pair);
let second_manager_handle = second.process_memory_manager.0.clone();
let mut second_manager = second_manager_handle.borrow_mut();
let second_heap_cursor_before = second_manager.native_heap_state().unwrap().heap_cursor;
let mut impossible_heap_cursor = 0;
assert_eq!(
ppc_mixed_mode_m68k_storage(
Some(second_manager.native_mut()),
&mut second.memory,
&mut impossible_heap_cursor,
0,
&second.toolbox_startup.mixed_mode_m68k,
),
Some(pair)
);
assert_eq!(impossible_heap_cursor, 0);
assert_eq!(
second_manager.native_heap_state().unwrap().heap_cursor,
second_heap_cursor_before
);
}
#[test]
fn mixed_mode_storage_rolls_back_native_allocator_on_failure() {
let heap_base = 0x1000;
let gateway_size = ppc_allocation_size(PPC_MIXED_MODE_M68K_GATEWAY_SIZE).unwrap();
let heap_limit = heap_base + gateway_size + 16;
let mut memory_manager = ProcessNativeMemoryManager::default();
memory_manager.publish_native_allocator(
ProcessNativeHeapState {
heap_base,
heap_cursor: heap_base,
heap_limit,
last_mem_error: PPC_NO_ERR,
heap_maximized: false,
master_pointer_blocks_requested: 0,
},
&[],
&[],
&[],
);
let allocator_before = memory_manager.native_allocator_snapshot();
let mut memory = PpcSectionMem::new();
let mut heap_cursor = heap_base;
let storage = SharedProcessMixedModeM68kState::default();
assert_eq!(
ppc_mixed_mode_m68k_storage(
Some(&mut memory_manager),
&mut memory,
&mut heap_cursor,
heap_limit,
&storage,
),
None
);
assert_eq!(storage.storage_pair(), (0, 0));
assert_eq!(heap_cursor, heap_base);
assert_eq!(memory_manager.native_allocator_snapshot(), allocator_before);
assert_eq!(
memory_manager.native_heap_state().unwrap().heap_cursor,
heap_base
);
}
#[test]
fn native_getmenu_returns_nil_when_the_compiled_mdef_is_missing() {
let pef = synthetic_pef_with_import(b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 130,
name: Vec::new(),
data: test_menu_resource_with_mdef(130, 300, b"Missing"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 130;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.test_resource_error(), PPC_RES_NOT_FOUND_ERR);
}
#[test]
fn native_init_getmenu_and_clear_share_live_menu_color_state() {
let pef = synthetic_pef_with_import(b"InitMenus");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.toolbox_startup.host_menu_bar_hidden = true;
let ref_num = *loaded.process_file_system.current_resource_file;
let menu_bar = test_menu_color_entry(0, 0, 0x11);
let old_title = test_menu_color_entry(128, 0, 0x22);
let new_title = test_menu_color_entry(128, 0, 0x33);
let item = test_menu_color_entry(128, 2, 0x44);
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"mctb"),
res_id: 0,
name: Vec::new(),
data: test_menu_color_resource(&[menu_bar, old_title]),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 128,
name: Vec::new(),
data: test_menu_resource(128, b"File"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"mctb"),
res_id: 128,
name: Vec::new(),
data: test_menu_color_resource(&[new_title, item]),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
run_test_import(&mut loaded, PpcImportDispatcherTarget::InitMenus);
let color_handle = loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_C_INFO)
.unwrap();
assert_ne!(color_handle, 0);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
[menu_bar.as_slice(), old_title.as_slice()].concat()
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
assert_ne!(loaded.cpu.gpr[3], 0);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
[menu_bar.as_slice(), new_title.as_slice(), item.as_slice()].concat()
);
run_test_import(&mut loaded, PpcImportDispatcherTarget::ClearMenuBar);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_C_INFO),
Some(color_handle),
"ClearMenuBar must preserve the manager-owned MenuCInfo handle"
);
assert!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded))
.is_empty()
);
}
#[test]
fn native_getnewmbar_rebuilds_menu_color_state_from_loaded_menus() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let ref_num = *loaded.process_file_system.current_resource_file;
let stale = test_menu_color_entry(999, 1, 0x11);
let file = test_menu_color_entry(601, 0, 0x22);
let edit = test_menu_color_entry(602, 2, 0x33);
let color_handle = ppc_ensure_menu_color_table_handle(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(color_handle, 0);
assert_eq!(
ppc_replace_menu_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
color_handle,
&stale,
),
PPC_NO_ERR
);
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 900,
name: Vec::new(),
data: vec![0, 2, 2, 89, 2, 90],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 601,
name: Vec::new(),
data: test_menu_resource(601, b"File"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"mctb"),
res_id: 601,
name: Vec::new(),
data: test_menu_color_resource(&[file]),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 602,
name: Vec::new(),
data: test_menu_resource(602, b"Edit"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"mctb"),
res_id: 602,
name: Vec::new(),
data: test_menu_color_resource(&[edit]),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 900;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetNewMBar);
assert_ne!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_C_INFO),
Some(color_handle)
);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
[file.as_slice(), edit.as_slice()].concat()
);
let standard_mdef = loaded
.vfs_resources
.iter()
.find(|resource| {
resource.res_type == u32::from_be_bytes(*b"MDEF") && resource.res_id == 0
})
.map(|resource| resource.handle)
.unwrap();
assert_ne!(standard_mdef, 0);
for menu_id in [601, 602] {
let menu_handle = loaded
.vfs_resources
.iter()
.find(|resource| {
resource.res_type == u32::from_be_bytes(*b"MENU") && resource.res_id == menu_id
})
.map(|resource| resource.handle)
.unwrap();
let menu_ptr = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(
loaded.memory.read_u32_be(menu_ptr + 6),
Some(standard_mdef),
"GetNewMBar must route every MENU through GetMenu MDEF resolution"
);
}
}
#[test]
fn native_getnewmbar_sizes_each_custom_menu_before_returning_the_list() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
PPC_CODE_BASE + 0x4000,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
d_form_u(32, 6, 4, 0),
d_form_u(14, 7, 0, 123),
d_form_u(44, 7, 6, 2),
d_form_u(14, 7, 0, 45),
d_form_u(44, 7, 6, 4),
BLR,
],
);
let descriptor_bytes =
ppc_memory_read_bytes(&mut loaded.memory, descriptor, 0x100).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 900,
name: Vec::new(),
data: vec![0, 2, 2, 89, 2, 90],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 601,
name: Vec::new(),
data: test_menu_resource_with_mdef(601, 256, b"First"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 602,
name: Vec::new(),
data: test_menu_resource_with_mdef(602, 256, b"Second"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: descriptor_bytes,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 900;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetNewMBar;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let list_handle = loaded.cpu.gpr[3];
let menu_handles = ppc_menu_list_definition(&mut loaded.memory, list_handle)
.unwrap()
.handles()
.collect::<Vec<_>>();
assert_eq!(menu_handles.len(), 2);
for menu_handle in menu_handles {
let menu = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
}
assert!(!loaded.guest_calls().has_menu_bar_builds());
}
#[test]
fn native_getnewmbar_resumes_internally_after_classic_mdefs() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor_bytes = vec![
0x20, 0x6f, 0x00, 0x10, 0x20, 0x50, 0x31, 0x7c, 0x00, 0x7b, 0x00, 0x02, 0x31, 0x7c,
0x00, 0x2d, 0x00, 0x04, 0x4e, 0x74, 0x00, 0x12,
];
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 900,
name: Vec::new(),
data: vec![0, 2, 2, 89, 2, 90],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 601,
name: Vec::new(),
data: test_menu_resource_with_mdef(601, 256, b"First"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 602,
name: Vec::new(),
data: test_menu_resource_with_mdef(602, 256, b"Second"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: descriptor_bytes,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 900;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetNewMBar);
assert_eq!(loaded.cpu.pc, PPC_HALT_PC);
assert!(loaded.guest_calls().is_empty());
let list_handle = loaded.cpu.gpr[3];
let menu_handles = ppc_menu_list_definition(&mut loaded.memory, list_handle)
.unwrap()
.handles()
.collect::<Vec<_>>();
assert_eq!(menu_handles.len(), 2);
for menu_handle in menu_handles {
let menu = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
}
assert!(!loaded.guest_calls().has_menu_bar_builds());
}
#[test]
fn nested_getnewmbar_keeps_each_build_and_its_return_separate() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let marker = PPC_DATA_BASE + 0x7800;
loaded.memory.add_region(marker, vec![0; 4]);
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
PPC_CODE_BASE + 0x4000,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
0x9421_ffa0, // stwu r1,-96(r1)
0x7c08_02a6, // mflr r0
0x9001_0064, // stw r0,100(r1)
0x9081_0038, // retain the outer menu handle
0x3860_0385, // li r3,901: nested empty MBAR resource
0x3d80_0000 | (PPC_IMPORT_TRAP_BASE >> 16),
0x618c_0000 | (PPC_IMPORT_TRAP_BASE & 0xffff),
0x7d89_03a6, // mtctr r12
0x4e80_0421, // bctrl: nested GetNewMBar
0x3d40_0000 | (marker >> 16),
0x614a_0000 | (marker & 0xffff),
0x906a_0000, // retain the nested menu-list handle
0x8081_0038,
d_form_u(32, 6, 4, 0),
d_form_u(14, 7, 0, 123),
d_form_u(44, 7, 6, 2),
d_form_u(14, 7, 0, 45),
d_form_u(44, 7, 6, 4),
0x8001_0064,
0x7c08_03a6,
0x3821_0060,
BLR,
],
);
let descriptor_bytes = ppc_memory_read_bytes(&mut loaded.memory, descriptor, 0x100).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 901,
name: Vec::new(),
data: vec![0, 0],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 900,
name: Vec::new(),
data: vec![0, 2, 2, 89, 2, 90],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 601,
name: Vec::new(),
data: test_menu_resource_with_mdef(601, 256, b"First"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 602,
name: Vec::new(),
data: test_menu_resource_with_mdef(602, 256, b"Second"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: descriptor_bytes,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 900;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetNewMBar;
let probe = loaded.run_with_hle_imports(256);
assert_eq!(probe.handled_import_count, 3);
assert_eq!(probe.unsupported_import_index, None);
let inner = loaded.memory.read_u32_be(marker).unwrap();
assert_ne!(
inner, 0,
"nested GetNewMBar must produce its own menu-list handle"
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, inner)
.unwrap()
.handles()
.count(),
0
);
assert!(loaded.guest_calls().is_empty());
assert_eq!(loaded.cpu.pc, PPC_HALT_PC);
let list_handle = loaded.cpu.gpr[3];
let menu_handles = ppc_menu_list_definition(&mut loaded.memory, list_handle)
.unwrap()
.handles()
.collect::<Vec<_>>();
assert_eq!(menu_handles.len(), 2);
for menu_handle in menu_handles {
let menu = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
}
assert!(!loaded.guest_calls().has_menu_bar_builds());
}
#[test]
fn native_menu_deletion_filters_the_shared_menu_color_table() {
let pef = synthetic_pef_with_import(b"DeleteMenuItem");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu_handle = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x6000,
128,
b"File",
b"One;Two",
);
let title = test_menu_color_entry(128, 0, 0x11);
let item_one = test_menu_color_entry(128, 1, 0x22);
let item_two = test_menu_color_entry(128, 2, 0x33);
let unrelated = test_menu_color_entry(129, 0, 0x44);
let color_handle = ppc_ensure_menu_color_table_handle(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_eq!(
ppc_replace_menu_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
color_handle,
&[
title.as_slice(),
item_one.as_slice(),
item_two.as_slice(),
unrelated.as_slice(),
]
.concat(),
),
PPC_NO_ERR
);
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 2;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenuItem);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
[title.as_slice(), item_one.as_slice(), unrelated.as_slice()].concat()
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenu);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
unrelated
);
}
#[test]
fn restore_entries_updates_selected_device_colors_without_reseeding() {
let pef = synthetic_pef_with_import(b"RestoreEntries");
let mut loaded = load_pef_application(&pef).unwrap();
let mut source_bytes = vec![0; 24];
source_bytes[0..4].copy_from_slice(&0x1234_5678u32.to_be_bytes());
source_bytes[6..8].copy_from_slice(&1u16.to_be_bytes());
source_bytes[8..10].copy_from_slice(&9u16.to_be_bytes());
source_bytes[10..12].copy_from_slice(&0x1111u16.to_be_bytes());
source_bytes[12..14].copy_from_slice(&0x2222u16.to_be_bytes());
source_bytes[14..16].copy_from_slice(&0x3333u16.to_be_bytes());
source_bytes[16..18].copy_from_slice(&10u16.to_be_bytes());
source_bytes[18..20].copy_from_slice(&0x4444u16.to_be_bytes());
source_bytes[20..22].copy_from_slice(&0x5555u16.to_be_bytes());
source_bytes[22..24].copy_from_slice(&0x6666u16.to_be_bytes());
let source = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&source_bytes,
);
let selection = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(selection, vec![0; 6]);
loaded.memory.write_u16_be(selection, 1).unwrap();
loaded.memory.write_u16_be(selection + 2, 42).unwrap();
loaded.memory.write_u16_be(selection + 4, 300).unwrap();
let destination = loaded.memory.read_u32_be(PPC_MAIN_CTABLE_HANDLE).unwrap();
let original_seed = loaded.memory.read_u32_be(destination).unwrap();
let original_sp = loaded.cpu.gpr[1];
loaded.cpu.gpr[3] = source;
loaded.cpu.gpr[4] = PPC_MAIN_CTABLE_HANDLE;
loaded.cpu.gpr[5] = selection;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(loaded.screen_clut[42], [0x1111, 0x2222, 0x3333]);
assert_eq!(loaded.memory.read_u16_be(destination + 8 + 42 * 8), Some(9));
assert_eq!(
loaded.memory.read_u16_be(destination + 10 + 42 * 8),
Some(0x1111)
);
assert_eq!(loaded.memory.read_u32_be(destination), Some(original_seed));
assert_eq!(loaded.memory.read_u16_be(selection + 4), Some(u16::MAX));
}
#[test]
fn direct_video_set_entries_updates_screen_clut() {
let parameter_block = 0x2000;
let request = 0x2100;
let table = 0x2200;
let mut memory = PpcSectionMem::new();
memory.add_region(parameter_block, vec![0; 64]);
memory.add_region(request, vec![0; 8]);
memory.add_region(table, vec![0; 8]);
memory.write_u16_be(parameter_block + 26, 8).unwrap();
memory.write_u32_be(parameter_block + 28, request).unwrap();
memory.write_u32_be(request, table).unwrap();
memory.write_u16_be(request + 4, 7).unwrap();
memory.write_u16_be(request + 6, 0).unwrap();
memory.write_u16_be(table, 99).unwrap();
memory.write_u16_be(table + 2, 0x1111).unwrap();
memory.write_u16_be(table + 4, 0x2222).unwrap();
memory.write_u16_be(table + 6, 0x3333).unwrap();
let mut screen_clut = [[0; 3]; 256];
let display_gamma = SharedProcessDisplayGamma::default();
let mut startup = PpcToolboxStartupState::default();
let mut cpu = PpcCpu::new();
cpu.gpr[3] = parameter_block;
assert_eq!(
ppc_pb_control(
&cpu,
&mut memory,
0,
&mut screen_clut,
&display_gamma,
&mut startup,
),
PPC_NO_ERR
);
assert_eq!(screen_clut[7], [0x1111, 0x2222, 0x3333]);
assert_eq!(display_gamma.table(), crate::display::linear_display_gamma());
assert_eq!(memory.read_u16_be(parameter_block + 16), Some(0));
let installed_gamma = [[42; 256]; 3];
display_gamma.install(installed_gamma);
assert_eq!(
ppc_pb_control(
&cpu,
&mut memory,
0,
&mut screen_clut,
&display_gamma,
&mut startup,
),
PPC_NO_ERR
);
assert_eq!(display_gamma.table(), installed_gamma);
}
#[test]
fn video_status_returns_device_owned_linear_gamma_table() {
let pef = synthetic_pef_with_import(b"PBStatusSync");
let mut loaded = load_pef_application(&pef).unwrap();
let parameter_block = PPC_DATA_BASE + 0x1000;
let vd_gamma = parameter_block + 64;
loaded.memory.add_region(parameter_block, vec![0; 128]);
loaded.memory.write_u16_be(parameter_block + 24, 0).unwrap();
loaded.memory.write_u16_be(parameter_block + 26, 8).unwrap();
loaded
.memory
.write_u32_be(parameter_block + 28, vd_gamma)
.unwrap();
loaded.cpu.gpr[3] = parameter_block;
assert_eq!(ppc_pb_status(&loaded.cpu, &mut loaded.memory), PPC_NO_ERR);
assert_eq!(loaded.memory.read_u16_be(parameter_block + 16), Some(0));
assert_eq!(
loaded.memory.read_u32_be(vd_gamma),
Some(PPC_MAIN_GAMMA_TABLE)
);
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_GAMMA_TABLE), Some(0));
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_GAMMA_TABLE + 6), Some(1));
assert_eq!(
loaded.memory.read_u16_be(PPC_MAIN_GAMMA_TABLE + 8),
Some(256)
);
assert_eq!(
loaded.memory.read_u16_be(PPC_MAIN_GAMMA_TABLE + 10),
Some(8)
);
for value in 0..256u32 {
assert_eq!(
loaded.memory.read_u8(PPC_MAIN_GAMMA_TABLE + 12 + value),
Some(value as u8)
);
}
}
#[test]
fn synthetic_main_color_table_does_not_overlap_gamma_storage() {
let color_table_end = PPC_MAIN_CTABLE + PPC_MAIN_CTABLE_SIZE;
let gamma_table_end = PPC_MAIN_GAMMA_TABLE + PPC_MAIN_GAMMA_TABLE_SIZE;
assert!(
color_table_end <= PPC_MAIN_GAMMA_TABLE || gamma_table_end <= PPC_MAIN_CTABLE,
"the 256-entry ColorTable and device GammaTbl must occupy disjoint storage"
);
}
#[test]
fn video_control_installs_three_channel_gamma_table() {
let parameter_block = 0x2000;
let vd_gamma = 0x2100;
let table = 0x2200;
let mut memory = PpcSectionMem::new();
memory.add_region(parameter_block, vec![0; 64]);
memory.add_region(vd_gamma, vec![0; 4]);
memory.add_region(table, vec![0; 24]);
memory.write_u16_be(parameter_block + 26, 4).unwrap();
memory.write_u32_be(parameter_block + 28, vd_gamma).unwrap();
memory.write_u32_be(vd_gamma, table).unwrap();
memory.write_u16_be(table, 0).unwrap();
memory.write_u16_be(table + 2, 0).unwrap();
memory.write_u16_be(table + 4, 0).unwrap();
memory.write_u16_be(table + 6, 3).unwrap();
memory.write_u16_be(table + 8, 4).unwrap();
memory.write_u16_be(table + 10, 2).unwrap();
memory
.write_bytes(table + 12, &[0, 10, 20, 30, 1, 11, 21, 31, 2, 12, 22, 32])
.unwrap();
let mut screen_clut = [[0; 3]; 256];
let display_gamma = SharedProcessDisplayGamma::default();
let mut startup = PpcToolboxStartupState::default();
let mut cpu = PpcCpu::new();
cpu.gpr[3] = parameter_block;
assert_eq!(
ppc_pb_control(
&cpu,
&mut memory,
0,
&mut screen_clut,
&display_gamma,
&mut startup,
),
PPC_NO_ERR
);
let installed = display_gamma.table();
assert_eq!(installed[0][0], 0);
assert_eq!(installed[0][64], 10);
assert_eq!(installed[0][255], 30);
assert_eq!(installed[1][64], 11);
assert_eq!(installed[2][255], 32);
assert!(display_gamma.is_explicit());
}
#[test]
fn direct_video_set_entries_does_not_replace_quickdraws_logical_color_table() {
let pef = synthetic_pef_with_import(b"PBControlSync");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let parameter_block = scratch;
let request = scratch + 0x100;
let table = scratch + 0x200;
loaded.memory.add_region(scratch, vec![0; 0x300]);
loaded.memory.write_u16_be(parameter_block + 26, 8).unwrap();
loaded
.memory
.write_u32_be(parameter_block + 28, request)
.unwrap();
loaded.memory.write_u32_be(request, table).unwrap();
loaded.memory.write_u16_be(request + 4, 7).unwrap();
loaded.memory.write_u16_be(request + 6, 0).unwrap();
loaded.memory.write_u16_be(table, 7).unwrap();
loaded.memory.write_u16_be(table + 2, 0x1111).unwrap();
loaded.memory.write_u16_be(table + 4, 0x2222).unwrap();
loaded.memory.write_u16_be(table + 6, 0x3333).unwrap();
let ctable_handle =
ppc_gdevice_ctable_handle(&mut loaded.memory, *loaded.current_gdevice).unwrap();
let logical_before = ppc_read_ctable_clut(
&mut loaded.memory,
ctable_handle,
&loaded.color_manager_clut,
)
.unwrap();
let screen_clut = loaded.screen_clut;
let display_gamma = loaded.display_gamma.shared_handle();
let mut startup = loaded.toolbox_startup;
let mut cpu = PpcCpu::new();
cpu.gpr[3] = parameter_block;
assert_eq!(
screen_clut.with_mut(|screen_clut| ppc_pb_control(
&cpu,
&mut loaded.memory,
*loaded.current_gdevice,
screen_clut,
&display_gamma,
&mut startup,
)),
PPC_NO_ERR
);
assert_eq!(screen_clut[7], [0x1111, 0x2222, 0x3333]);
assert_eq!(
ppc_read_ctable_clut(
&mut loaded.memory,
ctable_handle,
&loaded.color_manager_clut,
)
.unwrap(),
logical_before
);
}
#[test]
fn ppc_rgb2hsl_converts_primary_and_gray_colors() {
let rgb = 0x2000;
let hsl = 0x2100;
let mut memory = PpcSectionMem::new();
memory.add_region(rgb, vec![0; 0x200]);
memory.write_u16_be(rgb, 0xffff).unwrap();
memory.write_u16_be(rgb + 2, 0).unwrap();
memory.write_u16_be(rgb + 4, 0).unwrap();
assert!(ppc_rgb2hsl(&mut memory, rgb, hsl));
assert_eq!(memory.read_u16_be(hsl), Some(0));
assert_eq!(memory.read_u16_be(hsl + 2), Some(0xffff));
assert_eq!(memory.read_u16_be(hsl + 4), Some(0x8000));
memory.write_u16_be(rgb, 0x2468).unwrap();
memory.write_u16_be(rgb + 2, 0x2468).unwrap();
memory.write_u16_be(rgb + 4, 0x2468).unwrap();
assert!(ppc_rgb2hsl(&mut memory, rgb, hsl));
assert_eq!(memory.read_u16_be(hsl), Some(0));
assert_eq!(memory.read_u16_be(hsl + 2), Some(0));
assert_eq!(memory.read_u16_be(hsl + 4), Some(0x2468));
}
#[test]
fn ppc_rgb2hsv_converts_primary_and_gray_colors() {
let rgb = 0x2000;
let hsv = 0x2100;
let mut memory = PpcSectionMem::new();
memory.add_region(rgb, vec![0; 0x200]);
memory.write_u16_be(rgb, 0).unwrap();
memory.write_u16_be(rgb + 2, 0xffff).unwrap();
memory.write_u16_be(rgb + 4, 0).unwrap();
assert!(ppc_rgb2hsv(&mut memory, rgb, hsv));
assert_eq!(memory.read_u16_be(hsv), Some(0x5555));
assert_eq!(memory.read_u16_be(hsv + 2), Some(0xffff));
assert_eq!(memory.read_u16_be(hsv + 4), Some(0xffff));
memory.write_u16_be(rgb, 0x2468).unwrap();
memory.write_u16_be(rgb + 2, 0x2468).unwrap();
memory.write_u16_be(rgb + 4, 0x2468).unwrap();
assert!(ppc_rgb2hsv(&mut memory, rgb, hsv));
assert_eq!(memory.read_u16_be(hsv), Some(0));
assert_eq!(memory.read_u16_be(hsv + 2), Some(0));
assert_eq!(memory.read_u16_be(hsv + 4), Some(0x2468));
memory.write_u16_be(hsv, 0xaaaa).unwrap();
memory.write_u16_be(hsv + 2, 0xffff).unwrap();
memory.write_u16_be(hsv + 4, 0xffff).unwrap();
assert!(ppc_hsv2rgb(&mut memory, hsv, rgb));
assert_eq!(memory.read_u16_be(rgb), Some(0));
assert_eq!(memory.read_u16_be(rgb + 2), Some(0));
assert_eq!(memory.read_u16_be(rgb + 4), Some(0xffff));
}
#[test]
fn ppc_fix_ratio_truncates_signed_results_and_saturates_zero_divisors() {
assert_eq!(ppc_fix_ratio(3, 2), 0x0001_8000);
assert_eq!(ppc_fix_ratio(-1, 3), -0x0000_5555);
assert_eq!(ppc_fix_ratio(1, 0), i32::MAX);
assert_eq!(ppc_fix_ratio(-1, 0), i32::MIN + 1);
}
#[test]
fn ppc_fixed_point_helpers_round_multiply_and_saturate_conversion() {
assert_eq!(ppc_fix_mul(0x0001_8000, 0x0001_4000), 0x0001_e000);
assert_eq!(ppc_fix_mul(-0x0001_8000, 0x0001_4000), -0x0001_e000);
assert_eq!(ppc_long_to_fix(72), 0x0048_0000);
assert_eq!(ppc_long_to_fix(0x8000), i32::MAX);
assert_eq!(ppc_long_to_fix(-0x8001), i32::MIN);
}
#[test]
fn ppc_fix_round_rounds_to_nearest_halves_away_from_zero() {
assert_eq!(ppc_fix_round(0x0001_4000), 1);
assert_eq!(ppc_fix_round(0x0001_8000), 2);
assert_eq!(ppc_fix_round(0x0001_c000), 2);
assert_eq!(ppc_fix_round(-0x0001_4000), -1);
assert_eq!(ppc_fix_round(-0x0001_8000), -2);
assert_eq!(ppc_fix_round(i32::MIN), i16::MIN);
assert_eq!(ppc_fix_round(0), 0);
}
#[test]
fn ppc_fix_and_frac_conversions() {
assert_eq!(ppc_fix_to_frac(0x0001_0000), 0x4000_0000);
assert_eq!(ppc_fix_to_frac(-0x0001_0000), -0x4000_0000);
assert_eq!(ppc_fix_to_frac(0x0002_0000), i32::MAX);
assert_eq!(ppc_fix_to_frac(-0x0002_0001), i32::MIN);
assert_eq!(ppc_frac_to_fix(0x4000_0000), 0x0001_0000);
assert_eq!(ppc_frac_to_fix(0x7000_0000), 0x0001_c000);
assert_eq!(ppc_frac_to_fix(-0x4000_0000), -0x0001_0000);
assert_eq!(ppc_frac_to_fix(0x2000_0000), 0x0000_8000);
assert_eq!(ppc_f64_to_frac(1.0), 0x4000_0000);
assert_eq!(ppc_f64_to_frac(-1.0), (-0x4000_0000i32) as u32);
assert_eq!(ppc_f64_to_frac(0.5), 0x2000_0000);
assert_eq!(ppc_f64_to_frac(3.0), 0x7fff_ffff);
}
#[test]
fn ppc_frac_arithmetic_and_trig() {
assert_eq!(ppc_frac_mul(0x2000_0000, 0x2000_0000), 0x1000_0000);
assert_eq!(ppc_frac_mul(-0x2000_0000, 0x2000_0000), -0x1000_0000);
assert_eq!(
ppc_frac_mul(0xa000_0000u32 as i32, 0x5333_3333),
0x8333_3333u32 as i32
);
assert_eq!(ppc_frac_div(0x1000_0000, 0x2000_0000), 0x2000_0000);
assert_eq!(ppc_frac_div(0x7ccc_cccd, 0x5333_3333), 0x6000_0000);
assert_eq!(
ppc_frac_div(0x8333_3333u32 as i32, 0x5333_3333),
0xa000_0000u32 as i32
);
assert_eq!(ppc_frac_div(0x4000_0000, 0x1000_0000), i32::MAX);
assert_eq!(ppc_frac_div(0x1000_0000, 0), i32::MAX);
assert_eq!(ppc_frac_div(-0x1000_0000, 0), i32::MIN);
assert_eq!(ppc_frac_sqrt(0x4000_0000), 0x4000_0000);
assert_eq!(ppc_frac_sqrt(0x1000_0000), 0x2000_0000);
assert_eq!(ppc_frac_sqrt(0x7d70_a3d7), 0x5999_999a);
assert_eq!(ppc_frac_sqrt(0), 0);
assert_eq!(ppc_frac_sin(0), 0);
assert_eq!(ppc_frac_cos(0), 0x4000_0000);
let pi_over_2_fixed = 102_944;
let sin_pi_2 = ppc_frac_sin(pi_over_2_fixed);
assert_eq!(sin_pi_2, 0x4000_0000);
let cos_pi_2 = ppc_frac_cos(pi_over_2_fixed);
assert_eq!(cos_pi_2, 0);
assert_eq!(ppc_frac_sin(205_888), 0);
assert_eq!(ppc_frac_cos(205_888), -0x4000_0000);
assert_eq!(ppc_fix_atan2(1, 0), 0);
assert_eq!(ppc_fix_atan2(0, 1), 102_944);
assert_eq!(ppc_fix_atan2(-1, -1), -154_416);
}
#[test]
fn ppc_fixmath_imports_execute_through_synthetic_pefs() {
// Universal Interfaces 3.4 FixMath.h declares these as InterfaceLib
// exports; examples and boundaries are from Inside Macintosh IV-65
// and Operating System Utilities (1994), pp. 3-40 through 3-46.
let cases: [(
&str,
PpcImportDispatcherTarget,
u32,
u32,
Option<f64>,
Option<u32>,
Option<f64>,
); 11] = [
(
"FixRound",
PpcImportDispatcherTarget::FixRound,
i32::MIN as u32,
0,
None,
Some(0xffff_8000),
None,
),
(
"Fix2Frac",
PpcImportDispatcherTarget::Fix2Frac,
0x0001_c000,
0,
None,
Some(0x7000_0000),
None,
),
(
"Frac2Fix",
PpcImportDispatcherTarget::Frac2Fix,
0x9000_0000,
0,
None,
Some(0xfffe_4000),
None,
),
(
"Frac2X",
PpcImportDispatcherTarget::Frac2X,
0x7000_0000,
0,
None,
None,
Some(1.75),
),
(
"X2Frac",
PpcImportDispatcherTarget::X2Frac,
0,
0,
Some(-3.0),
Some(0x8000_0000),
None,
),
(
"FracSin",
PpcImportDispatcherTarget::FracSin,
205_888,
0,
None,
Some(0),
None,
),
(
"FracCos",
PpcImportDispatcherTarget::FracCos,
205_888,
0,
None,
Some(0xc000_0000),
None,
),
(
"FracSqrt",
PpcImportDispatcherTarget::FracSqrt,
0xc000_0000,
0,
None,
Some(0x6ed9_eba1),
None,
),
(
"FracMul",
PpcImportDispatcherTarget::FracMul,
0x6000_0000,
0x5333_3333,
None,
Some(0x7ccc_cccd),
None,
),
(
"FracDiv",
PpcImportDispatcherTarget::FracDiv,
0x8333_3333,
0,
None,
Some(0x8000_0000),
None,
),
(
"FixATan2",
PpcImportDispatcherTarget::FixATan2,
1,
1,
None,
Some(0x0000_c910),
None,
),
];
for (name, target, r3, r4, f1, expected_r3, expected_f1) in cases {
let mut loaded = load_pef_application(&synthetic_pef_with_import(name.as_bytes()))
.expect("synthetic FixMath PEF should load");
assert_eq!(loaded.imports[0].dispatcher_target, target, "{name}");
loaded.cpu.gpr[3] = r3;
loaded.cpu.gpr[4] = r4;
loaded.cpu.fpr[1] = f1.unwrap_or_default().to_bits();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let result = loaded.run_with_hle_imports(64);
assert_eq!(result.handled_import_count, 1, "{name}");
if let Some(expected) = expected_r3 {
assert_eq!(loaded.cpu.gpr[3], expected, "{name}");
}
if let Some(expected) = expected_f1 {
assert_eq!(f64::from_bits(loaded.cpu.fpr[1]), expected, "{name}");
}
}
}
#[test]
fn ppc_wide_fixmath_helpers_mutate_records_and_apply_documented_results() {
// QuickDraw GX Environment and Utilities (1994), pp. 8-49--8-54.
const TARGET: u32 = 0x2000;
const SOURCE: u32 = 0x2008;
const REMAINDER: u32 = 0x2010;
let mut memory = PpcSectionMem::new();
memory.add_region(TARGET, vec![0; 0x100]);
ppc_write_wide(&mut memory, TARGET, 0x0000_0001_ffff_ffff).unwrap();
ppc_write_wide(&mut memory, SOURCE, 2).unwrap();
assert_eq!(ppc_wide_add(&mut memory, TARGET, SOURCE), TARGET);
assert_eq!(
ppc_read_wide(&mut memory, TARGET),
Some(0x0000_0002_0000_0001)
);
assert_eq!(ppc_wide_subtract(&mut memory, TARGET, SOURCE), TARGET);
assert_eq!(
ppc_read_wide(&mut memory, TARGET),
Some(0x0000_0001_ffff_ffff)
);
assert_eq!(ppc_wide_negate(&mut memory, TARGET), TARGET);
assert_eq!(
ppc_read_wide(&mut memory, TARGET),
Some(-0x0000_0001_ffff_ffff)
);
ppc_write_wide(&mut memory, TARGET, 7).unwrap();
assert_eq!(ppc_wide_shift(&mut memory, TARGET, 1), TARGET);
assert_eq!(ppc_read_wide(&mut memory, TARGET), Some(4));
ppc_write_wide(&mut memory, TARGET, -7).unwrap();
ppc_wide_shift(&mut memory, TARGET, 1);
assert_eq!(ppc_read_wide(&mut memory, TARGET), Some(-3));
ppc_wide_shift(&mut memory, TARGET, -2);
assert_eq!(ppc_read_wide(&mut memory, TARGET), Some(-12));
assert_eq!(
ppc_wide_multiply(&mut memory, -2_000_000_000, 2, TARGET),
TARGET
);
assert_eq!(ppc_read_wide(&mut memory, TARGET), Some(-4_000_000_000));
ppc_write_wide(&mut memory, TARGET, 10).unwrap();
assert_eq!(ppc_wide_divide(&mut memory, TARGET, 3, REMAINDER), 3);
assert_eq!(memory.read_u32_be(REMAINDER), Some(1));
ppc_write_wide(&mut memory, TARGET, 11).unwrap();
assert_eq!(ppc_wide_divide(&mut memory, TARGET, 2, 0), 6);
ppc_write_wide(&mut memory, TARGET, -11).unwrap();
assert_eq!(ppc_wide_divide(&mut memory, TARGET, 2, 0), -5);
ppc_write_wide(&mut memory, TARGET, i64::MAX).unwrap();
assert_eq!(ppc_wide_divide(&mut memory, TARGET, 1, REMAINDER), i32::MAX);
assert_eq!(memory.read_u32_be(REMAINDER), Some(i32::MIN as u32));
assert_eq!(ppc_wide_divide(&mut memory, TARGET, 1, u32::MAX), i32::MIN);
ppc_write_wide(&mut memory, TARGET, 11).unwrap();
assert_eq!(
ppc_wide_wide_divide(&mut memory, TARGET, 2, REMAINDER),
TARGET
);
assert_eq!(ppc_read_wide(&mut memory, TARGET), Some(5));
assert_eq!(memory.read_u32_be(REMAINDER), Some(1));
ppc_write_wide(&mut memory, TARGET, 11).unwrap();
ppc_wide_wide_divide(&mut memory, TARGET, 2, 0);
assert_eq!(ppc_read_wide(&mut memory, TARGET), Some(6));
ppc_write_wide(&mut memory, TARGET, 81).unwrap();
assert_eq!(ppc_wide_square_root(&mut memory, TARGET), 9);
memory.write_u32_be(TARGET, u32::MAX).unwrap();
memory.write_u32_be(TARGET + 4, u32::MAX).unwrap();
assert_eq!(ppc_wide_square_root(&mut memory, TARGET), u32::MAX);
ppc_write_wide(&mut memory, TARGET, -1).unwrap();
ppc_write_wide(&mut memory, SOURCE, 1).unwrap();
assert_eq!(ppc_wide_compare(&mut memory, TARGET, SOURCE), -1);
ppc_write_wide(&mut memory, SOURCE, -1).unwrap();
assert_eq!(ppc_wide_compare(&mut memory, TARGET, SOURCE), 0);
}
#[test]
fn ppc_wide_fixmath_imports_execute_through_synthetic_pefs() {
// Universal Interfaces 3.4 FixMath.h declares these as InterfaceLib
// exports; semantics are from QuickDraw GX Environment and Utilities
// (1994), pp. 8-49 through 8-54.
let cases = [
("WideAdd", PpcImportDispatcherTarget::WideAdd),
("WideSubtract", PpcImportDispatcherTarget::WideSubtract),
("WideNegate", PpcImportDispatcherTarget::WideNegate),
("WideShift", PpcImportDispatcherTarget::WideShift),
("WideMultiply", PpcImportDispatcherTarget::WideMultiply),
("WideDivide", PpcImportDispatcherTarget::WideDivide),
("WideWideDivide", PpcImportDispatcherTarget::WideWideDivide),
("WideSquareRoot", PpcImportDispatcherTarget::WideSquareRoot),
("WideCompare", PpcImportDispatcherTarget::WideCompare),
];
for (name, target) in cases {
let mut loaded = load_pef_application(&synthetic_pef_with_import(name.as_bytes()))
.expect("synthetic Wide FixMath PEF should load");
assert_eq!(loaded.imports[0].dispatcher_target, target, "{name}");
let scratch = PPC_DATA_BASE + 0x1000;
let source = scratch + 8;
let remainder = scratch + 16;
loaded.memory.add_region(scratch, vec![0; 0x100]);
ppc_write_wide(&mut loaded.memory, scratch, 9).unwrap();
ppc_write_wide(&mut loaded.memory, source, 4).unwrap();
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = source;
loaded.cpu.gpr[5] = remainder;
match name {
"WideShift" => loaded.cpu.gpr[4] = 1,
"WideMultiply" => {
loaded.cpu.gpr[3] = (-3i32) as u32;
loaded.cpu.gpr[4] = 7;
loaded.cpu.gpr[5] = scratch;
}
"WideDivide" | "WideWideDivide" => {
loaded.cpu.gpr[4] = 2;
}
"WideSquareRoot" => {}
_ => {}
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let result = loaded.run_with_hle_imports(64);
assert_eq!(result.handled_import_count, 1, "{name}");
match name {
"WideAdd" => assert_eq!(ppc_read_wide(&mut loaded.memory, scratch), Some(13)),
"WideSubtract" => {
assert_eq!(ppc_read_wide(&mut loaded.memory, scratch), Some(5))
}
"WideNegate" => {
assert_eq!(ppc_read_wide(&mut loaded.memory, scratch), Some(-9))
}
"WideShift" => {
assert_eq!(ppc_read_wide(&mut loaded.memory, scratch), Some(5))
}
"WideMultiply" => {
assert_eq!(ppc_read_wide(&mut loaded.memory, scratch), Some(-21))
}
"WideDivide" => {
assert_eq!(loaded.cpu.gpr[3], 4);
assert_eq!(loaded.memory.read_u32_be(remainder), Some(1));
}
"WideWideDivide" => {
assert_eq!(loaded.cpu.gpr[3], scratch);
assert_eq!(ppc_read_wide(&mut loaded.memory, scratch), Some(4));
assert_eq!(loaded.memory.read_u32_be(remainder), Some(1));
}
"WideSquareRoot" => assert_eq!(loaded.cpu.gpr[3], 3),
"WideCompare" => assert_eq!(loaded.cpu.gpr[3], 1),
_ => unreachable!(),
}
}
}
#[test]
fn ppc_pb_get_fcb_info_reports_open_data_and_application_resource_forks() {
let pb = 0x2000;
let name = 0x2100;
let mut memory = PpcSectionMem::new();
memory.add_region(pb, vec![0; 0x200]);
let directories = initial_ppc_vfs_directories();
let path = "System Folder/Preferences/Test File";
let files = vec![PpcFileRecord {
ref_num: 130,
path: path.to_string(),
position: 2,
}];
let vfs_files = vec![PpcVfsFileRecord {
path: path.to_string(),
data: (b"data".to_vec()).into(),
creator: 0,
file_type: 0,
finder_flags: 0,
dirty: false,
}];
memory.write_u32_be(pb + 18, name).unwrap();
memory.write_u16_be(pb + 22, 0x1234).unwrap();
memory.write_u16_be(pb + 24, 130).unwrap();
memory.write_u16_be(pb + 28, 0).unwrap();
let mut cpu = PpcCpu::new();
cpu.gpr[3] = pb;
assert_eq!(
ppc_pb_get_fcb_info(
&cpu,
&mut memory,
&files,
&[],
&directories,
&vfs_files,
&[],
&[],
Some("Escape Velocity"),
),
PPC_NO_ERR
);
assert_eq!(
ppc_read_pstring_bytes(&mut memory, name),
Some(b"Test File".to_vec())
);
assert_eq!(memory.read_u16_be(pb + 36), Some(0x0100));
assert_eq!(memory.read_u32_be(pb + 40), Some(4));
assert_eq!(memory.read_u32_be(pb + 48), Some(2));
assert_eq!(memory.read_u32_be(pb + 58), Some(PPC_PREFERENCES_DIR_ID));
let resource_path = "Escape Velocity";
let resource_forks = vec![PpcVfsResourceFileRecord {
path: resource_path.to_string(),
creator: 0,
file_type: 0,
finder_flags: 0,
resource_len: 3,
raw_data: Some(b"fork".to_vec().into()),
map_attrs: 0,
dirty: false,
}];
memory.write_u16_be(pb + 24, 0).unwrap();
assert_eq!(
ppc_pb_get_fcb_info(
&cpu,
&mut memory,
&files,
&[],
&directories,
&vfs_files,
&resource_forks,
&[],
Some(resource_path),
),
PPC_NO_ERR
);
assert_eq!(memory.read_u16_be(pb + 36), Some(0x0200));
assert_eq!(memory.read_u32_be(pb + 40), Some(4));
assert_eq!(memory.read_u32_be(pb + 58), Some(PPC_ROOT_DIR_ID));
}
#[test]
fn protected_ppc_clut_entries_are_unchanged_by_set_entries() {
let table = 0x2000;
let mut memory = PpcSectionMem::new();
memory.add_region(table, vec![0; 8]);
memory.write_u16_be(table, 7).unwrap();
memory.write_u16_be(table + 2, 0x1111).unwrap();
memory.write_u16_be(table + 4, 0x2222).unwrap();
memory.write_u16_be(table + 6, 0x3333).unwrap();
let mut screen_clut = [[0; 3]; 256];
let mut startup = PpcToolboxStartupState::default();
ppc_set_clut_entry_flag(&mut startup.clut_protected, 7, true);
let protected = startup.clut_protected;
assert!(ppc_apply_set_entries(
&mut memory,
-1,
0,
table,
0,
&mut screen_clut,
&protected,
None,
true,
&mut startup,
));
assert_eq!(screen_clut[7], [0, 0, 0]);
ppc_set_clut_entry_flag(&mut startup.clut_protected, 7, false);
let protected = startup.clut_protected;
assert!(ppc_apply_set_entries(
&mut memory,
-1,
0,
table,
0,
&mut screen_clut,
&protected,
None,
true,
&mut startup,
));
assert_eq!(screen_clut[7], [0x1111, 0x2222, 0x3333]);
}
#[test]
fn ppc_clut_entry_flags_ignore_invalid_indices_and_can_be_cleared() {
let mut flags = [false; 256];
ppc_set_clut_entry_flag(&mut flags, 3, true);
ppc_set_clut_entry_flag(&mut flags, -1, true);
ppc_set_clut_entry_flag(&mut flags, 256, true);
assert!(flags[3]);
assert_eq!(flags.iter().filter(|flag| **flag).count(), 1);
ppc_set_clut_entry_flag(&mut flags, 3, false);
assert!(!flags[3]);
}
#[test]
fn color_manager_entry_flags_are_scoped_per_gdevice() {
let mut startup = PpcToolboxStartupState::default();
let other_gdevice = PPC_DATA_BASE + 0x9000;
ppc_set_clut_entry_flag(
ppc_device_clut_protected_mut(&mut startup, other_gdevice),
7,
true,
);
ppc_set_clut_entry_flag(
ppc_device_clut_reserved_mut(&mut startup, other_gdevice),
8,
true,
);
assert!(!ppc_device_clut_protected(&startup, PPC_MAIN_GDEVICE)[7]);
assert!(!ppc_device_clut_reserved(&startup, PPC_MAIN_GDEVICE)[8]);
assert!(ppc_device_clut_protected(&startup, other_gdevice)[7]);
assert!(ppc_device_clut_reserved(&startup, other_gdevice)[8]);
}
#[test]
fn make_itable_resizes_target_and_excludes_reserved_colors() {
let heap_base = 0x3000;
let heap_limit = heap_base + 0x20_000;
let mut memory = PpcSectionMem::new();
memory.add_region(heap_base, vec![0; (heap_limit - heap_base) as usize]);
let mut heap_cursor = heap_base;
let mut handles = Vec::new();
let mut ctable = Vec::new();
ctable.extend_from_slice(&0x1234_5678u32.to_be_bytes());
ctable.extend_from_slice(&0u16.to_be_bytes());
ctable.extend_from_slice(&1u16.to_be_bytes());
for (index, color) in [(7u16, [0u16, 0, 0]), (9u16, [0xffffu16; 3])] {
ctable.extend_from_slice(&index.to_be_bytes());
for component in color {
ctable.extend_from_slice(&component.to_be_bytes());
}
}
let ctable_handle = ppc_alloc_handle_with_bytes(
&mut memory,
&mut heap_cursor,
heap_limit,
&mut handles,
&ctable,
);
let itable_handle = ppc_alloc_handle(
&mut memory,
&mut heap_cursor,
heap_limit,
&mut handles,
1,
true,
);
let mut cpu = PpcCpu::new();
cpu.gpr[3] = ctable_handle;
cpu.gpr[4] = itable_handle;
cpu.gpr[5] = 4;
let mut startup = PpcToolboxStartupState::default();
ppc_set_clut_entry_flag(&mut startup.clut_reserved, 7, true);
let mut last_mem_error = PPC_NO_ERR;
ppc_make_itable(
&cpu,
None,
&mut memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
PPC_MAIN_GDEVICE,
&[[0; 3]; 256],
&mut startup,
);
assert_eq!(*startup.last_quickdraw_error, PPC_NO_ERR);
let record = handles
.iter()
.find(|record| record.handle == itable_handle)
.unwrap();
assert_eq!(record.size, 6 + 4096);
let itable = memory.read_u32_be(itable_handle).unwrap();
assert_eq!(memory.read_u32_be(itable), Some(0x1234_5678));
assert_eq!(memory.read_u16_be(itable + 4), Some(4));
assert!(ppc_memory_read_bytes(&mut memory, itable + 6, 4096)
.unwrap()
.iter()
.all(|index| *index == 9));
}
#[test]
fn make_itable_reports_invalid_resolution_without_touching_target() {
let heap_base = 0x3000;
let heap_limit = heap_base + 0x1000;
let mut memory = PpcSectionMem::new();
memory.add_region(heap_base, vec![0; (heap_limit - heap_base) as usize]);
let mut heap_cursor = heap_base;
let mut handles = Vec::new();
let itable_handle = ppc_alloc_handle_with_bytes(
&mut memory,
&mut heap_cursor,
heap_limit,
&mut handles,
b"unchanged",
);
let mut cpu = PpcCpu::new();
cpu.gpr[4] = itable_handle;
cpu.gpr[5] = 2;
let mut startup = PpcToolboxStartupState::default();
let mut last_mem_error = PPC_NO_ERR;
ppc_make_itable(
&cpu,
None,
&mut memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
0,
&[[0; 3]; 256],
&mut startup,
);
assert_eq!(*startup.last_quickdraw_error, PPC_C_RES_ERR);
let itable = memory.read_u32_be(itable_handle).unwrap();
assert_eq!(
ppc_memory_read_bytes(&mut memory, itable, 9),
Some(b"unchanged".to_vec())
);
}
#[test]
fn hand_to_hand_duplicates_tracked_handle_storage() {
let heap_base = 0x3000;
let handle_variable = 0x3f00;
let mut memory = PpcSectionMem::new();
memory.add_region(heap_base, vec![0; 0x1000]);
let mut heap_cursor = heap_base;
let mut handles = Vec::new();
let mut free_handles = Vec::new();
let source = ppc_alloc_handle_with_bytes(
&mut memory,
&mut heap_cursor,
heap_base + 0x1000,
&mut handles,
b"copy me",
);
memory.write_u32_be(handle_variable, source).unwrap();
let mut cpu = PpcCpu::new();
cpu.gpr[3] = handle_variable;
assert_eq!(
ppc_hand_to_hand(
&cpu,
&mut memory,
&mut heap_cursor,
heap_base + 0x1000,
&mut handles,
&mut free_handles,
),
PPC_NO_ERR
);
let copy = memory.read_u32_be(handle_variable).unwrap();
assert_ne!(copy, source);
let copy_data = memory.read_u32_be(copy).unwrap();
assert_eq!(
ppc_memory_read_bytes(&mut memory, copy_data, 7),
Some(b"copy me".to_vec())
);
}
#[test]
fn hand_to_hand_duplicates_main_device_color_table() {
let heap_base = 0x0300_0000;
let heap_limit = heap_base + 0x4000;
let handle_variable = heap_base + 0x3f00;
let mut memory = PpcSectionMem::new();
memory.add_region(PPC_MAIN_CTABLE_HANDLE, vec![0; 4]);
memory.add_region(PPC_MAIN_CTABLE, vec![0; PPC_MAIN_CTABLE_SIZE as usize]);
memory.add_region(heap_base, vec![0; (heap_limit - heap_base) as usize]);
ppc_seed_main_color_table(&mut memory).unwrap();
memory
.write_u32_be(handle_variable, PPC_MAIN_CTABLE_HANDLE)
.unwrap();
let mut heap_cursor = heap_base;
let mut handles = Vec::new();
let mut free_handles = Vec::new();
let mut cpu = PpcCpu::new();
cpu.gpr[3] = handle_variable;
assert_eq!(
ppc_hand_to_hand(
&cpu,
&mut memory,
&mut heap_cursor,
heap_limit,
&mut handles,
&mut free_handles,
),
PPC_NO_ERR
);
let copy = memory.read_u32_be(handle_variable).unwrap();
let copy_data = memory.read_u32_be(copy).unwrap();
assert_ne!(copy, PPC_MAIN_CTABLE_HANDLE);
assert_eq!(handles[0].size, PPC_MAIN_CTABLE_SIZE);
assert_eq!(
ppc_memory_read_bytes(&mut memory, copy_data, PPC_MAIN_CTABLE_SIZE),
ppc_memory_read_bytes(&mut memory, PPC_MAIN_CTABLE, PPC_MAIN_CTABLE_SIZE)
);
}
#[test]
fn sprocket_trace_formatter_includes_draw_sprocket_state() {
let mut attrs = PpcDspContextAttributes::default();
attrs.width = 800;
attrs.height = 600;
attrs.page_count = 2;
let draw_sprocket = PpcDrawSprocketState {
started: true,
reserved_context: Some(0x00ab_cdef),
active_context: Some(0x00ab_cdef),
context_state: PpcDspContextPlayState::Active,
context_attributes: attrs,
last_swap_context: Some(0x00ab_cdef),
swap_count: 3,
last_fade_context: Some(0x00ab_cdef),
last_fade_kind: Some(PpcDspGammaFadeKind::Out),
last_fade_percent: Some(0),
last_fade_zero_color: Some(PpcRgbColor {
red: 0x1111,
green: 0x2222,
blue: 0x3333,
}),
fade_count: 1,
..PpcDrawSprocketState::default()
};
let entry = PpcHleImportTraceEntry {
import_index: 41,
library_name: "DrawSprocketLib".to_string(),
symbol_name: "DSpContext_SwapBuffers".to_string(),
pc: 0x01f0_1000,
lr: 0x0100_2000,
rtoc: 0x0200_3000,
sp: 0x03fe_f000,
dispatcher_target: PpcImportDispatcherTarget::DSpContextSwapBuffers,
repeat_count: 1,
};
assert_eq!(
format_sprocket_trace(
&entry,
[0x00ab_cdef, 0, 0, 0, 0, 0],
&format_sprocket_action(&PpcImportAction::Return(0)),
&draw_sprocket,
&PpcInputSprocketState::default(),
&[],
),
"[SPROCKET-TRACE] DrawSprocketLib:DSpContext_SwapBuffers pc=$01F01000 lr=$01002000 rtoc=$02003000 sp=$03FEF000 r3=$00ABCDEF r4=$00000000 r5=$00000000 r6=$00000000 r7=$00000000 r8=$00000000 action=return($00000000) dsp started=true reserved=$00ABCDEF active=$00ABCDEF state=active attrs=800x600 display_depth=16 back_depth=16 pages=2 front=$02F00000 back=$05010000 swaps=3 last_swap=$00ABCDEF fades=1 last_fade=out context=$00ABCDEF percent=0 zero=$1111/$2222/$3333"
);
}
#[test]
fn sprocket_trace_formatter_includes_input_sprocket_state() {
let input_sprocket = PpcInputSprocketState {
initialized: true,
suspended: false,
keyboard_active: true,
mouse_active: false,
configure_count: 2,
virtual_element_count: 5,
last_virtual_need_count: 3,
last_virtual_needs_ptr: 0x0200_1000,
last_virtual_elements_out_ptr: 0x0200_2000,
};
let entry = PpcHleImportTraceEntry {
import_index: 51,
library_name: "InputSprocketLib".to_string(),
symbol_name: "ISpElement_GetSimpleState".to_string(),
pc: 0x01f0_1100,
lr: 0x0100_2100,
rtoc: 0x0200_3100,
sp: 0x03fe_efc0,
dispatcher_target: PpcImportDispatcherTarget::ISpElementGetSimpleState,
repeat_count: 1,
};
assert_eq!(
format_sprocket_trace(
&entry,
[0x0200_3000, 0x0200_4000, 0, 0, 0, 0],
"return-preserve",
&PpcDrawSprocketState::default(),
&input_sprocket,
&[],
),
"[SPROCKET-TRACE] InputSprocketLib:ISpElement_GetSimpleState pc=$01F01100 lr=$01002100 rtoc=$02003100 sp=$03FEEFC0 r3=$02003000 r4=$02004000 r5=$00000000 r6=$00000000 r7=$00000000 r8=$00000000 action=return-preserve isp initialized=true suspended=false keyboard=true mouse=false virtuals=5 last_need_count=3 last_needs=$02001000 last_elements=$02002000 configure_count=2"
);
}
#[test]
fn sprocket_trace_formatter_includes_input_sprocket_virtual_bindings_on_creation() {
let input_sprocket = PpcInputSprocketState {
initialized: true,
suspended: false,
keyboard_active: true,
mouse_active: true,
configure_count: 0,
virtual_element_count: 2,
last_virtual_need_count: 2,
last_virtual_needs_ptr: 0x0200_1000,
last_virtual_elements_out_ptr: 0x0200_2000,
};
let virtual_elements = vec![
PpcInputSprocketVirtualElementRecord {
element: 0x0300_0000,
need_index: 0,
need_source: 0x0200_1000,
kind: PPC_ISP_ELEMENT_KIND_BUTTON,
default_state: 0,
action_binding: PpcInputSprocketActionBinding::ButtonFire,
need_name: "Fire".to_string(),
need_record: Vec::new(),
},
PpcInputSprocketVirtualElementRecord {
element: 0x0300_0100,
need_index: 1,
need_source: 0x0200_1000 + PPC_ISP_NEED_SIZE,
kind: PPC_ISP_ELEMENT_KIND_DELTA,
default_state: 0,
action_binding: PpcInputSprocketActionBinding::DeltaYaw,
need_name: "Yaw (Mouse)".to_string(),
need_record: Vec::new(),
},
];
let entry = PpcHleImportTraceEntry {
import_index: 50,
library_name: "InputSprocketLib".to_string(),
symbol_name: "ISpElement_NewVirtualFromNeeds".to_string(),
pc: 0x01f0_1000,
lr: 0x0100_2000,
rtoc: 0x0200_3000,
sp: 0x03fe_f000,
dispatcher_target: PpcImportDispatcherTarget::ISpElementNewVirtualFromNeeds,
repeat_count: 1,
};
assert_eq!(
format_sprocket_trace(
&entry,
[2, 0x0200_1000, 0x0200_2000, 0, 0, 0],
"return($00000000)",
&PpcDrawSprocketState::default(),
&input_sprocket,
&virtual_elements,
),
"[SPROCKET-TRACE] InputSprocketLib:ISpElement_NewVirtualFromNeeds pc=$01F01000 lr=$01002000 rtoc=$02003000 sp=$03FEF000 r3=$00000002 r4=$02001000 r5=$02002000 r6=$00000000 r7=$00000000 r8=$00000000 action=return($00000000) isp initialized=true suspended=false keyboard=true mouse=true virtuals=2 last_need_count=2 last_needs=$02001000 last_elements=$02002000 configure_count=0 last_bindings=[#0 button 'Fire'=button/fire,#1 delta 'Yaw (Mouse)'=delta/yaw]"
);
}
#[test]
fn qd3d_trace_formatter_includes_state_counts_and_latest_records() {
let before = Qd3dTraceSnapshot {
objects: 1,
views: 1,
latest_object: Some(PpcQ3ObjectRecord {
object: 0x0500_0000,
kind: PpcQ3ObjectKind::Generic,
object_type: 0x1111_2222,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
}),
..Qd3dTraceSnapshot::default()
};
let after = Qd3dTraceSnapshot {
objects: 2,
views: 1,
submissions: 1,
completed_frames: 1,
memory_storages: 1,
files: 1,
group_memberships: 2,
trimeshes: 1,
draw_contexts: 1,
textures: 1,
shaders: 1,
styles: 1,
cameras: 1,
lights: 1,
latest_object: Some(PpcQ3ObjectRecord {
object: 0x0500_0010,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: 0x5354_4F52,
source: PpcQ3ObjectSource::default(),
data_ptr: 0x0200_1000,
data_size: 32,
}),
latest_submission: Some(PpcQ3SubmissionRecord {
view: 0x0500_0020,
kind: PpcQ3SubmissionKind::TriMesh,
primary: 0x0200_2000,
secondary: 0,
}),
latest_frame_view: Some(0x0500_0020),
latest_frame_submissions: 4,
};
let entry = PpcHleImportTraceEntry {
import_index: 61,
library_name: "QuickDraw\u{2122} 3D".to_string(),
symbol_name: "Q3TriMesh_Submit".to_string(),
pc: 0x01f0_1200,
lr: 0x0100_2200,
rtoc: 0x0200_3200,
sp: 0x03fe_ef80,
dispatcher_target: PpcImportDispatcherTarget::Q3TriMeshSubmit,
repeat_count: 1,
};
assert_eq!(
format_qd3d_trace(
&entry,
[0x0200_2000, 0x0500_0020, 0, 0, 0, 0],
"return($00000001)",
&before,
&after,
),
"[QD3D-TRACE] QuickDraw\u{2122} 3D:Q3TriMesh_Submit pc=$01F01200 lr=$01002200 rtoc=$02003200 sp=$03FEEF80 r3=$02002000 r4=$05000020 r5=$00000000 r6=$00000000 r7=$00000000 r8=$00000000 action=return($00000001) objects=2(+1) views=1(+0) submissions=1(+1) frames=1(+1) storages=1(+1) files=1(+1) groups=2(+2) trimeshes=1(+1) draw_contexts=1(+1) textures=1(+1) shaders=1(+1) styles=1(+1) cameras=1(+1) lights=1(+1) object=$05000010 kind=memory-storage type=$53544F52 data=$02001000/32 submission=trimesh view=$05000020 primary=$02002000 secondary=$00000000 frame_view=$05000020 frame_submissions=4"
);
}
#[test]
fn qd3d_trace_snapshot_tracks_latest_object_submission_and_frame() {
let object = PpcQ3ObjectRecord {
object: 0x0500_0000,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0x0200_1000,
data_size: 16,
};
let submission = PpcQ3SubmissionRecord {
view: 0x0500_0010,
kind: PpcQ3SubmissionKind::Object,
primary: object.object,
secondary: 0,
};
let frame = PpcQ3CompletedFrameRecord {
view: 0x0500_0010,
submissions: vec![submission],
submission_transforms: Vec::new(),
submission_materials: Vec::new(),
submission_lights: Vec::new(),
retained_trimeshes: Vec::new(),
};
let snapshot = qd3d_trace_snapshot(
&[object],
&[PpcQ3ViewStateRecord::new(0x0500_0010)],
&[submission],
&[frame],
&[],
&[],
&[],
&[],
&[],
&[],
&[],
&[],
&[],
&[],
&[],
);
assert_eq!(snapshot.objects, 1);
assert_eq!(snapshot.views, 1);
assert_eq!(snapshot.submissions, 1);
assert_eq!(snapshot.completed_frames, 1);
assert_eq!(snapshot.latest_object, Some(object));
assert_eq!(snapshot.latest_submission, Some(submission));
assert_eq!(snapshot.latest_frame_view, Some(0x0500_0010));
assert_eq!(snapshot.latest_frame_submissions, 1);
}
#[test]
fn pef_dump_json_includes_loader_sections_imports_and_entry() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let loaded = load_pef_application(&pef).unwrap();
let header = parse_pef_header(&pef).unwrap();
let loader = parse_pef_loader_header(&pef).unwrap();
let raw_sections = parse_pef_sections(&pef).unwrap();
let mapped_sections = map_instantiated_sections(&pef).unwrap();
let reloc_headers = parse_pef_reloc_headers(&pef).unwrap_or_default();
let report = format_pef_dump_json(&PefDumpContext {
data_len: pef.len(),
header,
loader,
raw_sections: &raw_sections,
mapped_sections: &mapped_sections,
imports: &loaded.imports,
reloc_headers: &reloc_headers,
entry_pc: loaded.entry_pc,
rtoc: loaded.rtoc,
stack_base: loaded.stack_base,
stack_size: loaded.stack_size,
stack_top: PPC_STACK_TOP,
});
assert!(report.contains("\"format\": \"systemless_pef_dump_v1\""));
assert!(report.contains("\"architecture\": \"pwpc\""));
assert!(report.contains("\"kind\": \"code\""));
assert!(report.contains("\"mapped_base\": \"0x01000000\""));
assert!(report.contains("\"library\": \"InterfaceLib\""));
assert!(report.contains("\"symbol\": \"NewPtrClear\""));
assert!(report.contains("\"dispatcher_target\": \"NewPtr { clear: true }\""));
assert!(report.contains("\"entry_pc\": \"0x01000000\""));
assert!(report.contains("\"rtoc\": \"0x02000000\""));
assert!(report.contains("\"base\": \"0x04FF0000\""));
}
#[test]
fn load_pef_application_reports_detailed_relocation_apply_failure() {
let pef = synthetic_pef_with_reloc_chunks(
b"InterfaceLib",
b"OnlyImport",
&[delt(8), sm_index_reloc(0x30, 0)],
);
let error = load_pef_application(&pef).unwrap_err();
assert_eq!(
error,
PpcLoadError::RelocationApply {
section_index: 1,
reloc_instr_offset: 2,
section_position: 8,
import_index: Some(0),
import_symbol: Some(PpcRelocationImportSymbol {
symbol_index: 0,
library_name: "InterfaceLib".to_string(),
symbol_name: "OnlyImport".to_string(),
class: 2,
weak: false,
}),
error: PefRelocApplyError::OutOfRange {
position: 8,
section_len: 8,
},
}
);
}
#[test]
fn load_pef_application_seeds_ppc_cpu_and_reaches_import_trace() {
let pef = synthetic_pef();
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(loaded.entry_pc, PPC_CODE_BASE);
assert_eq!(loaded.rtoc, PPC_DATA_BASE);
assert_eq!(loaded.cpu.pc, PPC_CODE_BASE);
assert_eq!(loaded.cpu.gpr[1], PPC_STACK_TOP - 64);
assert_eq!(loaded.stack_base, PPC_STACK_BASE);
assert_eq!(loaded.stack_size, PPC_DEFAULT_STACK_SIZE);
assert_eq!(loaded.heap_base(), PPC_HEAP_BASE);
assert_eq!(loaded.heap_cursor(), PPC_HEAP_BASE);
assert_eq!(test_heap_limit!(loaded), PPC_STACK_BASE);
assert_eq!(loaded.last_mem_error(), 0);
assert_eq!(*loaded.process_file_system.current_resource_file, 0);
assert_eq!(loaded.test_resource_error(), 0);
assert_eq!(loaded.cfm.as_ref().unwrap().connections.len(), 0);
assert_eq!(
loaded.cfm.as_ref().unwrap().next_connection_id,
PPC_FIRST_CFM_CONNECTION_ID
);
assert_eq!(test_handle_records!(loaded).len(), 0);
assert_eq!(loaded.gworlds.len(), 2);
assert_eq!(loaded.gworlds[0].port, PPC_MAIN_GWORLD);
assert_eq!(loaded.gworlds[0].pixmap_handle, PPC_MAIN_PIXMAP_HANDLE);
assert_eq!(loaded.gworlds[0].base_addr, PPC_MAIN_SCREEN_BASE);
assert_eq!(
loaded.memory.read_u16_be(PPC_MAIN_GDEVICE_RECORD + 4),
Some(0),
"the default indexed display is a clutType GDevice"
);
assert_eq!(
loaded.memory.read_u32_be(PPC_MAIN_GDEVICE_RECORD + 42),
Some(0x83),
"the default 8-bit display publishes the classic eightBitMode token"
);
assert_eq!(loaded.gworlds[1].port, PPC_DSP_BACK_GWORLD);
assert_eq!(loaded.gworlds[1].pixmap_handle, PPC_DSP_BACK_PIXMAP_HANDLE);
assert_eq!(loaded.gworlds[1].base_addr, PPC_DSP_BACK_SCREEN_BASE);
assert_eq!(loaded.draw_sprocket.front_buffer_gworld, PPC_MAIN_GWORLD);
assert_eq!(loaded.draw_sprocket.back_buffer_gworld, PPC_DSP_BACK_GWORLD);
assert_eq!(loaded.q3_objects.len(), 0);
assert_eq!(loaded.next_q3_object, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_error_state, PpcQ3ErrorState::default());
assert_eq!(loaded.q3_lifecycle, PpcQ3LifecycleState::default());
assert_eq!(loaded.q3_memory_storages.len(), 0);
assert_eq!(loaded.q3_files.len(), 0);
assert_eq!(loaded.q3_group_memberships.len(), 0);
assert_eq!(loaded.q3_file_groups.len(), 0);
assert_eq!(loaded.q3_views.len(), 0);
assert_eq!(loaded.q3_submissions.len(), 0);
assert_eq!(loaded.q3_view_transforms.len(), 0);
assert_eq!(loaded.q3_submission_transforms.len(), 0);
assert_eq!(loaded.q3_view_materials.len(), 0);
assert_eq!(loaded.q3_submission_materials.len(), 0);
assert_eq!(loaded.q3_submission_lights.len(), 0);
assert_eq!(loaded.q3_fog_styles.len(), 0);
assert_eq!(loaded.q3_attributes.len(), 0);
assert_eq!(loaded.q3_shader_uv_transforms.len(), 0);
assert_eq!(loaded.q3_mipmap_textures.len(), 0);
assert_eq!(loaded.q3_texture_shaders.len(), 0);
assert_eq!(loaded.q3_trimeshes.len(), 0);
assert_eq!(loaded.q3_styles.len(), 0);
assert_eq!(loaded.q3_cameras.len(), 0);
assert_eq!(loaded.q3_lights.len(), 0);
assert_eq!(loaded.input_sprocket, PpcInputSprocketState::default());
assert_eq!(loaded.quicktime, PpcQuickTimeState::default());
assert_eq!(loaded.sound, PpcSoundState::default());
assert_eq!(loaded.draw_sprocket, PpcDrawSprocketState::default());
assert_eq!(loaded.toolbox_startup, PpcToolboxStartupState::default());
assert_eq!(loaded.files.len(), 0);
assert_eq!(loaded.vfs_files.len(), 0);
assert_eq!(loaded.resource_files.len(), 0);
assert_eq!(loaded.vfs_resource_files.len(), 0);
assert_eq!(loaded.process_file_system.vfs_resources.len(), 0);
assert_eq!(loaded.next_file_ref_num, PPC_FIRST_FILE_REF_NUM);
assert_eq!(
loaded.sound.manager.default_output_volume(),
PPC_DEFAULT_OUTPUT_VOLUME
);
assert_eq!(*loaded.current_gworld, PPC_MAIN_GWORLD);
assert_eq!(*loaded.current_gdevice, PPC_MAIN_GDEVICE);
assert_eq!(loaded.default_dir_id, PPC_ROOT_DIR_ID);
assert_eq!(
loaded.memory.read_u32_be(PPC_MAIN_GWORLD + 2),
Some(PPC_MAIN_PIXMAP_HANDLE)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_MAIN_PIXMAP_HANDLE),
Some(PPC_MAIN_PIXMAP)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_MAIN_PIXMAP),
Some(PPC_MAIN_SCREEN_BASE)
);
assert_eq!(loaded.cpu.gpr[2], PPC_DATA_BASE);
assert_eq!(loaded.memory.read_u32_be(PPC_CFM_MAIN_STUB_BASE), Some(BLR));
assert_eq!(
loaded.memory.read_u32_be(PPC_PORT_LIST_ADDR),
Some(PPC_PORT_LIST_HANDLE)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_PORT_LIST_HANDLE),
Some(PPC_PORT_LIST)
);
assert_eq!(loaded.memory.read_u16_be(PPC_PORT_LIST), Some(0));
assert_eq!(loaded.memory.read_u32_be(0), Some(0));
assert!(loaded.memory.write_u32_be(0, 0xdead_beef).is_some());
assert_eq!(loaded.memory.read_u32_be(0), Some(0xdead_beef));
assert_eq!(loaded.stack_pointer & 0x0f, 0);
assert_eq!(loaded.import_count, 1);
assert_eq!(loaded.imports[0].library_name, "InterfaceLib");
assert_eq!(loaded.imports[0].symbol_name, "TestImport");
assert_eq!(loaded.imports[0].class, 2);
assert!(!loaded.imports[0].weak);
assert_eq!(loaded.imports[0].address, PPC_IMPORT_TVECTOR_BASE);
assert_eq!(
loaded.imports[0].tvector_address,
Some(PPC_IMPORT_TVECTOR_BASE)
);
assert_eq!(loaded.imports[0].trap_pc, PPC_IMPORT_TRAP_BASE);
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::Unsupported
);
let (result, trace) = loaded.run_import_trace(64);
assert!(
matches!(
result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
),
"{result:?}"
);
assert_eq!(trace, vec![0]);
}
#[test]
fn import_bindings_preserve_symbol_metadata_and_synthetic_addresses() {
let bindings = PpcImportBindingPlan::prepare(
vec![
PefResolvedImport {
library_index: 0,
symbol_index: 0,
library_name: "InterfaceLib".to_string(),
symbol_name: "Gestalt".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 1,
library_name: "InterfaceLib".to_string(),
symbol_name: "FindSymbol".to_string(),
class: 0,
weak: true,
},
],
2,
0,
ppc_import_layout(),
&SystemlessPpcImportBindingPolicy,
)
.unwrap()
.into_initial_bindings();
assert_eq!(bindings.len(), 2);
assert_eq!(bindings[0].library_name, "InterfaceLib");
assert_eq!(bindings[0].symbol_name, "Gestalt");
assert_eq!(bindings[0].address, PPC_IMPORT_TVECTOR_BASE);
assert_eq!(bindings[0].tvector_address, Some(PPC_IMPORT_TVECTOR_BASE));
assert_eq!(bindings[0].trap_pc, PPC_IMPORT_TRAP_BASE);
assert!(!bindings[0].weak);
assert_eq!(bindings[1].symbol_name, "FindSymbol");
assert_eq!(bindings[1].address, PPC_IMPORT_TRAP_BASE + 4);
assert_eq!(bindings[1].tvector_address, None);
assert_eq!(bindings[1].trap_pc, PPC_IMPORT_TRAP_BASE + 4);
assert!(bindings[1].weak);
assert_eq!(
bindings[1].dispatcher_target,
PpcImportDispatcherTarget::FindSymbol
);
}
#[test]
fn unavailable_weak_import_relocates_to_cfm_unresolved_symbol_address() {
let pef = synthetic_pef_with_import_class(b"MissingOptionalAPI", 0x82);
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(loaded.imports[0].address, 0);
assert_eq!(loaded.imports[0].tvector_address, None);
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::UnresolvedWeak
);
assert_eq!(loaded.memory.read_u32_be(PPC_DATA_BASE), Some(0));
}
#[test]
fn legacy_memory_utility_imports_pre_resolve_to_typed_operations() {
for (symbol, operation) in [
("BitClr", PpcLegacyMemoryUtilityOperation::BitClear),
("BitNot", PpcLegacyMemoryUtilityOperation::BitNot),
("BitSet", PpcLegacyMemoryUtilityOperation::BitSet),
("Fix2X", PpcLegacyMemoryUtilityOperation::FixToExtended),
("GetMyZone", PpcLegacyMemoryUtilityOperation::GetMyZone),
("HandleZone", PpcLegacyMemoryUtilityOperation::HandleZone),
("LockMemory", PpcLegacyMemoryUtilityOperation::LockMemory),
("MaxBlock", PpcLegacyMemoryUtilityOperation::MaxBlock),
("PurgeSpace", PpcLegacyMemoryUtilityOperation::PurgeSpace),
("ReserveMem", PpcLegacyMemoryUtilityOperation::ReserveMem),
("SetGrowZone", PpcLegacyMemoryUtilityOperation::SetGrowZone),
("StackSpace", PpcLegacyMemoryUtilityOperation::StackSpace),
("TempFreeMem", PpcLegacyMemoryUtilityOperation::TempFreeMem),
("UnlockMemory", PpcLegacyMemoryUtilityOperation::UnlockMemory),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::LegacyMemoryUtility(operation),
"{symbol}"
);
}
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetPtrSize"),
PpcImportDispatcherTarget::SetPtrSize
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "RecoverHandle"),
PpcImportDispatcherTarget::RecoverHandle
);
}
#[test]
fn legacy_window_imports_pre_resolve_to_typed_operations() {
for (symbol, operation) in [
("BringToFront", PpcLegacyWindowOperation::BringToFront),
("CalcVis", PpcLegacyWindowOperation::CalculateVisibleRegion),
("DisposeWindow", PpcLegacyWindowOperation::DisposeWindow),
("DragWindow", PpcLegacyWindowOperation::DragWindow),
("GetNewWindow", PpcLegacyWindowOperation::GetNewWindow),
("GetWTitle", PpcLegacyWindowOperation::GetWindowTitle),
("GrowWindow", PpcLegacyWindowOperation::GrowWindow),
("HiliteWindow", PpcLegacyWindowOperation::HighlightWindow),
("NewWindow", PpcLegacyWindowOperation::NewWindow),
("SendBehind", PpcLegacyWindowOperation::SendBehind),
("SetWTitle", PpcLegacyWindowOperation::SetWindowTitle),
("TrackBox", PpcLegacyWindowOperation::TrackBox),
("TrackGoAway", PpcLegacyWindowOperation::TrackGoAway),
("ZoomWindow", PpcLegacyWindowOperation::ZoomWindow),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::LegacyWindow(operation),
);
}
}
#[test]
fn hle_import_runner_handles_legacy_bit_utilities() {
let mut set = load_pef_application(&synthetic_pef_with_import(b"BitSet")).unwrap();
let byte = PPC_HEAP_BASE;
set.memory.add_region(byte, vec![0; 2]);
set.cpu.gpr[3] = byte;
set.cpu.gpr[4] = 9;
let set_probe = set.run_with_hle_imports(64);
assert_eq!(set_probe.unsupported_import_index, None);
assert_eq!(set.memory.read_u8(byte + 1), Some(0x40));
let mut clear = load_pef_application(&synthetic_pef_with_import(b"BitClr")).unwrap();
clear.memory.add_region(byte, vec![0xff; 2]);
clear.cpu.gpr[3] = byte;
clear.cpu.gpr[4] = 9;
let clear_probe = clear.run_with_hle_imports(64);
assert_eq!(clear_probe.unsupported_import_index, None);
assert_eq!(clear.memory.read_u8(byte + 1), Some(0xbf));
let mut not = load_pef_application(&synthetic_pef_with_import(b"BitNot")).unwrap();
not.cpu.gpr[3] = 0x0f0f_55aa;
let not_probe = not.run_with_hle_imports(64);
assert_eq!(not_probe.unsupported_import_index, None);
assert_eq!(not.cpu.gpr[3], 0xf0f0_aa55);
}
#[test]
fn hle_import_runner_converts_fixed_to_extended_result_register() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"Fix2X")).unwrap();
loaded.cpu.gpr[3] = (-98_304i32) as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(f64::from_bits(loaded.cpu.fpr[1]), -1.5);
}
#[test]
fn reserve_mem_reports_whether_a_contiguous_block_is_available() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"ReserveMem")).unwrap();
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = u32::MAX;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.last_mem_error(), PPC_MEM_FULL_ERR);
}
#[test]
fn set_ptr_size_grows_only_a_terminal_nonrelocatable_block() {
let mut memory = PpcSectionMem::new();
let heap_limit = PPC_HEAP_BASE + 0x1000;
memory.add_region(PPC_HEAP_BASE, vec![0; 0x1000]);
let mut manager = ProcessMemoryManager::default();
manager.publish_native_allocator(
ProcessNativeHeapState {
heap_base: PPC_HEAP_BASE,
heap_cursor: PPC_HEAP_BASE,
heap_limit,
last_mem_error: PPC_NO_ERR,
heap_maximized: false,
master_pointer_blocks_requested: 0,
},
&[],
&[],
&[],
);
let ptr = manager.new_native_ptr(&mut memory, 8, true);
assert_ne!(ptr, 0);
assert_eq!(
manager.set_native_ptr_size(&mut memory, ptr, 24),
PPC_NO_ERR
);
assert_eq!(manager.native_ptr_size(ptr), 24);
assert_eq!(memory.read_u8(ptr + 23), Some(0));
let second = manager.new_native_ptr(&mut memory, 8, true);
assert_ne!(second, 0);
assert_eq!(
manager.set_native_ptr_size(&mut memory, ptr, 32),
PPC_MEM_FULL_ERR
);
assert_eq!(manager.native_ptr_size(ptr), 24);
}
#[test]
fn hle_import_runner_creates_and_links_a_classic_control_record() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"NewControl")).unwrap();
let scratch = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
64,
true,
);
ppc_write_rect(&mut loaded.memory, scratch, 10, 20, 40, 140).unwrap();
write_ppc_pstring(&mut loaded.memory, scratch + 8, b"Launch");
let ref_con_slot =
ppc_parameter_area_slot_addr(loaded.cpu.gpr[1], PPC_NATIVE_PARAMETER_GPR_COUNT)
.unwrap();
loaded
.memory
.write_u32_be(ref_con_slot, 0x1234_5678)
.unwrap();
loaded.cpu.gpr[3] = PPC_MAIN_GWORLD;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 3;
loaded.cpu.gpr[8] = 1;
loaded.cpu.gpr[9] = 9;
loaded.cpu.gpr[10] = 16;
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.unsupported_import_index, None);
let handle = loaded.cpu.gpr[3];
let control = loaded.memory.read_u32_be(handle).unwrap();
assert_ne!(handle, 0);
assert_eq!(
loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CWINDOW_CONTROL_LIST_OFFSET),
Some(handle)
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, control + PPC_CONTROL_RECT_OFFSET),
Some((10, 20, 40, 140))
);
assert_eq!(
loaded
.memory
.read_u32_be(control + PPC_CONTROL_OWNER_OFFSET),
Some(PPC_MAIN_GWORLD)
);
assert_eq!(
loaded
.memory
.read_u16_be(control + PPC_CONTROL_VALUE_OFFSET),
Some(3)
);
assert_eq!(
loaded.memory.read_u16_be(control + PPC_CONTROL_MIN_OFFSET),
Some(1)
);
assert_eq!(
loaded.memory.read_u16_be(control + PPC_CONTROL_MAX_OFFSET),
Some(9)
);
assert_eq!(
loaded
.memory
.read_u32_be(control + PPC_CONTROL_REF_CON_OFFSET),
Some(0x1234_5678)
);
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, control + PPC_CONTROL_TITLE_OFFSET),
Some(b"Launch".to_vec())
);
assert_eq!(
loaded.controls.records(),
vec![PpcControlRecord {
handle,
pointer: control,
proc_id: 16,
popup_menu_id: 0,
popup_title_width: None,
}]
);
}
#[test]
fn popup_control_records_preserve_item_values_across_set_control_value() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"SetControlValue"))
.unwrap();
let mut last_mem_error = loaded.last_mem_error();
let handle = with_test_controls!(
loaded,
|controls| ppc_new_control_record_values(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
controls,
PPC_MAIN_GWORLD,
(10, 20, 30, 180),
b"Loadout",
true,
1,
143,
60,
1008,
0,
)
);
assert_ne!(handle, 0);
let control = loaded.memory.read_u32_be(handle).unwrap();
assert_eq!(
loaded
.memory
.read_u16_be(control + PPC_CONTROL_VALUE_OFFSET),
Some(1)
);
assert_eq!(
loaded
.controls
.records()
.into_iter()
.find(|record| record.handle == handle)
.map(|record| (record.popup_menu_id, record.popup_title_width)),
Some((143, Some(60)))
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = 4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded
.memory
.read_u16_be(control + PPC_CONTROL_VALUE_OFFSET),
Some(4)
);
}
#[test]
fn selected_checkbox_draws_indicator_and_checkmark_without_framing_title() {
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let handle = with_test_controls!(
loaded,
|controls| ppc_new_control_record_values(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
controls,
PPC_MAIN_GWORLD,
(10, 20, 30, 180),
b"Sound Effects",
true,
1,
0,
1,
1,
0,
)
);
assert_ne!(handle, 0);
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let white =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_WHITE).unwrap();
assert!(ppc_paint_rect_bounds(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
(0, 0, 40, 200),
PPC_RGB_WHITE,
None,
));
assert!(ppc_draw_control(
&mut loaded.memory,
&test_handle_records!(loaded),
&loaded.controls.records(),
&loaded.gworlds,
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
handle,
));
let front = surface.front_buffer;
let black =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (22, 20)),
Some(black)
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (179, 10)),
Some(white)
);
}
#[test]
fn selected_radio_button_draws_round_indicator_and_inner_dot() {
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let handle = with_test_controls!(
loaded,
|controls| ppc_new_control_record_values(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
controls,
PPC_MAIN_GWORLD,
(10, 20, 30, 180),
b"Veteran",
true,
1,
0,
1,
2,
0,
)
);
assert_ne!(handle, 0);
assert!(ppc_paint_rect_bounds(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
(0, 0, 40, 200),
PPC_RGB_WHITE,
None,
));
assert!(ppc_draw_control(
&mut loaded.memory,
&test_handle_records!(loaded),
&loaded.controls.records(),
&loaded.gworlds,
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
handle,
));
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let black =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK).unwrap();
let white =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_WHITE).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (27, 14)),
Some(black),
"the outer radio indicator should be round"
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (22, 14)),
Some(white),
"the indicator corner must remain outside the round outline"
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (27, 19)),
Some(black),
"contrlValue 1 should draw the inner selection dot"
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (179, 10)),
Some(white),
"radioButProc must not frame the full control rectangle"
);
}
#[test]
fn draw_controls_redraws_visible_controls_in_a_document_window() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"DrawControls")).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let handle = with_test_controls!(
loaded,
|controls| ppc_new_control_record_values(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
controls,
PPC_MAIN_GWORLD,
(10, 20, 30, 100),
b"Redraw",
true,
0,
0,
1,
0,
0,
)
);
assert_ne!(handle, 0);
assert!(ppc_paint_rect_bounds(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
(0, 0, 40, 120),
PPC_RGB_WHITE,
None,
));
loaded.cpu.gpr[3] = PPC_MAIN_GWORLD;
loaded.run_with_hle_imports(64);
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let black =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (60, 10)),
Some(black)
);
}
#[test]
fn classic_control_hit_testing_and_disposal_follow_the_window_list() {
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
32,
true,
);
ppc_write_rect(&mut loaded.memory, scratch, 5, 6, 25, 86).unwrap();
write_ppc_pstring(&mut loaded.memory, scratch + 8, b"OK");
let handle = with_test_controls!(
loaded,
|controls| ppc_new_control_values(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
controls,
PPC_MAIN_GWORLD,
scratch,
scratch + 8,
true,
0,
0,
1,
0,
0,
)
);
assert_ne!(handle, 0);
assert_eq!(
ppc_find_control_at_point(
&mut loaded.memory,
&loaded.controls.records(),
PPC_MAIN_GWORLD,
10,
10,
),
Some((handle, 10))
);
with_test_controls!(
loaded,
|controls| ppc_dispose_control(
None,
Some(&mut free_handle_blocks),
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
controls,
handle,
)
);
assert_eq!(loaded.memory.read_u32_be(handle), Some(0));
assert_eq!(
loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CWINDOW_CONTROL_LIST_OFFSET),
Some(0)
);
assert!(loaded.controls.is_empty());
}
#[test]
fn hle_import_runner_test_control_returns_the_hit_part() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"TestControl")).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let scratch = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
32,
true,
);
ppc_write_rect(&mut loaded.memory, scratch, 5, 6, 25, 86).unwrap();
write_ppc_pstring(&mut loaded.memory, scratch + 8, b"OK");
let handle = with_test_controls!(
loaded,
|controls| ppc_new_control_values(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
controls,
PPC_MAIN_GWORLD,
scratch,
scratch + 8,
true,
0,
0,
1,
0,
0,
)
);
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = (10 << 16) | 10;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 10);
}
#[test]
fn popup_track_control_requires_a_visible_enabled_hit_and_cdef_action() {
for (label, visible, hilite, point, requested, stored, opens) in [
("outside", true, 0, (0i16, 0i16), u32::MAX, u32::MAX, false),
("hidden", false, 0, (10, 10), u32::MAX, u32::MAX, false),
("inactive", true, 0xff, (10, 10), u32::MAX, u32::MAX, false),
("nil action", true, 0, (10, 10), 0, u32::MAX, false),
("nil stored action", true, 0, (10, 10), u32::MAX, 0, false),
("CDEF action", true, 0, (10, 10), u32::MAX, u32::MAX, true),
] {
let mut loaded =
load_pef_application(&synthetic_pef_with_import(b"TrackControl")).unwrap();
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
304,
b"Popup",
b"One;Two",
);
let mut last_mem_error = loaded.last_mem_error();
let scratch = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
32,
true,
);
ppc_write_rect(&mut loaded.memory, scratch, 5, 6, 25, 86).unwrap();
write_ppc_pstring(&mut loaded.memory, scratch + 8, b"Popup:");
let control_handle = with_test_controls!(
loaded,
|controls| ppc_new_control_values(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
controls,
PPC_MAIN_GWORLD,
scratch,
scratch + 8,
visible,
1,
304,
52,
1008,
0,
)
);
assert_ne!(control_handle, 0, "{label} control allocation");
let control = ppc_control_ptr(&mut loaded.memory, control_handle).unwrap();
loaded
.memory
.write_u8(control + PPC_CONTROL_HILITE_OFFSET, hilite)
.unwrap();
loaded.cpu.gpr[3] = control_handle;
loaded.cpu.gpr[4] = (u32::from(point.0 as u16) << 16) | u32::from(point.1 as u16);
assert_eq!(loaded.memory.read_u32_be(control + 32), Some(u32::MAX));
loaded.memory.write_u32_be(control + 32, stored).unwrap();
loaded.cpu.gpr[5] = requested;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: point.0,
mouse_h: point.1,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
if opens {
assert!(loaded.toolbox_startup.execution.menu().is_some(), "{label}");
assert!(
loaded
.toolbox_startup
.execution.menu()
.context()
.native_popup()
.is_some(),
"{label}"
);
continue;
}
assert!(
matches!(probe.result, PpcRunResult::Halted { .. }),
"{label}"
);
assert_eq!(
loaded.cpu.gpr[3],
if visible && hilite == 0 && point == (10, 10) {
10
} else {
0
},
"{label} TrackControl result",
);
assert!(loaded.toolbox_startup.execution.menu().is_none(), "{label}");
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_popup(),
None,
"{label}"
);
assert_eq!(
loaded
.memory
.read_u16_be(control + PPC_CONTROL_VALUE_OFFSET),
Some(1),
"{label} TrackControl must not mutate the value"
);
assert_ne!(menu_handle, 0);
}
}
#[test]
fn hle_import_runner_creates_window_title_and_zoom_state() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"NewWindow")).unwrap();
let scratch = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
64,
true,
);
ppc_write_rect(&mut loaded.memory, scratch, 40, 50, 240, 350).unwrap();
write_ppc_pstring(&mut loaded.memory, scratch + 8, b"Document");
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0x4455_6677;
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.unsupported_import_index, None);
let window = loaded.cpu.gpr[3];
assert_ne!(window, 0);
let title_handle = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_TITLE_HANDLE_OFFSET)
.unwrap();
let title = loaded.memory.read_u32_be(title_handle).unwrap();
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, title),
Some(b"Document".to_vec())
);
let state_handle = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_STATE_HANDLE_OFFSET)
.unwrap();
let state = loaded.memory.read_u32_be(state_handle).unwrap();
assert_eq!(
ppc_read_rect(&mut loaded.memory, state),
Some((40, 50, 240, 350))
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, state + 8),
Some((
20,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
))
);
let mut zoom_cpu = loaded.cpu.clone();
zoom_cpu.gpr[3] = window;
zoom_cpu.gpr[4] = 8;
let _ = ppc_zoom_window(&zoom_cpu, &mut loaded.memory, &mut loaded.gworlds);
assert_eq!(
ppc_dialog_global_bounds(&mut loaded.memory, &loaded.gworlds, window),
Some((
20,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
))
);
}
#[test]
fn window_resource_parameters_preserve_compiled_bounds_and_title() {
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let mut wind = Vec::new();
wind.extend_from_slice(&10i16.to_be_bytes());
wind.extend_from_slice(&20i16.to_be_bytes());
wind.extend_from_slice(&210i16.to_be_bytes());
wind.extend_from_slice(&420i16.to_be_bytes());
wind.extend_from_slice(&0u16.to_be_bytes());
wind.extend_from_slice(&1u16.to_be_bytes());
wind.extend_from_slice(&1u16.to_be_bytes());
wind.extend_from_slice(&0x1234_5678u32.to_be_bytes());
wind.push(4);
wind.extend_from_slice(b"Game");
let (bounds, title) = ppc_materialize_window_resource_parameters(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&wind,
)
.unwrap();
assert_eq!(
ppc_read_rect(&mut loaded.memory, bounds),
Some((10, 20, 210, 420))
);
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, title),
Some(b"Game".to_vec())
);
}
#[test]
fn import_bindings_classify_supported_memory_manager_imports() {
let bindings = PpcImportBindingPlan::prepare(
vec![
PefResolvedImport {
library_index: 0,
symbol_index: 0,
library_name: "InterfaceLib".to_string(),
symbol_name: "NewPtrClear".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 1,
library_name: "InterfaceLib".to_string(),
symbol_name: "DisposePtr".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 2,
library_name: "InterfaceLib".to_string(),
symbol_name: "MaxApplZone".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 3,
library_name: "InterfaceLib".to_string(),
symbol_name: "MoreMasters".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 4,
library_name: "InterfaceLib".to_string(),
symbol_name: "CompactMem".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 5,
library_name: "InterfaceLib".to_string(),
symbol_name: "MaxMem".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 6,
library_name: "InterfaceLib".to_string(),
symbol_name: "CurResFile".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 7,
library_name: "InterfaceLib".to_string(),
symbol_name: "ResError".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 8,
library_name: "InterfaceLib".to_string(),
symbol_name: "Gestalt".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 9,
library_name: "InterfaceLib".to_string(),
symbol_name: "GetSharedLibrary".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 10,
library_name: "InterfaceLib".to_string(),
symbol_name: "FindFolder".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 11,
library_name: "InterfaceLib".to_string(),
symbol_name: "DirCreate".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 12,
library_name: "InterfaceLib".to_string(),
symbol_name: "FSMakeFSSpec".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 13,
library_name: "InterfaceLib".to_string(),
symbol_name: "SndSoundManagerVersion".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 14,
library_name: "InterfaceLib".to_string(),
symbol_name: "ParamText".to_string(),
class: 2,
weak: false,
},
PefResolvedImport {
library_index: 0,
symbol_index: 15,
library_name: "InterfaceLib".to_string(),
symbol_name: "NoteAlert".to_string(),
class: 2,
weak: false,
},
],
16,
0,
ppc_import_layout(),
&SystemlessPpcImportBindingPolicy,
)
.unwrap()
.into_initial_bindings();
assert_eq!(
bindings[0].dispatcher_target,
PpcImportDispatcherTarget::NewPtr { clear: true }
);
assert_eq!(
bindings[1].dispatcher_target,
PpcImportDispatcherTarget::DisposePtr
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetPtrSize"),
PpcImportDispatcherTarget::GetPtrSize
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NewHandle"),
PpcImportDispatcherTarget::NewHandle { clear: false }
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NewHandleClear"),
PpcImportDispatcherTarget::NewHandle { clear: true }
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "TempNewHandle"),
PpcImportDispatcherTarget::TempNewHandle
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "BlockMove"),
PpcImportDispatcherTarget::BlockMove
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PtrToHand"),
PpcImportDispatcherTarget::PtrToHand
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DisposeHandle"),
PpcImportDispatcherTarget::DisposeHandle
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "EmptyHandle"),
PpcImportDispatcherTarget::EmptyHandle
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ReleaseResource"),
PpcImportDispatcherTarget::ReleaseResource
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DetachResource"),
PpcImportDispatcherTarget::DetachResource
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetHandleSize"),
PpcImportDispatcherTarget::GetHandleSize
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetHandleSize"),
PpcImportDispatcherTarget::SetHandleSize
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PurgeMem"),
PpcImportDispatcherTarget::PurgeMem
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PurgeMemSys"),
PpcImportDispatcherTarget::PurgeMemSys
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "MemError"),
PpcImportDispatcherTarget::MemError
);
assert_eq!(
bindings[2].dispatcher_target,
PpcImportDispatcherTarget::MaxApplZone
);
assert_eq!(
bindings[3].dispatcher_target,
PpcImportDispatcherTarget::MoreMasters
);
assert_eq!(
bindings[4].dispatcher_target,
PpcImportDispatcherTarget::HeapFreeBytes
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FreeMem"),
PpcImportDispatcherTarget::HeapFreeBytes
);
assert_eq!(
bindings[5].dispatcher_target,
PpcImportDispatcherTarget::MaxMem
);
assert_eq!(
bindings[6].dispatcher_target,
PpcImportDispatcherTarget::CurResFile
);
assert_eq!(
bindings[7].dispatcher_target,
PpcImportDispatcherTarget::ResError
);
assert_eq!(
bindings[8].dispatcher_target,
PpcImportDispatcherTarget::Gestalt
);
assert_eq!(
bindings[9].dispatcher_target,
PpcImportDispatcherTarget::GetSharedLibrary
);
assert_eq!(
bindings[10].dispatcher_target,
PpcImportDispatcherTarget::FindFolder
);
assert_eq!(
bindings[11].dispatcher_target,
PpcImportDispatcherTarget::DirCreate
);
assert_eq!(
bindings[12].dispatcher_target,
PpcImportDispatcherTarget::FSMakeFSSpec
);
assert_eq!(
bindings[13].dispatcher_target,
PpcImportDispatcherTarget::SndSoundManagerVersion
);
assert_eq!(
bindings[14].dispatcher_target,
PpcImportDispatcherTarget::ParamText
);
assert_eq!(
bindings[15].dispatcher_target,
PpcImportDispatcherTarget::AlertReturnDefault
);
}
#[test]
fn import_bindings_reject_symbol_indexes_outside_import_table() {
let error = PpcImportBindingPlan::prepare(
vec![PefResolvedImport {
library_index: 0,
symbol_index: 3,
library_name: "InterfaceLib".to_string(),
symbol_name: "BadImport".to_string(),
class: 2,
weak: false,
}],
1,
0,
ppc_import_layout(),
&SystemlessPpcImportBindingPolicy,
)
.map_err(ppc_initial_import_error)
.unwrap_err();
assert_eq!(
error,
PpcLoadError::ImportBindingOutOfRange {
symbol_index: 3,
import_count: 1,
}
);
}
#[test]
fn initial_import_plan_preserves_reachable_loader_errors() {
let result = load_pef_application(&synthetic_pef_with_loader(
synthetic_loader_with_repeated_imports(PPC_IMPORT_CAPACITY + 1),
));
let error = match result {
Ok(_) => panic!("over-capacity launch unexpectedly returned an app"),
Err(error) => error,
};
assert_eq!(
error,
PpcLoadError::ImportCapacityExceeded {
import_count: PPC_IMPORT_CAPACITY + 1,
capacity: PPC_IMPORT_CAPACITY,
}
);
}
#[test]
fn overlapping_library_ranges_preserve_duplicate_import_projection() {
let pef = synthetic_pef_with_loader_and_data(
synthetic_loader_with_overlapping_library_ranges(),
&[0; 8],
);
let resolved = resolve_pef_imports(&pef).unwrap();
assert_eq!(resolved.len(), 2);
assert_eq!(resolved[0].symbol_index, 0);
assert_eq!(resolved[1].symbol_index, 0);
assert_ne!(resolved[0].library_name, resolved[1].library_name);
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(loaded.imports.len(), 2);
let first = loaded.import_binding(0).unwrap();
assert_eq!(first.library_name, "InterfaceLib");
assert_eq!(first.address, PPC_IMPORT_TVECTOR_BASE);
assert_eq!(loaded.imports[1].address, PPC_IMPORT_STD_ERRNO);
assert_eq!(
loaded.memory.read_u32_be(PPC_DATA_BASE),
Some(PPC_IMPORT_STD_ERRNO)
);
}
#[test]
fn import_binding_error_maps_preserve_loader_and_fragment_results() {
assert_eq!(
ppc_initial_import_error(PpcImportBindingError::SymbolIndexOutOfRange {
symbol_index: 3,
import_count: 1,
}),
PpcLoadError::ImportBindingOutOfRange {
symbol_index: 3,
import_count: 1,
}
);
assert_eq!(
ppc_initial_import_error(PpcImportBindingError::CapacityExceeded {
import_count: 9,
capacity: 8,
}),
PpcLoadError::ImportCapacityExceeded {
import_count: 9,
capacity: 8,
}
);
for error in [
PpcImportBindingError::CountOverflow,
PpcImportBindingError::BindingAddressOverflow,
PpcImportBindingError::AddressTableOutOfRange,
] {
assert_eq!(ppc_initial_import_error(error), PpcLoadError::AddressOverflow);
}
for (error, expected) in [
(PpcImportBindingError::CountOverflow, PPC_FRAG_NO_MEM),
(
PpcImportBindingError::CapacityExceeded {
import_count: 9,
capacity: 8,
},
PPC_FRAG_NO_MEM,
),
(PpcImportBindingError::AddressTableOutOfRange, PPC_FRAG_NO_MEM),
(
PpcImportBindingError::SymbolIndexOutOfRange {
symbol_index: 3,
import_count: 1,
},
PPC_FRAG_CORRUPT_ERR,
),
(
PpcImportBindingError::BindingAddressOverflow,
PPC_FRAG_CORRUPT_ERR,
),
(PpcImportBindingError::RegistryChanged, PPC_FRAG_CORRUPT_ERR),
] {
assert_eq!(ppc_dynamic_import_error(error), expected);
}
}
#[test]
fn import_bindings_classify_quickdraw_3d_initializer() {
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Initialize"),
PpcImportDispatcherTarget::Q3Initialize
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Exit"),
PpcImportDispatcherTarget::Q3Exit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MemoryStorage_New"),
PpcImportDispatcherTarget::Q3MemoryStorageNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MemoryStorage_NewBuffer"),
PpcImportDispatcherTarget::Q3MemoryStorageNewBuffer
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3FSSpecStorage_New"),
PpcImportDispatcherTarget::Q3FSSpecStorageNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3File_New"),
PpcImportDispatcherTarget::Q3FileNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_New"),
PpcImportDispatcherTarget::Q3ViewNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3DisplayGroup_New"),
PpcImportDispatcherTarget::Q3DisplayGroupNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MipmapTexture_New"),
PpcImportDispatcherTarget::Q3MipmapTextureNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3TextureShader_New"),
PpcImportDispatcherTarget::Q3TextureShaderNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3LambertIllumination_New"),
PpcImportDispatcherTarget::Q3LambertIlluminationNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3NULLIllumination_New"),
PpcImportDispatcherTarget::Q3NullIlluminationNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3PhongIllumination_New"),
PpcImportDispatcherTarget::Q3PhongIlluminationNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Renderer_NewFromType"),
PpcImportDispatcherTarget::Q3RendererNewFromType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Renderer_GetType"),
PpcImportDispatcherTarget::Q3RendererGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Renderer_Sync"),
PpcImportDispatcherTarget::Q3RendererSync
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Renderer_Flush"),
PpcImportDispatcherTarget::Q3RendererFlush
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3InteractiveRenderer_SetDoubleBufferBypass"
),
PpcImportDispatcherTarget::Q3InteractiveRendererSetDoubleBufferBypass
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3InteractiveRenderer_SetPreferences"
),
PpcImportDispatcherTarget::Q3InteractiveRendererSetPreferences
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3InteractiveRenderer_SetRAVEContextHints"
),
PpcImportDispatcherTarget::Q3InteractiveRendererSetRaveContextHints
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3InteractiveRenderer_GetRAVEContextHints"
),
PpcImportDispatcherTarget::Q3InteractiveRendererGetRaveContextHints
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3InteractiveRenderer_GetRAVEDrawContexts"
),
PpcImportDispatcherTarget::Q3InteractiveRendererGetRaveDrawContexts
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3InteractiveRenderer_SetRAVETextureFilter"
),
PpcImportDispatcherTarget::Q3InteractiveRendererSetRaveTextureFilter
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3PixmapDrawContext_New"),
PpcImportDispatcherTarget::Q3PixmapDrawContextNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MacDrawContext_New"),
PpcImportDispatcherTarget::Q3MacDrawContextNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3ViewAngleAspectCamera_New"),
PpcImportDispatcherTarget::Q3ViewAngleAspectCameraNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3OrthographicCamera_New"),
PpcImportDispatcherTarget::Q3OrthographicCameraNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3ViewPlaneCamera_New"),
PpcImportDispatcherTarget::Q3ViewPlaneCameraNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3BackfacingStyle_New"),
PpcImportDispatcherTarget::Q3BackfacingStyleNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3InterpolationStyle_New"),
PpcImportDispatcherTarget::Q3InterpolationStyleNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3FillStyle_New"),
PpcImportDispatcherTarget::Q3FillStyleNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3OrientationStyle_New"),
PpcImportDispatcherTarget::Q3OrientationStyleNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Object_Dispose"),
PpcImportDispatcherTarget::Q3ObjectDispose
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Object_Duplicate"),
PpcImportDispatcherTarget::Q3ObjectDuplicate
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shared_GetReference"),
PpcImportDispatcherTarget::Q3SharedGetReference
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shared_IsReferenced"),
PpcImportDispatcherTarget::Q3SharedIsReferenced
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shared_GetType"),
PpcImportDispatcherTarget::Q3SharedGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shape_GetType"),
PpcImportDispatcherTarget::Q3ShapeGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shape_GetLeafType"),
PpcImportDispatcherTarget::Q3ShapeGetLeafType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Error_Get"),
PpcImportDispatcherTarget::Q3ErrorGet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Object_IsDrawable"),
PpcImportDispatcherTarget::Q3ObjectIsDrawable
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Object_IsType"),
PpcImportDispatcherTarget::Q3ObjectIsType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Object_GetType"),
PpcImportDispatcherTarget::Q3ObjectGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Object_GetLeafType"),
PpcImportDispatcherTarget::Q3ObjectGetLeafType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Geometry_GetType"),
PpcImportDispatcherTarget::Q3GeometryGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shader_GetType"),
PpcImportDispatcherTarget::Q3ShaderGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Group_GetType"),
PpcImportDispatcherTarget::Q3GroupGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3TextureShader_GetTexture"),
PpcImportDispatcherTarget::Q3TextureShaderGetTexture
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MipmapTexture_GetMipmap"),
PpcImportDispatcherTarget::Q3MipmapTextureGetMipmap
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Storage_GetType"),
PpcImportDispatcherTarget::Q3StorageGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3DrawContext_GetPane"),
PpcImportDispatcherTarget::Q3DrawContextGetPane
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MemoryStorage_Set"),
PpcImportDispatcherTarget::Q3MemoryStorageSet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MemoryStorage_GetBuffer"),
PpcImportDispatcherTarget::Q3MemoryStorageGetBuffer
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MemoryStorage_SetBuffer"),
PpcImportDispatcherTarget::Q3MemoryStorageSetBuffer
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MemoryStorage_GetType"),
PpcImportDispatcherTarget::Q3MemoryStorageGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Camera_GetPlacement"),
PpcImportDispatcherTarget::Q3CameraGetPlacement
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Camera_SetPlacement"),
PpcImportDispatcherTarget::Q3CameraSetPlacement
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Camera_GetRange"),
PpcImportDispatcherTarget::Q3CameraGetRange
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Camera_SetRange"),
PpcImportDispatcherTarget::Q3CameraSetRange
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Camera_GetViewPort"),
PpcImportDispatcherTarget::Q3CameraGetViewPort
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Camera_SetViewPort"),
PpcImportDispatcherTarget::Q3CameraSetViewPort
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Camera_GetWorldToView"),
PpcImportDispatcherTarget::Q3CameraGetWorldToView
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Camera_GetViewToFrustum"),
PpcImportDispatcherTarget::Q3CameraGetViewToFrustum
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Light_GetType"),
PpcImportDispatcherTarget::Q3LightGetType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Light_GetState"),
PpcImportDispatcherTarget::Q3LightGetState
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Light_SetState"),
PpcImportDispatcherTarget::Q3LightSetState
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Light_GetBrightness"),
PpcImportDispatcherTarget::Q3LightGetBrightness
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Light_SetBrightness"),
PpcImportDispatcherTarget::Q3LightSetBrightness
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Light_GetColor"),
PpcImportDispatcherTarget::Q3LightGetColor
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Light_SetColor"),
PpcImportDispatcherTarget::Q3LightSetColor
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Light_GetData"),
PpcImportDispatcherTarget::Q3LightGetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Light_SetData"),
PpcImportDispatcherTarget::Q3LightSetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3AmbientLight_New"),
PpcImportDispatcherTarget::Q3AmbientLightNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3AmbientLight_GetData"),
PpcImportDispatcherTarget::Q3AmbientLightGetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3AmbientLight_SetData"),
PpcImportDispatcherTarget::Q3AmbientLightSetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3DirectionalLight_New"),
PpcImportDispatcherTarget::Q3DirectionalLightNew
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3DirectionalLight_GetCastShadowsState"
),
PpcImportDispatcherTarget::Q3DirectionalLightGetCastShadowsState
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3DirectionalLight_SetCastShadowsState"
),
PpcImportDispatcherTarget::Q3DirectionalLightSetCastShadowsState
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3DirectionalLight_GetDirection"),
PpcImportDispatcherTarget::Q3DirectionalLightGetDirection
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3DirectionalLight_SetDirection"),
PpcImportDispatcherTarget::Q3DirectionalLightSetDirection
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3DirectionalLight_GetData"),
PpcImportDispatcherTarget::Q3DirectionalLightGetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3DirectionalLight_SetData"),
PpcImportDispatcherTarget::Q3DirectionalLightSetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3PointLight_New"),
PpcImportDispatcherTarget::Q3PointLightNew
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3PointLight_GetCastShadowsState"
),
PpcImportDispatcherTarget::Q3PointLightGetCastShadowsState
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3PointLight_SetCastShadowsState"
),
PpcImportDispatcherTarget::Q3PointLightSetCastShadowsState
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3PointLight_GetAttenuation"),
PpcImportDispatcherTarget::Q3PointLightGetAttenuation
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3PointLight_SetAttenuation"),
PpcImportDispatcherTarget::Q3PointLightSetAttenuation
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3PointLight_GetLocation"),
PpcImportDispatcherTarget::Q3PointLightGetLocation
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3PointLight_SetLocation"),
PpcImportDispatcherTarget::Q3PointLightSetLocation
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3PointLight_GetData"),
PpcImportDispatcherTarget::Q3PointLightGetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3PointLight_SetData"),
PpcImportDispatcherTarget::Q3PointLightSetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_New"),
PpcImportDispatcherTarget::Q3SpotLightNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_GetCastShadowsState"),
PpcImportDispatcherTarget::Q3SpotLightGetCastShadowsState
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_SetCastShadowsState"),
PpcImportDispatcherTarget::Q3SpotLightSetCastShadowsState
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_GetAttenuation"),
PpcImportDispatcherTarget::Q3SpotLightGetAttenuation
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_SetAttenuation"),
PpcImportDispatcherTarget::Q3SpotLightSetAttenuation
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_GetLocation"),
PpcImportDispatcherTarget::Q3SpotLightGetLocation
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_SetLocation"),
PpcImportDispatcherTarget::Q3SpotLightSetLocation
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_GetDirection"),
PpcImportDispatcherTarget::Q3SpotLightGetDirection
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_SetDirection"),
PpcImportDispatcherTarget::Q3SpotLightSetDirection
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_GetHotAngle"),
PpcImportDispatcherTarget::Q3SpotLightGetHotAngle
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_SetHotAngle"),
PpcImportDispatcherTarget::Q3SpotLightSetHotAngle
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_GetOuterAngle"),
PpcImportDispatcherTarget::Q3SpotLightGetOuterAngle
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_SetOuterAngle"),
PpcImportDispatcherTarget::Q3SpotLightSetOuterAngle
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_GetFallOff"),
PpcImportDispatcherTarget::Q3SpotLightGetFallOff
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_SetFallOff"),
PpcImportDispatcherTarget::Q3SpotLightSetFallOff
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_GetData"),
PpcImportDispatcherTarget::Q3SpotLightGetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3SpotLight_SetData"),
PpcImportDispatcherTarget::Q3SpotLightSetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3LightGroup_New"),
PpcImportDispatcherTarget::Q3LightGroupNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3BackfacingStyle_Get"),
PpcImportDispatcherTarget::Q3BackfacingStyleGet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3BackfacingStyle_Set"),
PpcImportDispatcherTarget::Q3BackfacingStyleSet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3InterpolationStyle_Get"),
PpcImportDispatcherTarget::Q3InterpolationStyleGet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3InterpolationStyle_Set"),
PpcImportDispatcherTarget::Q3InterpolationStyleSet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3FillStyle_Get"),
PpcImportDispatcherTarget::Q3FillStyleGet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3FillStyle_Set"),
PpcImportDispatcherTarget::Q3FillStyleSet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3OrientationStyle_Get"),
PpcImportDispatcherTarget::Q3OrientationStyleGet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3OrientationStyle_Set"),
PpcImportDispatcherTarget::Q3OrientationStyleSet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Storage_GetSize"),
PpcImportDispatcherTarget::Q3StorageGetSize
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Storage_GetData"),
PpcImportDispatcherTarget::Q3StorageGetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Storage_SetData"),
PpcImportDispatcherTarget::Q3StorageSetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3TriMesh_New"),
PpcImportDispatcherTarget::Q3TriMeshNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3TriMesh_GetData"),
PpcImportDispatcherTarget::Q3TriMeshGetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3TriMesh_SetData"),
PpcImportDispatcherTarget::Q3TriMeshSetData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3TriMesh_EmptyData"),
PpcImportDispatcherTarget::Q3TriMeshEmptyData
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3AttributeSet_New"),
PpcImportDispatcherTarget::Q3AttributeSetNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3AttributeSet_Get"),
PpcImportDispatcherTarget::Q3AttributeSetGet
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D",
"Q3AttributeSet_GetNextAttributeType"
),
PpcImportDispatcherTarget::Q3AttributeSetGetNextAttributeType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Vector3D_Normalize"),
PpcImportDispatcherTarget::Q3Vector3DNormalize
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Vector2D_Normalize"),
PpcImportDispatcherTarget::Q3Vector2DNormalize
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Vector3D_Cross"),
PpcImportDispatcherTarget::Q3Vector3DCross
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Point2D_Distance"),
PpcImportDispatcherTarget::Q3Point2DDistance
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Point3D_Distance"),
PpcImportDispatcherTarget::Q3Point3DDistance
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Point3D_CrossProductTri"),
PpcImportDispatcherTarget::Q3Point3DCrossProductTri
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix3x3_SetTranslate"),
PpcImportDispatcherTarget::Q3Matrix3x3SetTranslate
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_SetIdentity"),
PpcImportDispatcherTarget::Q3Matrix4x4SetIdentity
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_SetTranslate"),
PpcImportDispatcherTarget::Q3Matrix4x4SetTranslate
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_SetScale"),
PpcImportDispatcherTarget::Q3Matrix4x4SetScale
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_SetRotate_X"),
PpcImportDispatcherTarget::Q3Matrix4x4SetRotateX
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_SetRotate_Y"),
PpcImportDispatcherTarget::Q3Matrix4x4SetRotateY
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_SetRotate_Z"),
PpcImportDispatcherTarget::Q3Matrix4x4SetRotateZ
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_SetRotate_XYZ"),
PpcImportDispatcherTarget::Q3Matrix4x4SetRotateXyz
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_Multiply"),
PpcImportDispatcherTarget::Q3Matrix4x4Multiply
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_Transpose"),
PpcImportDispatcherTarget::Q3Matrix4x4Transpose
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Matrix4x4_Invert"),
PpcImportDispatcherTarget::Q3Matrix4x4Invert
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Point3D_Transform"),
PpcImportDispatcherTarget::Q3Point3DTransform
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Point3D_To3DTransformArray"),
PpcImportDispatcherTarget::Q3Point3DTo3DTransformArray
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Point3D_To4DTransformArray"),
PpcImportDispatcherTarget::Q3Point3DTo4DTransformArray
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Vector3D_Transform"),
PpcImportDispatcherTarget::Q3Vector3DTransform
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MatrixTransform_New"),
PpcImportDispatcherTarget::Q3MatrixTransformNew
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MatrixTransform_Set"),
PpcImportDispatcherTarget::Q3MatrixTransformSet
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Transform_GetMatrix"),
PpcImportDispatcherTarget::Q3TransformGetMatrix
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shader_GetUVTransform"),
PpcImportDispatcherTarget::Q3ShaderGetUVTransform
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shader_SetUVTransform"),
PpcImportDispatcherTarget::Q3ShaderSetUVTransform
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shader_GetUBoundary"),
PpcImportDispatcherTarget::Q3ShaderGetUBoundary
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shader_SetUBoundary"),
PpcImportDispatcherTarget::Q3ShaderSetUBoundary
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shader_GetVBoundary"),
PpcImportDispatcherTarget::Q3ShaderGetVBoundary
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shader_SetVBoundary"),
PpcImportDispatcherTarget::Q3ShaderSetVBoundary
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3File_SetStorage"),
PpcImportDispatcherTarget::Q3FileSetStorage
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3File_OpenRead"),
PpcImportDispatcherTarget::Q3FileOpenRead
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3File_ReadObject"),
PpcImportDispatcherTarget::Q3FileReadObject
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3File_IsEndOfFile"),
PpcImportDispatcherTarget::Q3FileIsEndOfFile
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3File_Close"),
PpcImportDispatcherTarget::Q3FileClose
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Group_AddObject"),
PpcImportDispatcherTarget::Q3GroupAddObject
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Group_AddObjectBefore"),
PpcImportDispatcherTarget::Q3GroupAddObjectBefore
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Group_CountObjects"),
PpcImportDispatcherTarget::Q3GroupCountObjects
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Group_GetFirstPosition"),
PpcImportDispatcherTarget::Q3GroupGetFirstPosition
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Group_GetNextPosition"),
PpcImportDispatcherTarget::Q3GroupGetNextPosition
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Group_GetFirstPositionOfType"),
PpcImportDispatcherTarget::Q3GroupGetFirstPositionOfType
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Group_GetPositionObject"),
PpcImportDispatcherTarget::Q3GroupGetPositionObject
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Group_RemovePosition"),
PpcImportDispatcherTarget::Q3GroupRemovePosition
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3AttributeSet_Add"),
PpcImportDispatcherTarget::Q3AttributeSetAdd
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3AttributeSet_Clear"),
PpcImportDispatcherTarget::Q3AttributeSetClear
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3AttributeSet_Contains"),
PpcImportDispatcherTarget::Q3AttributeSetContains
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_SetCamera"),
PpcImportDispatcherTarget::Q3ViewSetCamera
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_GetCamera"),
PpcImportDispatcherTarget::Q3ViewGetCamera
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_SetRenderer"),
PpcImportDispatcherTarget::Q3ViewSetRenderer
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_GetRenderer"),
PpcImportDispatcherTarget::Q3ViewGetRenderer
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_SetLightGroup"),
PpcImportDispatcherTarget::Q3ViewSetLightGroup
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_GetLightGroup"),
PpcImportDispatcherTarget::Q3ViewGetLightGroup
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_SetDrawContext"),
PpcImportDispatcherTarget::Q3ViewSetDrawContext
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_GetDrawContext"),
PpcImportDispatcherTarget::Q3ViewGetDrawContext
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_StartRendering"),
PpcImportDispatcherTarget::Q3ViewStartRendering
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3View_Cancel"),
PpcImportDispatcherTarget::Q3ViewCancel
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Shader_Submit"),
PpcImportDispatcherTarget::Q3ShaderSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Style_Submit"),
PpcImportDispatcherTarget::Q3StyleSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3BackfacingStyle_Submit"),
PpcImportDispatcherTarget::Q3BackfacingStyleSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3InterpolationStyle_Submit"),
PpcImportDispatcherTarget::Q3InterpolationStyleSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3FillStyle_Submit"),
PpcImportDispatcherTarget::Q3FillStyleSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3OrientationStyle_Submit"),
PpcImportDispatcherTarget::Q3OrientationStyleSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3FogStyle_Submit"),
PpcImportDispatcherTarget::Q3FogStyleSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3TriMesh_Submit"),
PpcImportDispatcherTarget::Q3TriMeshSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3MatrixTransform_Submit"),
PpcImportDispatcherTarget::Q3MatrixTransformSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3ResetTransform_Submit"),
PpcImportDispatcherTarget::Q3ResetTransformSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Push_Submit"),
PpcImportDispatcherTarget::Q3PushSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Pop_Submit"),
PpcImportDispatcherTarget::Q3PopSubmit
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Object_Submit"),
PpcImportDispatcherTarget::Q3ObjectSubmit
);
}
#[test]
fn import_bindings_reject_unknown_quickdraw_3d_imports() {
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D", "Q3Unmodeled_ReturnSuccess"),
PpcImportDispatcherTarget::Unsupported
);
}
#[test]
fn import_bindings_classify_quickdraw_3d_accelerator_imports() {
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D Accelerator",
"QADeviceGetFirstEngine"
),
PpcImportDispatcherTarget::QADeviceGetFirstEngine
);
assert_eq!(
dispatcher_target_for_import(
"QuickDraw\u{2122} 3D Accelerator",
"QADeviceGetNextEngine"
),
PpcImportDispatcherTarget::QADeviceGetNextEngine
);
assert_eq!(
dispatcher_target_for_import("QuickDraw\u{2122} 3D Accelerator", "QAEngineGestalt"),
PpcImportDispatcherTarget::QAEngineGestalt
);
}
#[test]
fn import_bindings_classify_mathlib_imports() {
assert_eq!(
dispatcher_target_for_import("MathLib", "ceil"),
PpcImportDispatcherTarget::MathCeil
);
assert_eq!(
dispatcher_target_for_import("MathLib", "sqrt"),
PpcImportDispatcherTarget::MathSqrt
);
assert_eq!(
dispatcher_target_for_import("MathLib", "exp"),
PpcImportDispatcherTarget::MathExp
);
assert_eq!(
dispatcher_target_for_import("MathLib", "sin"),
PpcImportDispatcherTarget::MathSin
);
assert_eq!(
dispatcher_target_for_import("MathLib", "cos"),
PpcImportDispatcherTarget::MathCos
);
assert_eq!(
dispatcher_target_for_import("MathLib", "atan2"),
PpcImportDispatcherTarget::MathAtan2
);
assert_eq!(
dispatcher_target_for_import("MathLib", "fmod"),
PpcImportDispatcherTarget::MathFmod
);
assert_eq!(
dispatcher_target_for_import("MathLib", "log10"),
PpcImportDispatcherTarget::MathLog10
);
assert_eq!(
dispatcher_target_for_import("MathLib", "dtox80"),
PpcImportDispatcherTarget::MathDtox80
);
}
#[test]
fn import_bindings_classify_picture_bootstrap_imports() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetPicture"),
PpcImportDispatcherTarget::GetPicture
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetPixPat"),
PpcImportDispatcherTarget::GetPixPat
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetPictInfo"),
PpcImportDispatcherTarget::GetPictInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DrawPicture"),
PpcImportDispatcherTarget::DrawPicture
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "KillPicture"),
PpcImportDispatcherTarget::KillPicture
);
}
#[test]
fn import_bindings_classify_gworld_state_imports() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetPort"),
PpcImportDispatcherTarget::GetPort
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetWMgrPort"),
PpcImportDispatcherTarget::GetWMgrPort
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetCWMgrPort"),
PpcImportDispatcherTarget::GetWMgrPort
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetPort"),
PpcImportDispatcherTarget::SetPort
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetGDevice"),
PpcImportDispatcherTarget::GetGDevice
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetGDevice"),
PpcImportDispatcherTarget::SetGDevice
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetDeviceList"),
PpcImportDispatcherTarget::GetDeviceList
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetNextDevice"),
PpcImportDispatcherTarget::GetNextDevice
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetMainDevice"),
PpcImportDispatcherTarget::GetMainDevice
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetMBarHeight"),
PpcImportDispatcherTarget::GetMBarHeight
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "TestDeviceAttribute"),
PpcImportDispatcherTarget::TestDeviceAttribute
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HasDepth"),
PpcImportDispatcherTarget::HasDepth
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetDepth"),
PpcImportDispatcherTarget::SetDepth
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DMGetGDeviceByDisplayID"),
PpcImportDispatcherTarget::DMGetGDeviceByDisplayID
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NewCWindow"),
PpcImportDispatcherTarget::NewCWindow
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetNewCWindow"),
PpcImportDispatcherTarget::GetNewCWindow
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetWRefCon"),
PpcImportDispatcherTarget::GetWRefCon
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetWRefCon"),
PpcImportDispatcherTarget::SetWRefCon
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SizeWindow"),
PpcImportDispatcherTarget::SizeWindow
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "MoveWindow"),
PpcImportDispatcherTarget::MoveWindow
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ShowWindow"),
PpcImportDispatcherTarget::ShowWindow
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HideWindow"),
PpcImportDispatcherTarget::HideWindow
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ShowHide"),
PpcImportDispatcherTarget::ShowHide
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "CloseWindow"),
PpcImportDispatcherTarget::CloseWindow
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SelectWindow"),
PpcImportDispatcherTarget::SelectWindow
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetWinColor"),
PpcImportDispatcherTarget::SetWinColor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "CalcVisBehind"),
PpcImportDispatcherTarget::CalcVisBehind
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PaintBehind"),
PpcImportDispatcherTarget::PaintBehind
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PaintOne"),
PpcImportDispatcherTarget::PaintOne
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ActivatePalette"),
PpcImportDispatcherTarget::ActivatePalette
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetPalette"),
PpcImportDispatcherTarget::NSetPalette
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NSetPalette"),
PpcImportDispatcherTarget::NSetPalette
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetPalette"),
PpcImportDispatcherTarget::GetPalette
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NewGWorld"),
PpcImportDispatcherTarget::NewGWorld
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DisposeGWorld"),
PpcImportDispatcherTarget::DisposeGWorld
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetGWorld"),
PpcImportDispatcherTarget::GetGWorld
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetGWorld"),
PpcImportDispatcherTarget::SetGWorld
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetGWorldDevice"),
PpcImportDispatcherTarget::GetGWorldDevice
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetGWorldPixMap"),
PpcImportDispatcherTarget::GetGWorldPixMap
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetPixBaseAddr"),
PpcImportDispatcherTarget::GetPixBaseAddr
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LockPixels"),
PpcImportDispatcherTarget::LockPixels
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "UnlockPixels"),
PpcImportDispatcherTarget::UnlockPixels
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetPixelsState"),
PpcImportDispatcherTarget::GetPixelsState
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetPixelsState"),
PpcImportDispatcherTarget::SetPixelsState
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "AllowPurgePixels"),
PpcImportDispatcherTarget::AllowPurgePixels
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NoPurgePixels"),
PpcImportDispatcherTarget::NoPurgePixels
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "CopyBits"),
PpcImportDispatcherTarget::CopyBits
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "BitMapToRegion"),
PpcImportDispatcherTarget::BitMapToRegion
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetPenState"),
PpcImportDispatcherTarget::GetPenState
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetPenState"),
PpcImportDispatcherTarget::SetPenState
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NewRgn"),
PpcImportDispatcherTarget::NewRgn
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DisposeRgn"),
PpcImportDispatcherTarget::DisposeRgn
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "OpenRgn"),
PpcImportDispatcherTarget::OpenRgn
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "CloseRgn"),
PpcImportDispatcherTarget::CloseRgn
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetEmptyRgn"),
PpcImportDispatcherTarget::SetEmptyRgn
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetRectRgn"),
PpcImportDispatcherTarget::SetRectRgn
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "RectRgn"),
PpcImportDispatcherTarget::RectRgn
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "EmptyRgn"),
PpcImportDispatcherTarget::EmptyRgn
);
}
#[test]
fn import_bindings_classify_rect_utility_imports() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetRect"),
PpcImportDispatcherTarget::SetRect
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "UnionRect"),
PpcImportDispatcherTarget::UnionRect
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetPt"),
PpcImportDispatcherTarget::SetPt
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LocalToGlobal"),
PpcImportDispatcherTarget::LocalToGlobal
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GlobalToLocal"),
PpcImportDispatcherTarget::GlobalToLocal
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PtInRect"),
PpcImportDispatcherTarget::PtInRect
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "OffsetRect"),
PpcImportDispatcherTarget::OffsetRect
);
}
#[test]
fn import_bindings_classify_quickdraw_bootstrap_noops() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "InitCursor"),
PpcImportDispatcherTarget::InitCursor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HideCursor"),
PpcImportDispatcherTarget::HideCursor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ShowCursor"),
PpcImportDispatcherTarget::ShowCursor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ShieldCursor"),
PpcImportDispatcherTarget::ShieldCursor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetCursor"),
PpcImportDispatcherTarget::GetCursor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetCursor"),
PpcImportDispatcherTarget::SetCursor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetCCursor"),
PpcImportDispatcherTarget::GetCCursor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetCIcon"),
PpcImportDispatcherTarget::GetCIcon
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PlotCIcon"),
PpcImportDispatcherTarget::PlotCIcon
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DisposeCIcon"),
PpcImportDispatcherTarget::DisposeCIcon
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetCCursor"),
PpcImportDispatcherTarget::SetCCursor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DisposeCCursor"),
PpcImportDispatcherTarget::DisposeCCursor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetForeColor"),
PpcImportDispatcherTarget::GetForeColor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetBackColor"),
PpcImportDispatcherTarget::GetBackColor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ForeColor"),
PpcImportDispatcherTarget::ForeColor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "BackColor"),
PpcImportDispatcherTarget::BackColor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "RGBForeColor"),
PpcImportDispatcherTarget::RGBForeColor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "RGBBackColor"),
PpcImportDispatcherTarget::RGBBackColor
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "Color2Index"),
PpcImportDispatcherTarget::Color2Index
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "Index2Color"),
PpcImportDispatcherTarget::Index2Color
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "MoveTo"),
PpcImportDispatcherTarget::MoveTo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LineTo"),
PpcImportDispatcherTarget::LineTo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DrawChar"),
PpcImportDispatcherTarget::DrawChar
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DrawString"),
PpcImportDispatcherTarget::DrawString
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DrawText"),
PpcImportDispatcherTarget::DrawText
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "TextMode"),
PpcImportDispatcherTarget::TextMode
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "TextSize"),
PpcImportDispatcherTarget::TextSize
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PaintRect"),
PpcImportDispatcherTarget::PaintRect
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "EraseRect"),
PpcImportDispatcherTarget::EraseRect
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "InvertRect"),
PpcImportDispatcherTarget::InvertRect
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FrameRect"),
PpcImportDispatcherTarget::FrameRect
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "InvalRect"),
PpcImportDispatcherTarget::InvalRect
);
}
#[test]
fn import_bindings_classify_classic_quickdraw_shape_imports() {
for (symbol, target) in [
("Move", PpcImportDispatcherTarget::Move),
("Line", PpcImportDispatcherTarget::Line),
("GetPen", PpcImportDispatcherTarget::GetPen),
("HidePen", PpcImportDispatcherTarget::HidePen),
("ShowPen", PpcImportDispatcherTarget::ShowPen),
("GetClip", PpcImportDispatcherTarget::GetClip),
("SetClip", PpcImportDispatcherTarget::SetClip),
("FillRect", PpcImportDispatcherTarget::FillRect),
("FrameOval", PpcImportDispatcherTarget::FrameOval),
("PaintOval", PpcImportDispatcherTarget::PaintOval),
("EraseOval", PpcImportDispatcherTarget::EraseOval),
("PaintArc", PpcImportDispatcherTarget::PaintArc),
("FrameRgn", PpcImportDispatcherTarget::FrameRgn),
("PaintRgn", PpcImportDispatcherTarget::PaintRgn),
("FillRgn", PpcImportDispatcherTarget::FillRgn),
("InvertRgn", PpcImportDispatcherTarget::InvertRgn),
("PtInRgn", PpcImportDispatcherTarget::PtInRgn),
("RectInRgn", PpcImportDispatcherTarget::RectInRgn),
("OpenPoly", PpcImportDispatcherTarget::OpenPoly),
("ClosePoly", PpcImportDispatcherTarget::ClosePoly),
("KillPoly", PpcImportDispatcherTarget::KillPoly),
("PaintPoly", PpcImportDispatcherTarget::PaintPoly),
("FramePoly", PpcImportDispatcherTarget::FramePoly),
("FillPoly", PpcImportDispatcherTarget::FillPoly),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
target,
"{symbol}"
);
}
}
#[test]
fn import_bindings_classify_resource_cleanup_imports() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ReleaseResource"),
PpcImportDispatcherTarget::ReleaseResource
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DetachResource"),
PpcImportDispatcherTarget::DetachResource
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HLock"),
PpcImportDispatcherTarget::HLock
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HLockHi"),
PpcImportDispatcherTarget::HLockHi
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HUnlock"),
PpcImportDispatcherTarget::HUnlock
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "MoveHHi"),
PpcImportDispatcherTarget::MoveHHi
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HNoPurge"),
PpcImportDispatcherTarget::HNoPurge
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HPurge"),
PpcImportDispatcherTarget::HPurge
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "TickCount"),
PpcImportDispatcherTarget::TickCount
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetZone"),
PpcImportDispatcherTarget::GetZone
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetZone"),
PpcImportDispatcherTarget::SetZone
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "InitZone"),
PpcImportDispatcherTarget::InitZone
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SystemZone"),
PpcImportDispatcherTarget::SystemZone
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ApplicZone"),
PpcImportDispatcherTarget::ApplicationZone
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ApplicationZone"),
PpcImportDispatcherTarget::ApplicationZone
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "DisposeCTable"),
PpcImportDispatcherTarget::DisposeCTable
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "CloseComponent"),
PpcImportDispatcherTarget::CloseComponent
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NewRoutineDescriptor"),
PpcImportDispatcherTarget::NewRoutineDescriptor
);
}
#[test]
fn import_bindings_classify_mixed_mode_imports() {
for (symbol, target) in [
(
"NewRoutineDescriptor",
PpcImportDispatcherTarget::NewRoutineDescriptor,
),
(
"NewFatRoutineDescriptor",
PpcImportDispatcherTarget::NewFatRoutineDescriptor,
),
(
"DisposeRoutineDescriptor",
PpcImportDispatcherTarget::DisposeRoutineDescriptor,
),
(
"CallUniversalProc",
PpcImportDispatcherTarget::CallUniversalProc,
),
(
"CallOSTrapUniversalProc",
PpcImportDispatcherTarget::CallOSTrapUniversalProc,
),
(
"NGetTrapAddress",
PpcImportDispatcherTarget::NGetTrapAddress,
),
(
"GetToolTrapAddress",
PpcImportDispatcherTarget::GetToolTrapAddress,
),
(
"GetOSTrapAddress",
PpcImportDispatcherTarget::GetOSTrapAddress,
),
(
"SetToolTrapAddress",
PpcImportDispatcherTarget::SetToolTrapAddress,
),
(
"SetOSTrapAddress",
PpcImportDispatcherTarget::SetOSTrapAddress,
),
(
"NSetTrapAddress",
PpcImportDispatcherTarget::NSetTrapAddress,
),
("LMGetCurrentA5", PpcImportDispatcherTarget::LMGetCurrentA5),
("VInstall", PpcImportDispatcherTarget::VInstall),
("VRemove", PpcImportDispatcherTarget::VRemove),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
target,
"{symbol}"
);
}
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetTrapAddress"),
PpcImportDispatcherTarget::Unsupported
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetTrapAddress"),
PpcImportDispatcherTarget::Unsupported
);
}
#[test]
fn import_bindings_classify_resource_write_imports() {
for (symbol, target) in [
("AddResource", PpcImportDispatcherTarget::AddResource),
(
"ChangedResource",
PpcImportDispatcherTarget::ChangedResource,
),
("WriteResource", PpcImportDispatcherTarget::WriteResource),
("RemoveResource", PpcImportDispatcherTarget::RemoveResource),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
target,
"{symbol}"
);
}
}
#[test]
fn import_bindings_classify_resource_read_imports() {
for (symbol, target) in [
("OpenResFile", PpcImportDispatcherTarget::OpenResFile),
("GetResource", PpcImportDispatcherTarget::GetResource),
("Get1Resource", PpcImportDispatcherTarget::Get1Resource),
(
"GetNamedResource",
PpcImportDispatcherTarget::GetNamedResource,
),
(
"Get1NamedResource",
PpcImportDispatcherTarget::Get1NamedResource,
),
("GetIndResource", PpcImportDispatcherTarget::GetIndResource),
(
"Get1IndResource",
PpcImportDispatcherTarget::Get1IndResource,
),
("GetIndString", PpcImportDispatcherTarget::GetIndString),
("getindstring", PpcImportDispatcherTarget::GetIndString),
("GetString", PpcImportDispatcherTarget::GetString),
("GetResAttrs", PpcImportDispatcherTarget::GetResAttrs),
("SetResAttrs", PpcImportDispatcherTarget::SetResAttrs),
("GetResInfo", PpcImportDispatcherTarget::GetResInfo),
("SetResInfo", PpcImportDispatcherTarget::SetResInfo),
("HomeResFile", PpcImportDispatcherTarget::HomeResFile),
("CountResources", PpcImportDispatcherTarget::CountResources),
(
"Count1Resources",
PpcImportDispatcherTarget::Count1Resources,
),
("UniqueID", PpcImportDispatcherTarget::UniqueID),
("Unique1ID", PpcImportDispatcherTarget::Unique1ID),
("UpdateResFile", PpcImportDispatcherTarget::UpdateResFile),
(
"ReadPartialResource",
PpcImportDispatcherTarget::ReadPartialResource,
),
("HCreateResFile", PpcImportDispatcherTarget::HCreateResFile),
("GetIcon", PpcImportDispatcherTarget::GetIcon),
("GetPattern", PpcImportDispatcherTarget::GetPattern),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
target,
"{symbol}"
);
}
}
#[test]
fn import_bindings_classify_sound_manager_volume_imports() {
assert_eq!(
dispatcher_target_for_import("SoundLib", "UnsignedFixedMulDiv"),
PpcImportDispatcherTarget::UnsignedFixedMulDiv
);
assert_eq!(
dispatcher_target_for_import("SoundLib", "GetSoundOutputInfo"),
PpcImportDispatcherTarget::GetSoundOutputInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SysBeep"),
PpcImportDispatcherTarget::SysBeep
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetDefaultOutputVolume"),
PpcImportDispatcherTarget::GetDefaultOutputVolume
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetDefaultOutputVolume"),
PpcImportDispatcherTarget::SetDefaultOutputVolume
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndNewChannel"),
PpcImportDispatcherTarget::SndNewChannel
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndDisposeChannel"),
PpcImportDispatcherTarget::SndDisposeChannel
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndChannelStatus"),
PpcImportDispatcherTarget::SndChannelStatus
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndDoImmediate"),
PpcImportDispatcherTarget::SndDoImmediate
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndDoCommand"),
PpcImportDispatcherTarget::SndDoCommand
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndPlayDoubleBuffer"),
PpcImportDispatcherTarget::SndPlayDoubleBuffer
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndStartFilePlay"),
PpcImportDispatcherTarget::SndStartFilePlay
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndPauseFilePlay"),
PpcImportDispatcherTarget::SndPauseFilePlay
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndStopFilePlay"),
PpcImportDispatcherTarget::SndStopFilePlay
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetSoundHeaderOffset"),
PpcImportDispatcherTarget::GetSoundHeaderOffset
);
}
#[test]
fn import_bindings_classify_file_manager_imports() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSpOpenDF"),
PpcImportDispatcherTarget::FSpOpenDF
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSpOpenResFile"),
PpcImportDispatcherTarget::FSpOpenResFile
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSpCreateResFile"),
PpcImportDispatcherTarget::FSpCreateResFile
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSpDirCreate"),
PpcImportDispatcherTarget::FSpDirCreate
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBGetFInfoSync"),
PpcImportDispatcherTarget::PBGetFInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBHGetFInfo"),
PpcImportDispatcherTarget::PBHGetFInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBSetFInfoAsync"),
PpcImportDispatcherTarget::PBSetFInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBHSetFInfoSync"),
PpcImportDispatcherTarget::PBHSetFInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HGetFInfo"),
PpcImportDispatcherTarget::HGetFInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HSetFInfo"),
PpcImportDispatcherTarget::HSetFInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "StandardGetFile"),
PpcImportDispatcherTarget::StandardGetFile
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetWDInfo"),
PpcImportDispatcherTarget::GetWDInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBGetCatInfoSync"),
PpcImportDispatcherTarget::PBGetCatInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBGetCatInfo"),
PpcImportDispatcherTarget::PBGetCatInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBGetFCBInfoSync"),
PpcImportDispatcherTarget::PBGetFCBInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetVol"),
PpcImportDispatcherTarget::GetVol
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HSetVol"),
PpcImportDispatcherTarget::HSetVol
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HGetVol"),
PpcImportDispatcherTarget::HGetVol
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FlushVol"),
PpcImportDispatcherTarget::FlushVol
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBFlushVolSync"),
PpcImportDispatcherTarget::PBFlushVol
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBSetCatInfoSync"),
PpcImportDispatcherTarget::PBSetCatInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBSetCatInfo"),
PpcImportDispatcherTarget::PBSetCatInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSpGetFInfo"),
PpcImportDispatcherTarget::FSpGetFInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSpSetFInfo"),
PpcImportDispatcherTarget::FSpSetFInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NewAlias"),
PpcImportDispatcherTarget::NewAlias
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "UpdateAlias"),
PpcImportDispatcherTarget::UpdateAlias
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ResolveAlias"),
PpcImportDispatcherTarget::ResolveAlias
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ResolveAliasFile"),
PpcImportDispatcherTarget::ResolveAliasFile
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSClose"),
PpcImportDispatcherTarget::FSClose
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBFlushFileSync"),
PpcImportDispatcherTarget::PBFlushFile
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSRead"),
PpcImportDispatcherTarget::FSRead
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSWrite"),
PpcImportDispatcherTarget::FSWrite
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetEOF"),
PpcImportDispatcherTarget::GetEOF
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetEOF"),
PpcImportDispatcherTarget::SetEOF
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetFPos"),
PpcImportDispatcherTarget::GetFPos
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetFPos"),
PpcImportDispatcherTarget::SetFPos
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSpCreate"),
PpcImportDispatcherTarget::FSpCreate
);
for symbol in ["PBHCreate", "PBHCreateSync", "PBHCreateAsync"] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::PBCreate(
PpcParameterBlockCreateOperation::Hierarchical
),
"{symbol}"
);
}
for symbol in ["PBCreate", "PBCreateSync", "PBCreateAsync"] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::PBCreate(PpcParameterBlockCreateOperation::Legacy),
"{symbol}"
);
}
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSpDelete"),
PpcImportDispatcherTarget::FSpDelete
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HDelete"),
PpcImportDispatcherTarget::DeleteByName(
PpcDeleteByNameOperation::HierarchicalHighLevel
)
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "FSDelete"),
PpcImportDispatcherTarget::DeleteByName(PpcDeleteByNameOperation::LegacyHighLevel)
);
for symbol in ["PBHDelete", "PBHDeleteSync", "PBHDeleteAsync"] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::DeleteByName(
PpcDeleteByNameOperation::HierarchicalParameterBlock
),
"{symbol}"
);
}
for symbol in ["PBDelete", "PBDeleteSync", "PBDeleteAsync"] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::DeleteByName(
PpcDeleteByNameOperation::LegacyParameterBlock
),
"{symbol}"
);
}
}
#[test]
fn hle_import_runner_uses_typed_parameter_block_create_operation() {
let pef = synthetic_pef_with_import(b"PBHCreate");
let mut loaded = load_pef_application(&pef).unwrap();
let folder_id = PPC_FIRST_DYNAMIC_DIR_ID;
loaded.vfs_directories.push(PpcVfsDirectory {
dir_id: folder_id,
parent_dir_id: PPC_ROOT_DIR_ID,
path: "Typed Folder".to_string(),
creator: PPC_DIRECTORY_CREATOR,
file_type: PPC_DIRECTORY_FILE_TYPE,
finder_flags: 0,
dirty: false,
});
let pb = PPC_DATA_BASE + 0x1000;
let name_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(pb, vec![0; 64]);
loaded.memory.add_region(name_ptr, vec![0; 64]);
loaded.memory.write_u32_be(pb + 18, name_ptr).unwrap();
loaded
.memory
.write_u16_be(pb + 22, PPC_BOOT_VOLUME_REF_NUM as u16)
.unwrap();
loaded.memory.write_u32_be(pb + 48, folder_id).unwrap();
loaded.cpu.gpr[3] = pb;
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::PBCreate(PpcParameterBlockCreateOperation::Hierarchical)
);
loaded.imports[0].symbol_name = "PBCreate".to_string();
write_ppc_pstring(&mut loaded.memory, name_ptr, b"Hierarchical File");
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(loaded
.vfs_files
.iter()
.any(|file| file.path == "Typed Folder/Hierarchical File"));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::PBCreate(PpcParameterBlockCreateOperation::Legacy);
loaded.imports[0].symbol_name = "PBHCreate".to_string();
write_ppc_pstring(&mut loaded.memory, name_ptr, b"Legacy File");
loaded.cpu.gpr[3] = pb;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(loaded.vfs_files.iter().any(|file| file.path == "Legacy File"));
assert!(!loaded
.vfs_files
.iter()
.any(|file| file.path == "Typed Folder/Legacy File"));
}
#[test]
fn hle_import_runner_uses_typed_delete_by_name_operation() {
let pef = synthetic_pef_with_import(b"PBHDelete");
let mut loaded = load_pef_application(&pef).unwrap();
let folder_id = PPC_FIRST_DYNAMIC_DIR_ID;
loaded.vfs_directories.push(PpcVfsDirectory {
dir_id: folder_id,
parent_dir_id: PPC_ROOT_DIR_ID,
path: "Typed Folder".to_string(),
creator: PPC_DIRECTORY_CREATOR,
file_type: PPC_DIRECTORY_FILE_TYPE,
finder_flags: 0,
dirty: false,
});
for path in ["Victim", "Typed Folder/Victim"] {
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: path.to_string(),
data: Vec::new().into(),
creator: 0,
file_type: 0,
finder_flags: 0,
dirty: false,
});
}
let pb = PPC_DATA_BASE + 0x1000;
let name_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(pb, vec![0; 64]);
loaded.memory.add_region(name_ptr, vec![0; 64]);
loaded.memory.write_u32_be(pb + 18, name_ptr).unwrap();
loaded
.memory
.write_u16_be(pb + 22, PPC_BOOT_VOLUME_REF_NUM as u16)
.unwrap();
loaded.memory.write_u32_be(pb + 48, folder_id).unwrap();
write_ppc_pstring(&mut loaded.memory, name_ptr, b"Victim");
loaded.cpu.gpr[3] = pb;
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::DeleteByName(
PpcDeleteByNameOperation::HierarchicalParameterBlock
)
);
loaded.imports[0].symbol_name = "PBDelete".to_string();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(loaded.vfs_files.iter().any(|file| file.path == "Victim"));
assert!(!loaded
.vfs_files
.iter()
.any(|file| file.path == "Typed Folder/Victim"));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DeleteByName(
PpcDeleteByNameOperation::LegacyParameterBlock,
);
loaded.imports[0].symbol_name = "PBHDelete".to_string();
loaded.cpu.gpr[3] = pb;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(!loaded.vfs_files.iter().any(|file| file.path == "Victim"));
}
#[test]
fn file_compatibility_imports_pre_resolve_to_typed_operations() {
for (symbol, operation) in [
("OpenDF", PpcFileCompatibilityOperation::OpenDf),
("OpenRF", PpcFileCompatibilityOperation::OpenRf),
("PBCatSearchSync", PpcFileCompatibilityOperation::PbCatSearchSync),
("PBCloseWDSync", PpcFileCompatibilityOperation::PbCloseWdSync),
("PBDirCreateSync", PpcFileCompatibilityOperation::PbDirCreateSync),
("PBGetFPosSync", PpcFileCompatibilityOperation::PbGetFPosSync),
("PBGetWDInfoSync", PpcFileCompatibilityOperation::PbGetWdInfoSync),
("PBHGetVolParmsSync", PpcFileCompatibilityOperation::PbHGetVolParmsSync),
("PBHGetVolSync", PpcFileCompatibilityOperation::PbHGetVolSync),
("PBHOpenRFSync", PpcFileCompatibilityOperation::PbHOpenRfSync),
("PBHSetVolSync", PpcFileCompatibilityOperation::PbHSetVolSync),
("PBOpenWDSync", PpcFileCompatibilityOperation::PbOpenWdSync),
("create", PpcFileCompatibilityOperation::Create),
("fsopen", PpcFileCompatibilityOperation::FsOpen),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::FileCompatibility(operation),
);
}
}
#[test]
fn stdio_imports_pre_resolve_to_typed_operations() {
for (symbol, operation) in [
("clearerr", PpcStdIoOperation::ClearErr),
("_filbuf", PpcStdIoOperation::FileBuffer),
("fclose", PpcStdIoOperation::FileClose),
("feof", PpcStdIoOperation::FileEof),
("ferror", PpcStdIoOperation::FileError),
("fflush", PpcStdIoOperation::FileFlush),
("fopen", PpcStdIoOperation::FileOpen),
("fprintf", PpcStdIoOperation::FilePrintf),
("fread", PpcStdIoOperation::FileRead),
("fseek", PpcStdIoOperation::FileSeek),
("ftell", PpcStdIoOperation::FileTell),
("fwrite", PpcStdIoOperation::FileWrite),
("_iob", PpcStdIoOperation::IoBuffer),
] {
assert_eq!(
dispatcher_target_for_import("StdCLib", symbol),
PpcImportDispatcherTarget::StdIoCompatibility(operation),
);
}
}
#[test]
fn legacy_control_imports_pre_resolve_to_typed_operations() {
for (symbol, operation) in [
("DisposeControl", PpcLegacyControlOperation::DisposeControl),
("Draw1Control", PpcLegacyControlOperation::DrawOneControl),
("FindControl", PpcLegacyControlOperation::FindControl),
("GetControlMaximum", PpcLegacyControlOperation::GetControlMaximum),
("GetControlMinimum", PpcLegacyControlOperation::GetControlMinimum),
("GetControlTitle", PpcLegacyControlOperation::GetControlTitle),
("GetControlValue", PpcLegacyControlOperation::GetControlValue),
("GetNewControl", PpcLegacyControlOperation::GetNewControl),
("HideControl", PpcLegacyControlOperation::HideControl),
("KillControls", PpcLegacyControlOperation::KillControls),
("MoveControl", PpcLegacyControlOperation::MoveControl),
("NewControl", PpcLegacyControlOperation::NewControl),
("SetControlMaximum", PpcLegacyControlOperation::SetControlMaximum),
("SetControlMinimum", PpcLegacyControlOperation::SetControlMinimum),
("ShowControl", PpcLegacyControlOperation::ShowControl),
("SizeControl", PpcLegacyControlOperation::SizeControl),
("TestControl", PpcLegacyControlOperation::TestControl),
("TrackControl", PpcLegacyControlOperation::TrackControl),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::LegacyControl(operation),
);
}
}
#[test]
fn pbhgetvolsync_returns_working_directory_fields_at_wdpb_offsets() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBHGetVolSync"),
PpcImportDispatcherTarget::FileCompatibility(
PpcFileCompatibilityOperation::PbHGetVolSync,
)
);
let pef = synthetic_pef_with_import(b"PBHGetVolSync");
let mut loaded = load_pef_application(&pef).unwrap();
let parameter_block = PPC_DATA_BASE + 0x1000;
let volume_name = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(parameter_block, vec![0xaa; 64]);
loaded.memory.add_region(volume_name, vec![0; 64]);
loaded
.memory
.write_u32_be(parameter_block + 18, volume_name)
.unwrap();
loaded
.default_dir_id
.with_mut(|default_dir_id| *default_dir_id = 0x1234_5678);
loaded.cpu.gpr[3] = parameter_block;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u16_be(parameter_block + 22),
Some(PPC_BOOT_VOLUME_REF_NUM as u16)
);
assert_eq!(
loaded.memory.read_u16_be(parameter_block + 32),
Some(PPC_BOOT_VOLUME_REF_NUM as u16)
);
assert_eq!(
loaded.memory.read_u32_be(parameter_block + 48),
Some(0x1234_5678)
);
assert_eq!(
loaded.memory.read_u32_be(parameter_block + 28),
Some(0),
"ioWDProcID is cleared for the current process"
);
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, volume_name),
Some(TrapDispatcher::boot_volume_name().as_bytes().to_vec())
);
}
#[test]
fn native_parameter_block_working_directory_lifecycle_uses_process_registry() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PBCloseWDSync"),
PpcImportDispatcherTarget::FileCompatibility(
PpcFileCompatibilityOperation::PbCloseWdSync,
)
);
let pef = synthetic_pef_with_import(b"PBOpenWDSync");
let mut loaded = load_pef_application(&pef).unwrap();
let parameter_block = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(parameter_block, vec![0; 64]);
loaded
.memory
.write_u16_be(parameter_block + 22, PPC_BOOT_VOLUME_REF_NUM as u16)
.unwrap();
loaded
.memory
.write_u32_be(parameter_block + 28, 0x1234_5678)
.unwrap();
loaded
.memory
.write_u32_be(parameter_block + 48, PPC_PREFERENCES_DIR_ID)
.unwrap();
loaded.cpu.gpr[3] = parameter_block;
let open_probe = loaded.run_with_hle_imports(64);
assert_eq!(open_probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let wd_ref_num = loaded.memory.read_u16_be(parameter_block + 22).unwrap() as i16;
assert_ne!(wd_ref_num, PPC_BOOT_VOLUME_REF_NUM);
assert_eq!(
loaded.working_directories.get(&wd_ref_num),
Some(&ProcessWorkingDirectory {
ref_num: wd_ref_num,
volume_ref_num: PPC_BOOT_VOLUME_REF_NUM,
dir_id: PPC_PREFERENCES_DIR_ID,
proc_id: 0x1234_5678,
})
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::FileCompatibility(
PpcFileCompatibilityOperation::PbGetWdInfoSync,
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = loaded.halt_pc;
loaded.cpu.gpr[3] = parameter_block;
loaded
.memory
.write_u16_be(parameter_block + 22, wd_ref_num as u16)
.unwrap();
loaded.memory.write_u16_be(parameter_block + 26, 0).unwrap();
let info_probe = loaded.run_with_hle_imports(64);
assert_eq!(info_probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u16_be(parameter_block + 32),
Some(PPC_BOOT_VOLUME_REF_NUM as u16)
);
assert_eq!(
loaded.memory.read_u32_be(parameter_block + 48),
Some(PPC_PREFERENCES_DIR_ID)
);
assert_eq!(
loaded.memory.read_u32_be(parameter_block + 28),
Some(0x1234_5678)
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::FileCompatibility(
PpcFileCompatibilityOperation::PbCloseWdSync,
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = loaded.halt_pc;
loaded.cpu.gpr[3] = parameter_block;
loaded
.memory
.write_u16_be(parameter_block + 22, wd_ref_num as u16)
.unwrap();
let close_probe = loaded.run_with_hle_imports(64);
assert_eq!(close_probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(!loaded.working_directories.contains_key(&wd_ref_num));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = loaded.halt_pc;
loaded.cpu.gpr[3] = parameter_block;
loaded
.memory
.write_u16_be(parameter_block + 22, PPC_BOOT_VOLUME_REF_NUM as u16)
.unwrap();
let volume_close_probe = loaded.run_with_hle_imports(64);
assert_eq!(volume_close_probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
}
#[test]
fn import_bindings_classify_dialog_and_utility_imports() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetNewDialog"),
PpcImportDispatcherTarget::GetNewDialog
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NewDialog"),
PpcImportDispatcherTarget::NewDialog
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetDialogItem"),
PpcImportDispatcherTarget::GetDialogItem
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetDialogItemText"),
PpcImportDispatcherTarget::GetDialogItemText
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "getdialogitemtext"),
PpcImportDispatcherTarget::GetDialogItemText
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetDialogItemText"),
PpcImportDispatcherTarget::SetDialogItemText
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "setdialogitemtext"),
PpcImportDispatcherTarget::SetDialogItemText
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ModalDialog"),
PpcImportDispatcherTarget::ModalDialog
);
for (symbol, operation) in [
("AppendDITL", PpcDialogCompatibilityOperation::AppendDitl),
("CountDITL", PpcDialogCompatibilityOperation::CountDitl),
("DialogSelect", PpcDialogCompatibilityOperation::DialogSelect),
(
"FindDialogItem",
PpcDialogCompatibilityOperation::FindDialogItem,
),
(
"HideDialogItem",
PpcDialogCompatibilityOperation::HideDialogItem,
),
(
"IsDialogEvent",
PpcDialogCompatibilityOperation::IsDialogEvent,
),
("ShortenDITL", PpcDialogCompatibilityOperation::ShortenDitl),
(
"ShowDialogItem",
PpcDialogCompatibilityOperation::ShowDialogItem,
),
("UpdateDialog", PpcDialogCompatibilityOperation::UpdateDialog),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::DialogCompatibility(operation),
);
}
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetControlTitle"),
PpcImportDispatcherTarget::SetControlTitle
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetControlValue"),
PpcImportDispatcherTarget::SetControlValue
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetNextEvent"),
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::GetNextEvent)
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "WaitNextEvent"),
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::WaitNextEvent)
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetOSEvent"),
PpcImportDispatcherTarget::GetOSEvent
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "OSEventAvail"),
PpcImportDispatcherTarget::OSEventAvail
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "PostEvent"),
PpcImportDispatcherTarget::PostEvent
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "Button"),
PpcImportDispatcherTarget::Button
);
for (symbol, target) in [
("InitGraf", PpcImportDispatcherTarget::InitGraf),
("InitFonts", PpcImportDispatcherTarget::InitFonts),
("InitWindows", PpcImportDispatcherTarget::InitWindows),
("InitMenus", PpcImportDispatcherTarget::InitMenus),
("TEInit", PpcImportDispatcherTarget::TEInit),
("InitDialogs", PpcImportDispatcherTarget::InitDialogs),
("FlushEvents", PpcImportDispatcherTarget::FlushEvents),
("DisposeDialog", PpcImportDispatcherTarget::DisposeDialog),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
target,
"{symbol}"
);
}
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetKeys"),
PpcImportDispatcherTarget::GetKeys
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetDateTime"),
PpcImportDispatcherTarget::GetDateTime
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetTime"),
PpcImportDispatcherTarget::GetTime
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "Delay"),
PpcImportDispatcherTarget::Delay
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetDblTime"),
PpcImportDispatcherTarget::GetDblTime
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMGetTime"),
PpcImportDispatcherTarget::LMGetTime
);
assert_eq!(
dispatcher_target_for_import("StdCLib", "__setjmp"),
PpcImportDispatcherTarget::ReturnNoErr
);
assert_eq!(
dispatcher_target_for_import("StdCLib", "sprintf"),
PpcImportDispatcherTarget::StdSprintf
);
assert_eq!(
dispatcher_target_for_import("StdCLib", "signal"),
PpcImportDispatcherTarget::StdCCompatibility(PpcStdCCompatibilityOperation::Signal)
);
for (symbol, operation) in [
("qsort", PpcStdCCompatibilityOperation::Qsort),
("sscanf", PpcStdCCompatibilityOperation::Sscanf),
("strftime", PpcStdCCompatibilityOperation::Strftime),
("vsprintf", PpcStdCCompatibilityOperation::Vsprintf),
] {
assert_eq!(
dispatcher_target_for_import("StdCLib", symbol),
PpcImportDispatcherTarget::StdCCompatibility(operation),
);
}
for (symbol, operation) in [
("CountVoices", PpcSpeechCompatibilityOperation::CountVoices),
(
"DisposeSpeechChannel",
PpcSpeechCompatibilityOperation::DisposeSpeechChannel,
),
("GetIndVoice", PpcSpeechCompatibilityOperation::GetIndVoice),
(
"GetVoiceDescription",
PpcSpeechCompatibilityOperation::GetVoiceDescription,
),
(
"NewSpeechChannel",
PpcSpeechCompatibilityOperation::NewSpeechChannel,
),
("SpeakString", PpcSpeechCompatibilityOperation::SpeakString),
("SpeakText", PpcSpeechCompatibilityOperation::SpeakText),
("SpeechBusy", PpcSpeechCompatibilityOperation::SpeechBusy),
] {
assert_eq!(
dispatcher_target_for_import("SpeechLib", symbol),
PpcImportDispatcherTarget::SpeechCompatibility(operation),
);
}
for (symbol, operation) in [
("SPBCloseDevice", PpcSoundInputCompatibilityOperation::CloseDevice),
("SPBGetDeviceInfo", PpcSoundInputCompatibilityOperation::GetDeviceInfo),
("SPBOpenDevice", PpcSoundInputCompatibilityOperation::OpenDevice),
("SPBRecord", PpcSoundInputCompatibilityOperation::Record),
("SPBSetDeviceInfo", PpcSoundInputCompatibilityOperation::SetDeviceInfo),
("SPBStopRecording", PpcSoundInputCompatibilityOperation::StopRecording),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::SoundInputCompatibility(operation),
);
}
for (symbol, operation) in [
("PrClose", PpcPrintingCompatibilityOperation::PrClose),
("PrCloseDoc", PpcPrintingCompatibilityOperation::PrCloseDoc),
("PrClosePage", PpcPrintingCompatibilityOperation::PrClosePage),
("PrError", PpcPrintingCompatibilityOperation::PrError),
("PrJobDialog", PpcPrintingCompatibilityOperation::PrJobDialog),
("PrOpen", PpcPrintingCompatibilityOperation::PrOpen),
("PrOpenDoc", PpcPrintingCompatibilityOperation::PrOpenDoc),
("PrOpenPage", PpcPrintingCompatibilityOperation::PrOpenPage),
("PrPicFile", PpcPrintingCompatibilityOperation::PrPicFile),
("PrStlDialog", PpcPrintingCompatibilityOperation::PrStlDialog),
("PrintDefault", PpcPrintingCompatibilityOperation::PrintDefault),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::PrintingCompatibility(operation),
);
}
for (symbol, operation) in [
(
"ISpDevices_ActivateClass",
PpcInputSprocketCompatibilityOperation::DevicesActivateClass,
),
(
"ISpElement_DisposeVirtual",
PpcInputSprocketCompatibilityOperation::ElementDisposeVirtual,
),
(
"ISpElement_Flush",
PpcInputSprocketCompatibilityOperation::ElementFlush,
),
(
"ISpElement_GetNextEvent",
PpcInputSprocketCompatibilityOperation::ElementGetNextEvent,
),
("ISpTickle", PpcInputSprocketCompatibilityOperation::Tickle),
] {
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", symbol),
PpcImportDispatcherTarget::InputSprocketCompatibility(operation),
);
}
for (symbol, operation) in [
(
"GetMovieTimeBase",
PpcQuickTimeCompatibilityOperation::GetMovieTimeBase,
),
(
"GetMovieVolume",
PpcQuickTimeCompatibilityOperation::GetMovieVolume,
),
(
"NewMovieFromDataFork",
PpcQuickTimeCompatibilityOperation::NewMovieFromDataFork,
),
("PrerollMovie", PpcQuickTimeCompatibilityOperation::PrerollMovie),
(
"SetMovieVolume",
PpcQuickTimeCompatibilityOperation::SetMovieVolume,
),
(
"SetTimeBaseFlags",
PpcQuickTimeCompatibilityOperation::SetTimeBaseFlags,
),
("UpdateMovie", PpcQuickTimeCompatibilityOperation::UpdateMovie),
] {
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", symbol),
PpcImportDispatcherTarget::QuickTimeCompatibility(operation),
);
}
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SecondsToDate"),
PpcImportDispatcherTarget::SecondsToDate
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "Secs2Date"),
PpcImportDispatcherTarget::SecondsToDate
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "Microseconds"),
PpcImportDispatcherTarget::Microseconds
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SysEnvirons"),
PpcImportDispatcherTarget::SysEnvirons
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "TextWidth"),
PpcImportDispatcherTarget::TextWidth
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "StringWidth"),
PpcImportDispatcherTarget::StringWidth
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "EqualString"),
PpcImportDispatcherTarget::EqualString
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "X2Fix"),
PpcImportDispatcherTarget::X2Fix
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "NumToString"),
PpcImportDispatcherTarget::NumToString
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "StringToNum"),
PpcImportDispatcherTarget::StringToNum
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "Random"),
PpcImportDispatcherTarget::Random
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "p2cstr"),
PpcImportDispatcherTarget::P2CStr
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "c2pstr"),
PpcImportDispatcherTarget::C2PStr
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetCurrentProcess"),
PpcImportDispatcherTarget::GetCurrentProcess
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "WakeUpProcess"),
PpcImportDispatcherTarget::WakeUpProcess
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetProcessInformation"),
PpcImportDispatcherTarget::GetProcessInformation
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "ExitToShell"),
PpcImportDispatcherTarget::ExitToShell
);
}
#[test]
fn sound_input_open_failure_clears_the_output_reference() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"SPBOpenDevice")).unwrap();
let output = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(output, vec![0xaa; 4]);
loaded.cpu.gpr[5] = output;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(output), Some(0));
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_NOT_ENOUGH_HARDWARE_ERR)
);
}
#[test]
fn quickdraw_compatibility_imports_pre_resolve_to_typed_operations() {
for (symbol, operation) in [
("AnimateEntry", PpcQuickDrawCompatibilityOperation::AnimateEntry),
("AnimatePalette", PpcQuickDrawCompatibilityOperation::AnimatePalette),
("BackPat", PpcQuickDrawCompatibilityOperation::BackPat),
("BackPixPat", PpcQuickDrawCompatibilityOperation::BackPixPat),
("ClosePicture", PpcQuickDrawCompatibilityOperation::ClosePicture),
("CopyDeepMask", PpcQuickDrawCompatibilityOperation::CopyDeepMask),
("CopyMask", PpcQuickDrawCompatibilityOperation::CopyMask),
("CopyPalette", PpcQuickDrawCompatibilityOperation::CopyPalette),
("CTab2Palette", PpcQuickDrawCompatibilityOperation::Ctab2Palette),
("DisposeGDevice", PpcQuickDrawCompatibilityOperation::DisposeGDevice),
("DisposePalette", PpcQuickDrawCompatibilityOperation::DisposePalette),
("Exp1to3", PpcQuickDrawCompatibilityOperation::Exp1To3),
("Exp1to6", PpcQuickDrawCompatibilityOperation::Exp1To6),
("GetCPixel", PpcQuickDrawCompatibilityOperation::GetCPixel),
("GetEntryUsage", PpcQuickDrawCompatibilityOperation::GetEntryUsage),
("GetItemIcon", PpcQuickDrawCompatibilityOperation::GetItemIcon),
("GetItemStyle", PpcQuickDrawCompatibilityOperation::GetItemStyle),
("GetNewPalette", PpcQuickDrawCompatibilityOperation::GetNewPalette),
("NewGDevice", PpcQuickDrawCompatibilityOperation::NewGDevice),
("NewPalette", PpcQuickDrawCompatibilityOperation::NewPalette),
("OpenPicture", PpcQuickDrawCompatibilityOperation::OpenPicture),
("Palette2CTab", PpcQuickDrawCompatibilityOperation::Palette2Ctab),
("PenPat", PpcQuickDrawCompatibilityOperation::PenPat),
("PlotIcon", PpcQuickDrawCompatibilityOperation::PlotIcon),
("ScrollRect", PpcQuickDrawCompatibilityOperation::ScrollRect),
("SetCPixel", PpcQuickDrawCompatibilityOperation::SetCPixel),
("SetEntryColor", PpcQuickDrawCompatibilityOperation::SetEntryColor),
("SetEntryUsage", PpcQuickDrawCompatibilityOperation::SetEntryUsage),
("SetItemIcon", PpcQuickDrawCompatibilityOperation::SetItemIcon),
("SetItemStyle", PpcQuickDrawCompatibilityOperation::SetItemStyle),
("SetStdCProcs", PpcQuickDrawCompatibilityOperation::SetStdCProcs),
("SetStdProcs", PpcQuickDrawCompatibilityOperation::SetStdProcs),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::QuickDrawCompatibility(operation),
);
}
}
#[test]
fn system_compatibility_imports_pre_resolve_to_typed_operations() {
for (symbol, operation) in [
("BuildDDPwds", PpcSystemCompatibilityOperation::BuildDdPwds),
("CTBGetCTBVersion", PpcSystemCompatibilityOperation::CtbGetCtbVersion),
("CallComponentUPP", PpcSystemCompatibilityOperation::CallComponentUpp),
("DIBadMount", PpcSystemCompatibilityOperation::DiBadMount),
("DILoad", PpcSystemCompatibilityOperation::DiLoad),
("DIUnload", PpcSystemCompatibilityOperation::DiUnload),
("Debugger", PpcSystemCompatibilityOperation::Debugger),
("Dequeue", PpcSystemCompatibilityOperation::Dequeue),
("Enqueue", PpcSystemCompatibilityOperation::Enqueue),
("FindNextComponent", PpcSystemCompatibilityOperation::FindNextComponent),
("GetNextProcess", PpcSystemCompatibilityOperation::GetNextProcess),
("GetScript", PpcSystemCompatibilityOperation::GetScript),
("GetScriptManagerVariable", PpcSystemCompatibilityOperation::GetScriptManagerVariable),
("GetScriptVariable", PpcSystemCompatibilityOperation::GetScriptVariable),
("GetSysBeepVolume", PpcSystemCompatibilityOperation::GetSysBeepVolume),
("IUCompString", PpcSystemCompatibilityOperation::IuCompString),
("IUDateString", PpcSystemCompatibilityOperation::IuDateString),
("InitCRM", PpcSystemCompatibilityOperation::InitCrm),
("InitCTBUtilities", PpcSystemCompatibilityOperation::InitCtbUtilities),
("KeyTranslate", PpcSystemCompatibilityOperation::KeyTranslate),
("LaunchApplication", PpcSystemCompatibilityOperation::LaunchApplication),
("LMGetCurApName", PpcSystemCompatibilityOperation::LmGetCurApName),
("LMGetSysFontFam", PpcSystemCompatibilityOperation::LmGetSysFontFam),
("LMGetSysFontSize", PpcSystemCompatibilityOperation::LmGetSysFontSize),
("MIDIAddPort", PpcSystemCompatibilityOperation::MidiAddPort),
("MIDIRemovePort", PpcSystemCompatibilityOperation::MidiRemovePort),
("MIDISignOut", PpcSystemCompatibilityOperation::MidiSignOut),
("MIDIWritePacket", PpcSystemCompatibilityOperation::MidiWritePacket),
("Munger", PpcSystemCompatibilityOperation::Munger),
("NMRemove", PpcSystemCompatibilityOperation::NmRemove),
("ObscureCursor", PpcSystemCompatibilityOperation::ObscureCursor),
("OpenDefaultComponent", PpcSystemCompatibilityOperation::OpenDefaultComponent),
("ResetAlertStage", PpcSystemCompatibilityOperation::ResetAlertStage),
("SetFrontProcess", PpcSystemCompatibilityOperation::SetFrontProcess),
("StyledLineBreak", PpcSystemCompatibilityOperation::StyledLineBreak),
("SystemEdit", PpcSystemCompatibilityOperation::SystemEdit),
("TruncText", PpcSystemCompatibilityOperation::TruncText),
("UpperString", PpcSystemCompatibilityOperation::UpperString),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::SystemCompatibility(operation),
);
}
}
#[test]
fn import_run_state_preserves_sparse_first_match_lookup() {
let first = PpcImportBinding {
library_index: 0,
symbol_index: 52,
library_name: "InterfaceLib".to_string(),
symbol_name: "GetKeys".to_string(),
class: 0,
weak: false,
address: 0,
tvector_address: None,
trap_pc: 0,
dispatcher_target: PpcImportDispatcherTarget::GetKeys,
};
let mut duplicate = first.clone();
duplicate.symbol_name = "DuplicateGetKeys".to_string();
duplicate.dispatcher_target = PpcImportDispatcherTarget::Unsupported;
let mut out_of_range = first.clone();
out_of_range.symbol_index = 999;
let state = PpcImportRunState::from_parts(
vec![first.clone(), duplicate, out_of_range],
64,
ppc_import_layout(),
);
assert_eq!(state.binding_cloned(52), Some(first));
assert_eq!(state.binding_cloned(51), None);
assert_eq!(state.binding_cloned(53), None);
assert_eq!(state.binding_cloned(999), None);
}
#[test]
fn import_bindings_classify_quicktime_imports() {
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GetGraphicsImporterForFile"),
PpcImportDispatcherTarget::QtGetGraphicsImporterForFile
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GraphicsImportGetBoundsRect"),
PpcImportDispatcherTarget::QtGraphicsImportGetBoundsRect
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GraphicsImportSetGWorld"),
PpcImportDispatcherTarget::QtGraphicsImportSetGWorld
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GraphicsImportDraw"),
PpcImportDispatcherTarget::QtGraphicsImportDraw
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "OpenMovieFile"),
PpcImportDispatcherTarget::QtOpenMovieFile
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "NewMovieFromFile"),
PpcImportDispatcherTarget::QtNewMovieFromFile
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GetMovieBox"),
PpcImportDispatcherTarget::QtGetMovieBox
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "SetMovieBox"),
PpcImportDispatcherTarget::QtSetMovieBox
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "IsMovieDone"),
PpcImportDispatcherTarget::QtIsMovieDone
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "SetMovieGWorld"),
PpcImportDispatcherTarget::QtSetMovieGWorld
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "StartMovie"),
PpcImportDispatcherTarget::QtStartMovie
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "StopMovie"),
PpcImportDispatcherTarget::QtStopMovie
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "MoviesTask"),
PpcImportDispatcherTarget::QtMoviesTask
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "DisposeMovie"),
PpcImportDispatcherTarget::QtDisposeMovie
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GoToBeginningOfMovie"),
PpcImportDispatcherTarget::QtGoToBeginningOfMovie
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GoToEndOfMovie"),
PpcImportDispatcherTarget::QtGoToEndOfMovie
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GetMovieDuration"),
PpcImportDispatcherTarget::QtGetMovieDuration
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "LoadMovieIntoRam"),
PpcImportDispatcherTarget::QtLoadMovieIntoRam
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "CloseMovieFile"),
PpcImportDispatcherTarget::QtCloseMovieFile
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "EnterMovies"),
PpcImportDispatcherTarget::QtEnterMovies
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "ExitMovies"),
PpcImportDispatcherTarget::QtExitMovies
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GetMoviesError"),
PpcImportDispatcherTarget::QtGetMoviesError
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "GetMoviesStickyError"),
PpcImportDispatcherTarget::QtGetMoviesStickyError
);
assert_eq!(
dispatcher_target_for_import("QuickTimeLib", "ClearMoviesStickyError"),
PpcImportDispatcherTarget::QtClearMoviesStickyError
);
}
#[test]
fn import_bindings_classify_draw_sprocket_imports() {
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpStartup"),
PpcImportDispatcherTarget::DSpStartup
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpShutdown"),
PpcImportDispatcherTarget::DSpShutdown
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpCanUserSelectContext"),
PpcImportDispatcherTarget::DSpCanUserSelectContext
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpGetMouse"),
PpcImportDispatcherTarget::DSpGetMouse
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpFindContextFromPoint"),
PpcImportDispatcherTarget::DSpFindContextFromPoint
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GlobalToLocal"),
PpcImportDispatcherTarget::DSpContextGlobalToLocal
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpFindBestContext"),
PpcImportDispatcherTarget::DSpFindBestContext
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpUserSelectContext"),
PpcImportDispatcherTarget::DSpUserSelectContext
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpSetBlankingColor"),
PpcImportDispatcherTarget::DSpSetBlankingColor
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpAltBuffer_New"),
PpcImportDispatcherTarget::DSpAltBufferNew
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpAltBuffer_GetCGrafPtr"),
PpcImportDispatcherTarget::DSpAltBufferGetCGrafPtr
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_Reserve"),
PpcImportDispatcherTarget::DSpContextReserve
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_Release"),
PpcImportDispatcherTarget::DSpContextRelease
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_SetState"),
PpcImportDispatcherTarget::DSpContextSetState
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_FadeGamma"),
PpcImportDispatcherTarget::DSpContextFadeGamma
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_FadeGammaIn"),
PpcImportDispatcherTarget::DSpContextFadeGammaIn
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_FadeGammaOut"),
PpcImportDispatcherTarget::DSpContextFadeGammaOut
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetFrontBuffer"),
PpcImportDispatcherTarget::DSpContextGetFrontBuffer
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetBackBuffer"),
PpcImportDispatcherTarget::DSpContextGetBackBuffer
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_SwapBuffers"),
PpcImportDispatcherTarget::DSpContextSwapBuffers
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetDisplayID"),
PpcImportDispatcherTarget::DSpContextGetDisplayID
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetAttributes"),
PpcImportDispatcherTarget::DSpContextGetAttributes
);
}
#[test]
fn import_bindings_classify_input_sprocket_imports() {
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpElement_NewVirtualFromNeeds"),
PpcImportDispatcherTarget::ISpElementNewVirtualFromNeeds
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpDevices_Extract"),
PpcImportDispatcherTarget::ISpDevicesExtract
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpDevices_ExtractByClass"),
PpcImportDispatcherTarget::ISpDevicesExtractByClass
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpDevice_GetElementList"),
PpcImportDispatcherTarget::ISpDeviceGetElementList
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpElementList_Extract"),
PpcImportDispatcherTarget::ISpElementListExtract
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpElement_GetInfo"),
PpcImportDispatcherTarget::ISpElementGetInfo
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpElement_GetSimpleState"),
PpcImportDispatcherTarget::ISpElementGetSimpleState
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpInit"),
PpcImportDispatcherTarget::ISpInit
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpStop"),
PpcImportDispatcherTarget::ISpStop
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpSuspend"),
PpcImportDispatcherTarget::ISpSuspend
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpResume"),
PpcImportDispatcherTarget::ISpResume
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpDevices_Activate"),
PpcImportDispatcherTarget::ISpDevicesActivate
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpDevices_Deactivate"),
PpcImportDispatcherTarget::ISpDevicesDeactivate
);
assert_eq!(
dispatcher_target_for_import("InputSprocketLib", "ISpConfigure"),
PpcImportDispatcherTarget::ISpConfigure
);
}
#[test]
fn startup_probe_halts_at_first_import_and_preserves_symbol_index() {
let pef = synthetic_pef();
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_until_import_or_fault(64);
assert_eq!(probe.first_import_index, Some(0));
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_IMPORT_TRAP_BASE,
cycles: 4,
}
);
let binding = loaded.import_binding(0).unwrap();
assert_eq!(binding.library_name, "InterfaceLib");
assert_eq!(binding.symbol_name, "TestImport");
}
#[test]
fn hle_import_runner_reports_unsupported_import_without_side_effects() {
let pef = synthetic_pef();
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 0);
assert_eq!(probe.last_import_index, Some(0));
assert_eq!(probe.unsupported_import_index, Some(0));
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_IMPORT_TRAP_BASE,
cycles: 4,
}
);
assert_eq!(loaded.heap_cursor(), PPC_HEAP_BASE);
}
#[test]
fn hle_import_runner_reuses_retained_state_allocations_between_slices() {
let pef = synthetic_pef_with_import(b"TickCount");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.q3_objects.reserve(8);
loaded.q3_objects.push(test_q3_object(0x1000, 0x2000));
let imports_ptr = loaded.imports.as_ptr();
let imports_capacity = loaded.imports.capacity();
let q3_objects_ptr = loaded.q3_objects.as_ptr();
let q3_objects_capacity = loaded.q3_objects.capacity();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.imports.as_ptr(), imports_ptr);
assert_eq!(loaded.imports.capacity(), imports_capacity);
assert_eq!(loaded.q3_objects.as_ptr(), q3_objects_ptr);
assert_eq!(loaded.q3_objects.capacity(), q3_objects_capacity);
assert_eq!(loaded.q3_objects.len(), 1);
}
#[test]
fn hle_import_runner_traces_supported_import_context_when_requested() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[2] = 0x1234_5678;
loaded.cpu.gpr[3] = 16;
let probe = loaded.run_with_hle_import_trace(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(probe.import_trace.len(), 1);
let entry = &probe.import_trace[0];
assert_eq!(entry.import_index, 0);
assert_eq!(entry.library_name, "InterfaceLib");
assert_eq!(entry.symbol_name, "NewPtrClear");
assert_eq!(entry.pc, PPC_IMPORT_TRAP_BASE);
assert_eq!(entry.rtoc, 0x1234_5678);
assert_eq!(entry.sp, loaded.stack_pointer);
assert_eq!(
entry.dispatcher_target,
PpcImportDispatcherTarget::NewPtr { clear: true }
);
}
#[test]
fn hle_import_runner_records_fetch_histogram_when_requested() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 16;
let normal_probe = loaded.run_with_hle_imports(64);
assert!(normal_probe.fetch_histogram.is_none());
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 16;
let probe = loaded.run_with_hle_import_fetch_histogram(64);
let histogram = probe
.fetch_histogram
.as_ref()
.expect("histogram should be present for explicit fetch probe");
assert_eq!(probe.handled_import_count, 1);
assert_eq!(histogram.total(), 7);
assert_eq!(histogram.primary_count(19), 2);
assert_eq!(histogram.primary_count(31), 2);
assert_eq!(histogram.secondary_count(19, 16), 1);
assert_eq!(histogram.secondary_count(19, 528), 1);
assert_eq!(histogram.secondary_count(31, 467), 2);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 16;
let probe = loaded.run_with_hle_import_trace_and_fetch_histogram(64);
assert_eq!(probe.import_trace.len(), 1);
assert!(probe.fetch_histogram.is_some());
}
#[test]
fn hle_import_runner_handles_new_ptr_clear_and_continues() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 24;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.last_import_index, Some(0));
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 8,
}
);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE);
assert_eq!(loaded.last_mem_error(), 0);
assert_eq!(loaded.cpu.gpr[3] & (PPC_HEAP_ALIGNMENT - 1), 0);
assert_eq!(
loaded.heap_cursor(),
PPC_HEAP_BASE + ppc_allocation_size(24).unwrap()
);
for offset in 0..24 {
assert_eq!(loaded.memory.read_u8(PPC_HEAP_BASE + offset), Some(0));
}
assert_eq!(
loaded.ptrs(),
vec![PpcPtrRecord {
ptr: PPC_HEAP_BASE,
size: 24
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetPtrSize;
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 24);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposePtr;
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(loaded.ptrs().is_empty());
assert_eq!(
loaded.free_ptr_blocks(),
vec![PpcPtrRecord {
ptr: PPC_HEAP_BASE,
size: 24
}]
);
let heap_cursor = loaded.heap_cursor();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::NewPtr { clear: true };
loaded.cpu.gpr[3] = 12;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert!(loaded.free_ptr_blocks().is_empty());
assert_eq!(loaded.ptrs()[0].size, 12);
}
#[test]
fn hle_import_runner_ptr_to_hand_copies_bytes_into_a_new_handle() {
let pef = synthetic_pef_with_import(b"PtrToHand");
let mut loaded = load_pef_application(&pef).unwrap();
let source_ptr = PPC_DATA_BASE + 0x1000;
let destination_handle_ptr = source_ptr + 16;
loaded.memory.add_region(source_ptr, vec![0; 32]);
for (offset, byte) in b"Gridz".iter().copied().enumerate() {
loaded
.memory
.write_u8(source_ptr + offset as u32, byte)
.unwrap();
}
loaded.cpu.gpr[3] = source_ptr;
loaded.cpu.gpr[4] = destination_handle_ptr;
loaded.cpu.gpr[5] = 5;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let handle = loaded.memory.read_u32_be(destination_handle_ptr).unwrap();
assert_ne!(handle, 0);
assert_eq!(
ppc_handle_bytes(&mut loaded.memory, &test_handle_records!(loaded), handle),
Some(b"Gridz".to_vec())
);
}
#[test]
fn hle_import_runner_builds_new_routine_descriptor() {
let pef = synthetic_pef_with_import(b"NewRoutineDescriptor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_CODE_BASE;
loaded.cpu.gpr[4] = 0x1234_5678;
loaded.cpu.gpr[5] = PPC_ROUTINE_RECORD_POWERPC_ISA as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 8,
}
);
let descriptor = loaded.cpu.gpr[3];
assert_eq!(descriptor, PPC_HEAP_BASE);
assert_eq!(
loaded.heap_cursor(),
PPC_HEAP_BASE + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE + PPC_ROUTINE_RECORD_SIZE
);
assert_eq!(
loaded.memory.read_u16_be(descriptor),
Some(PPC_MIXED_MODE_TRAP)
);
assert_eq!(
loaded.memory.read_u8(descriptor + 2),
Some(PPC_ROUTINE_DESCRIPTOR_VERSION)
);
assert_eq!(loaded.memory.read_u16_be(descriptor + 10), Some(0));
let record = descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE;
assert_eq!(loaded.memory.read_u32_be(record), Some(0x1234_5678));
assert_eq!(
loaded
.memory
.read_u8(record + PPC_ROUTINE_RECORD_ISA_OFFSET),
Some(PPC_ROUTINE_RECORD_POWERPC_ISA)
);
assert_eq!(
loaded
.memory
.read_u16_be(record + PPC_ROUTINE_RECORD_FLAGS_OFFSET),
Some(PPC_ROUTINE_FLAG_USE_NATIVE_ISA)
);
assert_eq!(
loaded
.memory
.read_u32_be(record + PPC_ROUTINE_RECORD_PROC_DESCRIPTOR_OFFSET),
Some(PPC_CODE_BASE)
);
}
#[test]
fn hle_import_runner_handles_trap_address_queries() {
for (symbol, target, toolbox) in [
(
b"NGetTrapAddress".as_slice(),
PpcImportDispatcherTarget::NGetTrapAddress,
true,
),
(
b"GetToolTrapAddress".as_slice(),
PpcImportDispatcherTarget::GetToolTrapAddress,
true,
),
(
b"GetOSTrapAddress".as_slice(),
PpcImportDispatcherTarget::GetOSTrapAddress,
false,
),
] {
let pef = synthetic_pef_with_import(symbol);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.imports[0].dispatcher_target = target;
loaded.cpu.gpr[3] = 0xFFFF_A800;
loaded.cpu.gpr[4] = u32::from(toolbox);
let expected: u32 = if toolbox { 0x1234_5678 } else { 0x8765_4321 };
loaded.memory.add_region(
ppc_raw_trap_table_entry(0xA800, toolbox),
expected.to_be_bytes().to_vec(),
);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1, "{symbol:?}");
assert_eq!(probe.unsupported_import_index, None, "{symbol:?}");
assert_eq!(loaded.cpu.gpr[3], expected, "{symbol:?}");
}
}
#[test]
fn hle_import_runner_handles_supported_trap_address_setters() {
for (symbol, target, toolbox, general) in [
(
b"SetToolTrapAddress".as_slice(),
PpcImportDispatcherTarget::SetToolTrapAddress,
true,
false,
),
(
b"SetOSTrapAddress".as_slice(),
PpcImportDispatcherTarget::SetOSTrapAddress,
false,
false,
),
(
b"NSetTrapAddress".as_slice(),
PpcImportDispatcherTarget::NSetTrapAddress,
true,
true,
),
(
b"NSetTrapAddress".as_slice(),
PpcImportDispatcherTarget::NSetTrapAddress,
false,
true,
),
] {
let pef = synthetic_pef_with_import(symbol);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.imports[0].dispatcher_target = target;
let trap_word = 0xFFFF_A823u32;
let entry = ppc_raw_trap_table_entry(trap_word as u16, toolbox);
loaded
.memory
.add_region(entry, 0x1234_5678u32.to_be_bytes().to_vec());
loaded.cpu.gpr[3] = PPC_CODE_BASE;
loaded.cpu.gpr[4] = trap_word;
loaded.cpu.gpr[5] = u32::from(general && toolbox);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1, "{symbol:?}");
assert_eq!(probe.unsupported_import_index, None, "{symbol:?}");
assert_eq!(loaded.memory.read_u32_be(entry), Some(PPC_CODE_BASE));
}
}
#[test]
fn native_trap_apis_do_not_promote_a_writable_signature_to_a_protected_head() {
let trap_word = 0xA823;
let table_entry = ppc_raw_trap_table_entry(trap_word, true);
let writable_head: u32 = 0x0030_0000;
let apparent_successor: u32 = 0x0040_0000;
let replacement: u32 = 0x0050_0000;
let mut memory = PpcSectionMem::new();
memory.add_region(table_entry, writable_head.to_be_bytes().to_vec());
let mut head_bytes = Vec::from(
crate::trap::manager::COME_FROM_PATCH_SIGNATURE.to_be_bytes(),
);
head_bytes.extend_from_slice(&apparent_successor.to_be_bytes());
memory.add_region(writable_head, head_bytes);
assert_eq!(
ppc_logical_trap_address(&mut memory, trap_word, true),
Some(writable_head)
);
assert!(ppc_set_logical_trap_address(
&mut memory,
trap_word,
true,
replacement,
));
assert_eq!(memory.read_u32_be(table_entry), Some(replacement));
assert_eq!(
memory.read_u32_be(writable_head + 4),
Some(apparent_successor)
);
}
#[test]
fn native_trap_apis_share_permanent_come_from_topology() {
let pef = synthetic_pef_with_import(b"NGetTrapAddress");
let mut loaded = load_pef_application(&pef).unwrap();
let mut bus = MacMemoryBus::new(8 * 1024 * 1024);
let mut dispatcher = TrapDispatcher::new();
dispatcher
.materialize_trap_tables(
&mut bus,
crate::trap::dispatch::TrapTableProfile::PowerPc604,
)
.expect("trap table construction requires writable cells and system storage");
let trap_word = 0xA823u16;
let table_entry = ppc_raw_trap_table_entry(trap_word, true);
let head = bus.read_long(table_entry);
let original = bus.read_long(head + 4);
let second_head = bus.alloc_synthetic(10);
bus.write_readonly_code_word(second_head, 0x6006);
bus.write_readonly_code_word(second_head + 2, 0x4ef9);
bus.write_readonly_code_word(second_head + 4, (original >> 16) as u16);
bus.write_readonly_code_word(second_head + 6, original as u16);
bus.write_readonly_code_word(second_head + 8, 0x60f8);
bus.protect_readonly_code(second_head, 10);
bus.write_readonly_code_word(head + 4, (second_head >> 16) as u16);
bus.write_readonly_code_word(head + 6, second_head as u16);
for (base, len) in [
(
crate::trap::dispatch::OS_TRAP_TABLE_BASE,
u32::from(crate::trap::dispatch::OS_TRAP_TABLE_SLOTS) * 4,
),
(
crate::trap::dispatch::TOOLBOX_TRAP_TABLE_BASE,
u32::from(crate::trap::dispatch::TOOLBOX_TRAP_TABLE_SLOTS) * 4,
),
] {
let region = bus.shared_ram_region(base, len).unwrap();
// SAFETY: this focused fixture serializes the two adapters.
unsafe { loaded.memory.add_shared_region(base, region) };
}
let (synthetic_base, synthetic) = bus.shared_synthetic_reservation().unwrap();
// SAFETY: this focused fixture serializes the two adapters.
unsafe {
loaded.memory.add_shared_readonly_region(
Some(GuestIsa::M68k),
synthetic_base,
synthetic,
)
};
let ds_err = bus
.shared_ram_region(crate::memory::globals::addr::DS_ERR_CODE, 2)
.unwrap();
// SAFETY: this focused fixture serializes the two adapters.
unsafe {
loaded
.memory
.add_shared_region(crate::memory::globals::addr::DS_ERR_CODE, ds_err)
};
assert_eq!(bus.read_long(head), 0x6006_4ef9);
assert_eq!(bus.read_long(head + 4), second_head);
assert_eq!(bus.read_long(second_head), 0x6006_4ef9);
assert_eq!(bus.read_long(second_head + 4), original);
// The 68K Trap Manager and the PPC import adapter must observe one
// raw guest table, including the hidden successor of a permanent
// come-from chain. Mutate the chain through the 68K-side service and
// read it through the PPC side before exercising the inverse route.
assert_eq!(
dispatcher.trap_table_address(&bus, trap_word),
Some(original)
);
let m68k_patch = 0x0022_0000;
dispatcher
.install_trap_address(&mut bus, trap_word, m68k_patch)
.expect("68K patch must install into the materialized table");
assert_eq!(bus.read_long(table_entry), head);
assert_eq!(bus.read_long(head + 4), second_head);
assert_eq!(bus.read_long(second_head + 4), m68k_patch);
loaded.cpu.gpr[3] = u32::from(trap_word);
loaded.cpu.gpr[4] = 1;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], m68k_patch);
loaded.cpu.gpr[3] = 0xAA6E;
loaded.cpu.gpr[4] = 1;
loaded.run_with_hle_imports(64);
let unimplemented = loaded.cpu.gpr[3];
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0xAA57;
loaded.cpu.gpr[4] = 1;
loaded.run_with_hle_imports(64);
assert_ne!(loaded.cpu.gpr[3], unimplemented);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = u32::from(trap_word);
loaded.cpu.gpr[4] = 1;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], m68k_patch);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::NSetTrapAddress;
loaded.cpu.gpr[3] = head;
loaded.cpu.gpr[4] = u32::from(trap_word);
loaded.cpu.gpr[5] = 1;
loaded.run_with_hle_imports(64);
assert_eq!(bus.read_word(crate::memory::globals::addr::DS_ERR_CODE), 12);
assert_eq!(bus.read_long(table_entry), head);
assert_eq!(bus.read_long(head + 4), second_head);
assert_eq!(bus.read_long(second_head + 4), m68k_patch);
let replacement = PPC_CODE_BASE;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = replacement;
loaded.cpu.gpr[4] = u32::from(trap_word);
loaded.cpu.gpr[5] = 1;
loaded.run_with_hle_imports(64);
assert_eq!(bus.read_long(table_entry), head);
assert_eq!(bus.read_long(head + 4), second_head);
assert_eq!(bus.read_long(second_head + 4), replacement);
assert_eq!(loaded.memory.write_u32_be(second_head + 4, original), None);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::NGetTrapAddress;
loaded.cpu.gpr[3] = u32::from(trap_word);
loaded.cpu.gpr[4] = 1;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], replacement);
loaded
.memory
.write_u32_be(table_entry, original)
.expect("raw trap table remains guest-writable");
assert_eq!(bus.read_long(table_entry), original);
assert_eq!(
dispatcher.trap_table_address(&bus, trap_word),
Some(original),
"68K getter must observe a PPC-side raw table overwrite"
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = u32::from(trap_word);
loaded.cpu.gpr[4] = 1;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], original);
}
#[test]
fn ppc_heap_allocation_skips_shared_system_reservation() {
let mut memory = PpcSectionMem::new();
let mut bus = MacMemoryBus::new(8 * 1024 * 1024);
let (reservation_base, reservation) = bus.shared_synthetic_reservation().unwrap();
let reservation_len = u32::try_from(reservation.len()).unwrap();
let local_base = reservation_base - PPC_HEAP_ALIGNMENT;
memory.add_region(
local_base,
vec![0xff; usize::try_from(reservation_len + 3 * PPC_HEAP_ALIGNMENT).unwrap()],
);
bus.write_byte(reservation_base, 0x5a);
// SAFETY: this focused fixture serializes the two adapters.
unsafe {
memory.add_shared_readonly_region(Some(GuestIsa::M68k), reservation_base, reservation);
}
let mut heap_cursor = local_base;
let reservation_end = reservation_base + reservation_len;
let tight_limit = reservation_end + PPC_HEAP_ALIGNMENT;
let heap_limit = reservation_base + reservation_len + 3 * PPC_HEAP_ALIGNMENT;
assert_eq!(
ppc_heap_free_capacity(&memory, heap_cursor, heap_limit),
(4 * PPC_HEAP_ALIGNMENT, 3 * PPC_HEAP_ALIGNMENT)
);
assert!(!ppc_heap_can_alloc_sequence(
&memory,
heap_cursor,
tight_limit,
&[PPC_HEAP_ALIGNMENT, PPC_HEAP_ALIGNMENT],
));
assert!(!ppc_heap_can_alloc_repeated(
&memory,
heap_cursor,
tight_limit,
PPC_HEAP_ALIGNMENT,
2,
));
assert!(ppc_heap_can_alloc_sequence(
&memory,
heap_cursor,
heap_limit,
&[PPC_HEAP_ALIGNMENT, PPC_HEAP_ALIGNMENT],
));
assert!(ppc_heap_can_alloc_repeated(
&memory,
heap_cursor,
heap_limit,
PPC_HEAP_ALIGNMENT,
2,
));
let allocation = ppc_heap_alloc(
&mut memory,
&mut heap_cursor,
heap_limit,
2 * PPC_HEAP_ALIGNMENT,
true,
);
assert_eq!(allocation, reservation_end);
assert_eq!(heap_cursor, allocation + 2 * PPC_HEAP_ALIGNMENT);
assert_eq!(
ppc_heap_free_capacity(&memory, heap_cursor, heap_limit),
(PPC_HEAP_ALIGNMENT, PPC_HEAP_ALIGNMENT)
);
assert_eq!(bus.read_byte(reservation_base), 0x5a);
assert_eq!(memory.read_u8(allocation), Some(0));
}
#[test]
fn ppc_loader_excludes_system_reservation_before_initializer_allocations() {
let reservation_base = PPC_HEAP_BASE + PPC_HEAP_ALIGNMENT;
let mut bus = MacMemoryBus::new((reservation_base + 0x0009_0000) as usize);
let reservation = bus.synthetic_reservation_range().unwrap();
assert_eq!(reservation.0, reservation_base);
bus.write_byte(reservation_base, 0x5a);
let mut loaded = load_pef_application_with_config_and_system_reservation(
&synthetic_pef_with_initializer(),
PpcLoadConfig::default(),
reservation,
)
.unwrap();
let reservation_end = reservation.0 + reservation.1;
assert!(loaded.heap_cursor() > reservation_end);
assert!(loaded
.memory
.has_readonly_allocation_exclusion(reservation.0, reservation.1));
assert_eq!(
loaded.memory.read_u32_be(PPC_APPLICATION_ZONE + 12),
Some(
ppc_heap_free_capacity(
&loaded.memory,
loaded.heap_cursor(),
test_heap_limit!(loaded)
)
.0
)
);
assert_eq!(bus.read_byte(reservation_base), 0x5a);
let mut installed = loaded.clone();
assert!(installed.prepare_shared_system_reservation(reservation.0, reservation.1));
let (shared_base, shared) = bus.shared_synthetic_reservation().unwrap();
// SAFETY: this focused fixture serializes both adapters.
unsafe {
installed
.memory
.add_shared_readonly_region(Some(GuestIsa::M68k), shared_base, shared)
};
assert!(!installed
.memory
.has_readonly_allocation_exclusion(reservation.0, reservation.1));
assert!(installed
.memory
.shared_view()
.is_shared_readonly_range(reservation.0, 1));
assert_eq!(installed.memory.write_u8(reservation.0, 0xff), None);
assert_eq!(bus.read_byte(reservation_base), 0x5a);
}
#[test]
fn ppc_memory_reporting_excludes_system_reservation() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"FreeMem")).unwrap();
let reservation_base = PPC_HEAP_BASE + 0x1000;
let reservation_len = 0x1_0000;
loaded
.memory
.add_readonly_allocation_exclusion(reservation_base, reservation_len)
.unwrap();
loaded.set_heap_limit(reservation_base + reservation_len + 0x2000);
let expected = (0x3000, 0x2000);
assert_eq!(
ppc_heap_free_capacity(
&loaded.memory,
loaded.heap_cursor(),
test_heap_limit!(loaded)
),
expected
);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], expected.0, "FreeMem total");
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MaxMem;
loaded.cpu.gpr[3] = 0;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], expected.1, "MaxMem largest block");
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::PurgeMem;
loaded.cpu.gpr[3] = expected.1 + 1;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.last_mem_error(), PPC_MEM_FULL_ERR);
let allocation = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
PPC_HEAP_ALIGNMENT,
true,
);
assert_eq!(allocation, PPC_HEAP_BASE);
assert_eq!(
loaded.memory.read_u32_be(PPC_APPLICATION_ZONE + 12),
Some(expected.0 - PPC_HEAP_ALIGNMENT),
"zcbFree total"
);
}
#[test]
fn native_generated_code_uses_owned_system_provenance() {
let mut loaded = load_pef_application(&synthetic_pef_with_initializer()).unwrap();
for base in [
PPC_IMPORT_TVECTOR_BASE,
PPC_IMPORT_TRAP_BASE,
PPC_CFM_MAIN_STUB_BASE,
PPC_APPLICATION_INIT_RETURN_PC,
] {
let word = loaded.memory.read_u32_be(base).unwrap();
assert_eq!(loaded.memory.system_code_isa(base), Some(GuestIsa::PowerPc));
assert!(loaded
.memory
.shared_view()
.is_shared_readonly_range(base, 4));
assert!(!loaded.prepare_shared_system_reservation(base, 4));
assert_eq!(loaded.memory.write_u32_be(base, word ^ u32::MAX), None);
loaded.memory.add_region(base, vec![0xff; 4]);
assert_eq!(loaded.memory.read_u32_be(base), Some(word));
let mut detached = loaded.memory.clone();
assert_eq!(
detached.write_shared_system_u32_be(base, word ^ u32::MAX),
Some(())
);
assert_eq!(detached.read_u32_be(base), Some(word ^ u32::MAX));
assert_eq!(loaded.memory.read_u32_be(base), Some(word));
}
assert!(!loaded
.memory
.shared_view()
.is_shared_readonly_range(PPC_CODE_BASE, 4));
}
#[test]
fn ppc_loader_rejects_system_reservation_layout_collisions() {
fn reservation_at(base: u32) -> (MacMemoryBus, (u32, u32)) {
let bus = MacMemoryBus::new((base + 0x0009_0000) as usize);
let reservation = bus.synthetic_reservation_range().unwrap();
assert_eq!(reservation.0, base);
(bus, reservation)
}
let safe_gap_bus = MacMemoryBus::new(8 * 1024 * 1024);
load_pef_application_with_config_and_system_reservation(
&synthetic_pef(),
PpcLoadConfig::default(),
safe_gap_bus.synthetic_reservation_range().unwrap(),
)
.expect("the 8 MiB runner reservation occupies a native-layout gap");
for base in [
PPC_CODE_BASE,
PPC_MAIN_GWORLD,
PPC_IMPORT_TVECTOR_BASE,
PPC_IMPORT_TRAP_BASE,
PPC_CFM_MAIN_STUB_BASE,
] {
let (_bus, reservation) = reservation_at(base);
assert_eq!(
load_pef_application_with_config_and_system_reservation(
&synthetic_pef(),
PpcLoadConfig::default(),
reservation,
)
.unwrap_err(),
PpcLoadError::AddressOverflow,
"reservation at {base:#010x}"
);
}
let trampoline_reservation_base = PPC_APPLICATION_INIT_RETURN_PC + 44 - 64 * 1024;
let (_bus, trampoline_reservation) = reservation_at(trampoline_reservation_base);
load_pef_application_with_config_and_system_reservation(
&synthetic_pef(),
PpcLoadConfig::default(),
trampoline_reservation,
)
.expect("the sparse non-initializer layout remains valid");
assert_eq!(
load_pef_application_with_config_and_system_reservation(
&synthetic_pef_with_initializer(),
PpcLoadConfig::default(),
trampoline_reservation,
)
.unwrap_err(),
PpcLoadError::AddressOverflow
);
let stack_base = PPC_HEAP_BASE + 0x1000;
let (_bus, stack_reservation) = reservation_at(stack_base);
assert_eq!(
load_pef_application_with_config_and_system_reservation(
&synthetic_pef(),
PpcLoadConfig {
stack_size: PPC_STACK_TOP - stack_base,
..PpcLoadConfig::default()
},
stack_reservation,
)
.unwrap_err(),
PpcLoadError::AddressOverflow
);
}
#[test]
fn public_ppc_loader_late_reservation_guard_preserves_mapped_state() {
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let original_code = loaded.memory.read_u32_be(PPC_CODE_BASE);
assert!(!loaded.prepare_shared_system_reservation(PPC_CODE_BASE, 64 * 1024));
assert_eq!(loaded.memory.read_u32_be(PPC_CODE_BASE), original_code);
assert!(loaded.prepare_shared_system_reservation(PPC_HEAP_BASE + 0x1000, 64 * 1024));
}
#[test]
fn hle_import_runner_handles_lm_get_current_a5() {
let pef = synthetic_pef_with_import(b"LMGetCurrentA5");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_DATA_BASE);
}
#[test]
fn hle_import_runner_handles_vinstall_success() {
let pef = synthetic_pef_with_import(b"VInstall");
let mut loaded = load_pef_application(&pef).unwrap();
let task_ptr = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
16,
true,
);
loaded.cpu.gpr[3] = task_ptr;
loaded.memory.write_u16_be(task_ptr + 4, 1).unwrap();
loaded.memory.write_u16_be(task_ptr + 10, 2).unwrap();
loaded.memory.write_u16_be(task_ptr + 12, 3).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u16_be(task_ptr + 10), Some(5));
assert_eq!(loaded.memory.read_u32_be(task_ptr), Some(0));
let second_task_ptr = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
16,
true,
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = second_task_ptr;
loaded.memory.write_u16_be(second_task_ptr + 4, 1).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(task_ptr), Some(second_task_ptr));
assert_eq!(loaded.memory.read_u32_be(second_task_ptr), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::VRemove;
loaded.cpu.gpr[3] = task_ptr;
loaded.memory.write_u16_be(task_ptr + 4, 1).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(second_task_ptr), Some(0));
}
#[test]
fn ppc_publish_tick_rejects_stale_candidate_after_guest_ticks_store() {
use crate::memory::globals::addr;
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
loaded.set_tick_count(41);
loaded
.memory
.write_u32_be(addr::TICKS, 7)
.expect("direct guest Ticks store");
// A native slice that started at 41 must not restore its old
// candidate after guest code rewound the writable low-memory cell.
assert_eq!(loaded.publish_tick(42), 7);
assert_eq!(loaded.memory.read_u32_be(addr::TICKS), Some(7));
}
#[test]
fn ppc_timer_manager_schedules_and_invokes_native_callbacks() {
let pef = synthetic_pef_with_import(b"InsTime");
let mut loaded = load_pef_application(&pef).unwrap();
let task_ptr = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
20,
true,
);
let callback_entry = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
16,
true,
);
// li r4, $1234; stw r4, 16(r3); blr
loaded
.memory
.write_u32_be(callback_entry, 0x3880_1234)
.unwrap();
loaded
.memory
.write_u32_be(callback_entry + 4, 0x9083_0010)
.unwrap();
loaded.memory.write_u32_be(callback_entry + 8, BLR).unwrap();
loaded
.memory
.write_u32_be(task_ptr + 6, callback_entry)
.unwrap();
loaded.cpu.gpr[3] = task_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.timer_tasks.len(), 1);
assert!(!loaded.timer_tasks[0].active);
assert_eq!(loaded.memory.read_u16_be(task_ptr + 4), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::PrimeTime;
loaded.cpu.gpr[3] = task_ptr;
loaded.cpu.gpr[4] = 33;
loaded.set_tick_count(10);
loaded.set_clock_cycle_timing(1_000, 0);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert!(loaded.timer_tasks[0].active);
assert_eq!(loaded.timer_tasks[0].fire_at_tick, 12);
assert_eq!(loaded.memory.read_u16_be(task_ptr + 4), Some(0x8000));
assert!(loaded
.fire_timer_tasks_for_ticks(10, 1, 8, 64, false, false)
.is_empty());
// Timer callbacks use the normal PPC halt return address (0) as
// their synthetic LR. That Halted result belongs to the callback;
// the interrupted foreground CPU must be restored by the dispatcher.
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let foreground_pc = loaded.cpu.pc;
let probes = loaded.fire_timer_tasks_for_ticks(11, 1, 8, 64, false, false);
assert_eq!(probes.len(), 1);
assert_eq!(probes[0].invocation.task_ptr, task_ptr);
assert_eq!(probes[0].invocation.end_r3, task_ptr);
assert!(matches!(
probes[0].invocation.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(probes[0].invocation.end_pc, PPC_HALT_PC);
assert_eq!(loaded.cpu.pc, foreground_pc);
assert_eq!(loaded.memory.read_u32_be(task_ptr + 16), Some(0x1234));
assert_eq!(loaded.memory.read_u16_be(task_ptr + 4), Some(0));
assert!(!loaded.timer_tasks[0].active);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::RmvTime;
loaded.cpu.gpr[3] = task_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert!(loaded.timer_tasks.is_empty());
assert_eq!(loaded.memory.read_u32_be(task_ptr), Some(0));
}
#[test]
fn native_extended_timer_uses_process_owned_scheduling_metadata() {
let pef = synthetic_pef_with_import(b"InsXTime");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
assert!(native
.callback_scheduling
.ptr_eq(&classic.callback_scheduling));
let task = ppc_heap_alloc(
&mut native.memory,
test_heap_cursor!(native),
test_heap_limit!(native),
22,
true,
);
native.memory.write_u32_be(task + 6, 0x1234_5678).unwrap();
native.cpu.gpr[3] = task;
native.run_with_hle_imports(64);
assert!(native.timer_tasks[0].extended);
assert!(classic.timer_tasks[0].extended);
native.set_tick_count(100);
native.set_clock_cycle_timing(1_000, 0);
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::PrimeTime;
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = task;
native.cpu.gpr[4] = (-5_000i32) as u32;
native.run_with_hle_imports(64);
assert_eq!(native.timer_tasks[0].fire_at_subtick, 100_300_000);
assert_eq!(
classic.callback_scheduling.extended_wakeup(task),
Some(100_300_000)
);
assert_ne!(native.memory.read_u32_be(task + 14), Some(0));
let detached = classic.callback_scheduling.clone();
classic.callback_scheduling.set_primary_vbl_slot(7);
classic.callback_scheduling.set_current_subtick(100_150_000);
assert_eq!(native.callback_scheduling.primary_vbl_slot(), 7);
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RmvTime;
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = task;
native.run_with_hle_imports(64);
assert_eq!(native.memory.read_u32_be(task + 10), Some((-2_500i32) as u32));
assert_eq!(detached.primary_vbl_slot(), 0);
assert_eq!(detached.current_subtick(), 100_000_000);
}
#[test]
fn vbl_callback_receives_task_record_and_can_reschedule_itself() {
let pef = synthetic_pef();
let mut loaded = load_pef_application(&pef).unwrap();
let task_ptr = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
16,
true,
);
let callback_entry = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
16,
true,
);
// li r4, 2; sth r4, 10(r3); blr
loaded
.memory
.write_u32_be(callback_entry, 0x3880_0002)
.unwrap();
loaded
.memory
.write_u32_be(callback_entry + 4, 0xb083_000a)
.unwrap();
loaded.memory.write_u32_be(callback_entry + 8, BLR).unwrap();
loaded
.memory
.write_u32_be(task_ptr + 6, callback_entry)
.unwrap();
loaded.memory.write_u16_be(task_ptr + 10, 1).unwrap();
loaded.vbl_tasks.push(PpcVblTaskRecord {
task_ptr,
architecture: CallbackTaskArchitecture::PowerPc,
slot: None,
pending: false,
});
let probes = loaded.fire_vbl_tasks_for_ticks(0, 3, 8, 64, false, false);
assert_eq!(probes.len(), 2);
assert!(probes.iter().all(|probe| {
probe.invocation.task_ptr == task_ptr
&& probe.invocation.end_r3 == task_ptr
&& matches!(
probe.invocation.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
)
}));
assert_eq!(loaded.memory.read_u16_be(task_ptr + 10), Some(2));
assert_eq!(
*loaded.vbl_tasks,
vec![PpcVblTaskRecord {
task_ptr,
architecture: CallbackTaskArchitecture::PowerPc,
slot: None,
pending: false,
}]
);
}
#[test]
fn native_callback_task_imports_mutate_the_attached_process_registry() {
let mut native = load_pef_application(&synthetic_pef()).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
assert!(native.timer_tasks.ptr_eq(&classic.timer_tasks));
assert!(native.vbl_tasks.ptr_eq(&classic.vbl_tasks));
let timer = PPC_HEAP_BASE + 0x800;
let vbl = timer + 0x20;
native.memory.add_region(timer, vec![0; 0x40]);
native.memory.write_u32_be(timer + 6, 0x1234_5678).unwrap();
native.memory.write_u16_be(vbl + 4, 1).unwrap();
native.memory.write_u16_be(vbl + 10, 2).unwrap();
let timer_tasks = native.timer_tasks.shared_handle();
let vbl_tasks = native.vbl_tasks.shared_handle();
timer_tasks.with_mut(|timer_tasks| {
ppc_install_time_task(
&mut native.memory,
timer_tasks,
&native.callback_scheduling,
timer,
false,
);
});
vbl_tasks.with_mut(|vbl_tasks| {
ppc_install_vbl_task(&mut native.memory, vbl_tasks, vbl, None);
});
assert_eq!(classic.timer_tasks.len(), 1);
assert_eq!(classic.vbl_tasks.len(), 1);
assert_eq!(classic.timer_tasks[0].architecture, CallbackTaskArchitecture::PowerPc);
assert_eq!(classic.vbl_tasks[0].architecture, CallbackTaskArchitecture::PowerPc);
let detached_timers = classic.timer_tasks.clone();
let detached_vbls = classic.vbl_tasks.clone();
timer_tasks.with_mut(|timer_tasks| {
ppc_remove_time_task(
&mut native.memory,
timer_tasks,
&native.callback_scheduling,
timer,
);
});
assert_eq!(
vbl_tasks.with_mut(|vbl_tasks| {
ppc_remove_vbl_task(&mut native.memory, vbl_tasks, vbl)
}),
PPC_NO_ERR
);
assert!(classic.timer_tasks.is_empty());
assert!(classic.vbl_tasks.is_empty());
assert_eq!(detached_timers.len(), 1);
assert_eq!(detached_vbls.len(), 1);
}
#[test]
fn hle_import_runner_builds_m68k_new_routine_descriptor_without_native_flag() {
let pef = synthetic_pef_with_import(b"NewRoutineDescriptor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0x00c0_ffee;
loaded.cpu.gpr[4] = 0x1234_5678;
loaded.cpu.gpr[5] = PPC_ROUTINE_RECORD_M68K_ISA as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 8,
}
);
let descriptor = loaded.cpu.gpr[3];
assert_eq!(
loaded
.ptrs()
.iter()
.find(|record| record.ptr == descriptor)
.map(|record| record.size),
Some(PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE + PPC_ROUTINE_RECORD_SIZE)
);
let record = descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE;
assert_eq!(
loaded
.memory
.read_u8(record + PPC_ROUTINE_RECORD_ISA_OFFSET),
Some(PPC_ROUTINE_RECORD_M68K_ISA)
);
assert_eq!(
loaded
.memory
.read_u16_be(record + PPC_ROUTINE_RECORD_FLAGS_OFFSET),
Some(0)
);
assert_eq!(
loaded
.memory
.read_u32_be(record + PPC_ROUTINE_RECORD_PROC_DESCRIPTOR_OFFSET),
Some(0x00c0_ffee)
);
}
#[test]
fn hle_import_runner_builds_new_fat_routine_descriptor() {
let pef = synthetic_pef_with_import(b"NewFatRoutineDescriptor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0x00c0_ffee;
loaded.cpu.gpr[4] = PPC_CODE_BASE;
loaded.cpu.gpr[5] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 8,
}
);
let descriptor = loaded.cpu.gpr[3];
assert_eq!(
loaded
.ptrs()
.iter()
.find(|record| record.ptr == descriptor)
.map(|record| record.size),
Some(PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE + (PPC_ROUTINE_RECORD_SIZE * 2))
);
assert_eq!(descriptor, PPC_HEAP_BASE);
assert_eq!(
loaded.heap_cursor(),
PPC_HEAP_BASE
+ ppc_allocation_size(
PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE + (PPC_ROUTINE_RECORD_SIZE * 2),
)
.unwrap()
);
assert_eq!(
loaded.memory.read_u16_be(descriptor),
Some(PPC_MIXED_MODE_TRAP)
);
assert_eq!(
loaded.memory.read_u8(descriptor + 2),
Some(PPC_ROUTINE_DESCRIPTOR_VERSION)
);
assert_eq!(loaded.memory.read_u16_be(descriptor + 10), Some(1));
let m68k_record = descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE;
assert_eq!(loaded.memory.read_u32_be(m68k_record), Some(0x1234_5678));
assert_eq!(
loaded
.memory
.read_u8(m68k_record + PPC_ROUTINE_RECORD_ISA_OFFSET),
Some(PPC_ROUTINE_RECORD_M68K_ISA)
);
assert_eq!(
loaded
.memory
.read_u16_be(m68k_record + PPC_ROUTINE_RECORD_FLAGS_OFFSET),
Some(0)
);
assert_eq!(
loaded
.memory
.read_u32_be(m68k_record + PPC_ROUTINE_RECORD_PROC_DESCRIPTOR_OFFSET),
Some(0x00c0_ffee)
);
let powerpc_record = m68k_record + PPC_ROUTINE_RECORD_SIZE;
assert_eq!(loaded.memory.read_u32_be(powerpc_record), Some(0x1234_5678));
assert_eq!(
loaded
.memory
.read_u8(powerpc_record + PPC_ROUTINE_RECORD_ISA_OFFSET),
Some(PPC_ROUTINE_RECORD_POWERPC_ISA)
);
assert_eq!(
loaded
.memory
.read_u16_be(powerpc_record + PPC_ROUTINE_RECORD_FLAGS_OFFSET),
Some(PPC_ROUTINE_FLAG_USE_NATIVE_ISA)
);
assert_eq!(
loaded
.memory
.read_u32_be(powerpc_record + PPC_ROUTINE_RECORD_PROC_DESCRIPTOR_OFFSET),
Some(PPC_CODE_BASE)
);
}
#[test]
fn hle_import_runner_disposes_and_reuses_routine_descriptor_storage() {
let pef = synthetic_pef_with_import(b"DisposeRoutineDescriptor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::NewRoutineDescriptor;
loaded.cpu.gpr[3] = 0x00c0_ffee;
loaded.cpu.gpr[4] = 0x1234_5678;
loaded.cpu.gpr[5] = PPC_ROUTINE_RECORD_M68K_ISA as u32;
let create_probe = loaded.run_with_hle_imports(64);
assert_eq!(create_probe.handled_import_count, 1);
assert_eq!(create_probe.unsupported_import_index, None);
let descriptor = loaded.cpu.gpr[3];
let descriptor_size = PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE + PPC_ROUTINE_RECORD_SIZE;
assert_eq!(
loaded
.ptrs()
.iter()
.find(|record| record.ptr == descriptor)
.map(|record| record.size),
Some(descriptor_size)
);
let heap_cursor = loaded.heap_cursor();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeRoutineDescriptor;
loaded.set_last_mem_error(PPC_MEM_FULL_ERR);
loaded.cpu.gpr[3] = descriptor;
let dispose_probe = loaded.run_with_hle_imports(64);
assert_eq!(dispose_probe.handled_import_count, 1);
assert_eq!(dispose_probe.unsupported_import_index, None);
assert_eq!(
dispose_probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 8,
}
);
assert_eq!(loaded.cpu.gpr[3], descriptor);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert!(!loaded.ptrs().iter().any(|record| record.ptr == descriptor));
assert!(loaded
.free_ptr_blocks()
.iter()
.any(|record| record.ptr == descriptor && record.size == descriptor_size));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::NewRoutineDescriptor;
loaded.cpu.gpr[3] = 0x00c0_ffee;
loaded.cpu.gpr[4] = 0x1234_5678;
loaded.cpu.gpr[5] = PPC_ROUTINE_RECORD_M68K_ISA as u32;
let recreate_probe = loaded.run_with_hle_imports(64);
assert_eq!(recreate_probe.handled_import_count, 1);
assert_eq!(recreate_probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], descriptor);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert!(loaded
.ptrs()
.iter()
.any(|record| record.ptr == descriptor && record.size == descriptor_size));
assert!(!loaded
.free_ptr_blocks()
.iter()
.any(|record| record.ptr == descriptor));
}
#[test]
fn hle_import_runner_does_not_dispose_untracked_routine_descriptor() {
let pef = synthetic_pef_with_import(b"DisposeRoutineDescriptor");
let mut loaded = load_pef_application(&pef).unwrap();
let heap_cursor = loaded.heap_cursor();
let ptrs = loaded.ptrs().clone();
let free_ptr_blocks = loaded.free_ptr_blocks().clone();
loaded.set_last_mem_error(PPC_MEM_FULL_ERR);
loaded.cpu.gpr[3] = PPC_HEAP_BASE + 0x40;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE + 0x40);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(loaded.ptrs(), ptrs);
assert_eq!(loaded.free_ptr_blocks(), free_ptr_blocks);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn hle_import_runner_call_universal_proc_enters_native_ppc_descriptor_and_restores_rtoc() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_stack_proc_info(
PPC_PROCINFO_SIZE_FOUR,
&[PPC_PROCINFO_SIZE_FOUR, PPC_PROCINFO_SIZE_FOUR],
);
let stw_r3_0_r2 = (36u32 << 26) | (3u32 << 21) | (2u32 << 16);
let stw_r4_4_r2 = (36u32 << 26) | (4u32 << 21) | (2u32 << 16) | 4;
let stw_r2_8_r2 = (36u32 << 26) | (2u32 << 21) | (2u32 << 16) | 8;
let addi_r3_r3_7 = (14u32 << 26) | (3u32 << 21) | (3u32 << 16) | 7;
let mut callback = Vec::new();
for word in [stw_r3_0_r2, stw_r4_4_r2, stw_r2_8_r2, addi_r3_r3_7, BLR] {
callback.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(callback_entry, callback);
loaded.memory.add_region(callback_rtoc, vec![0; 0x100]);
loaded.memory.add_region(descriptor, vec![0; 0x100]);
loaded
.memory
.write_u16_be(descriptor, PPC_MIXED_MODE_TRAP)
.unwrap();
loaded
.memory
.write_u8(descriptor + 2, PPC_ROUTINE_DESCRIPTOR_VERSION)
.unwrap();
loaded.memory.write_u16_be(descriptor + 10, 0).unwrap();
ppc_write_routine_record(
&mut loaded.memory,
descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE,
proc_info,
PPC_ROUTINE_RECORD_POWERPC_ISA,
PPC_ROUTINE_FLAG_USE_NATIVE_ISA,
tvector,
);
loaded.memory.write_u32_be(tvector, callback_entry).unwrap();
loaded
.memory
.write_u32_be(tvector + 4, callback_rtoc)
.unwrap();
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x10;
loaded.cpu.gpr[6] = 0x20;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 14,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0x17);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x10));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 4), Some(0x20));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 8),
Some(callback_rtoc)
);
assert!(loaded.guest_calls().is_empty());
}
#[test]
fn reverse_mixed_mode_activation_uses_the_native_worker_stack_and_retries_overflow() {
use crate::guest_call::{ExecutionTaskId, GuestCallTarget, PowerPcArguments};
const MADE: u32 = PPC_DATA_BASE + 0x2000;
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"NewThread")).unwrap();
loaded.memory.add_region(MADE, vec![0; 4]);
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = PPC_CODE_BASE;
loaded.cpu.gpr[5] = 17;
loaded.cpu.gpr[6] = 4096;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = 0;
loaded.cpu.gpr[9] = MADE;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], 0);
let worker = ExecutionTaskId::from_thread_id(loaded.memory.read_u32_be(MADE).unwrap());
assert!(loaded.toolbox_startup.execution.calls()
.yield_native_thread(&mut loaded.cpu, worker.thread_id())
.unwrap());
let storage = loaded.guest_calls().thread_storage(worker).unwrap();
let worker_sp = loaded.cpu.gpr[1];
assert!(worker_sp < loaded.stack_base);
assert!(loaded.guest_calls()
.switch_to_task(ExecutionTaskId::APPLICATION));
assert_eq!(
loaded.guest_calls()
.native_stack_bounds(loaded.stack_base, PPC_STACK_TOP),
Some((storage.stack_base, storage.stack_limit))
);
assert!(loaded.guest_calls().switch_to_task(worker));
assert!(loaded.guest_calls().begin_m68k_to_powerpc(
GuestCallTarget {
isa: GuestIsa::PowerPc,
entry: PPC_CODE_BASE + 0x1000,
rtoc: PPC_DATA_BASE,
},
PowerPcArguments::from_slice(&[42]).unwrap(),
0x0010_0000,
0x0010_1000,
None,
));
let mut classic = crate::cpu::M68kCpu::new();
classic.write_reg(crate::cpu::Register::PC, 0x0010_0000);
loaded
.memory
.add_region(storage.stack_base - 64, vec![0; 64]);
// Both surrounding addresses are mapped. Mapping
// alone must not permit a frame outside this worker's allocation.
for invalid_sp in [storage.stack_base + 16, storage.stack_limit + 16] {
loaded.cpu.gpr[1] = invalid_sp;
let before = loaded.cpu.clone();
let sentinel = invalid_sp - 64;
loaded.memory.write_u32_be(sentinel, 0xface_cafe).unwrap();
assert!(loaded.activate_powerpc_from_m68k(&mut classic).is_none());
assert_eq!(loaded.cpu.gpr, before.gpr);
assert_eq!(loaded.cpu.pc, before.pc);
assert_eq!(loaded.cpu.lr, before.lr);
assert_eq!(loaded.cpu.cr, before.cr);
assert_eq!(loaded.cpu.fpr, before.fpr);
assert_eq!(classic.read_reg(crate::cpu::Register::PC), 0x0010_0000);
assert_eq!(loaded.memory.read_u32_be(sentinel), Some(0xface_cafe));
assert!(loaded.guest_calls().pending_powerpc_from_m68k().is_some());
assert!(!loaded.guest_calls().has_parked_m68k_contexts());
}
loaded.cpu.gpr[1] = worker_sp;
loaded.activate_powerpc_from_m68k(&mut classic).unwrap();
let callback_sp = loaded.cpu.gpr[1];
assert!(callback_sp >= storage.stack_base && callback_sp < worker_sp);
assert_eq!(callback_sp & 15, 0);
assert_eq!(loaded.memory.read_u32_be(callback_sp), Some(worker_sp));
assert_eq!(loaded.cpu.gpr[3], 42);
assert_eq!(loaded.cpu.pc, PPC_CODE_BASE + 0x1000);
assert!(loaded.guest_calls().has_parked_m68k_contexts());
}
#[test]
fn reverse_mixed_mode_activation_builds_a_protected_native_parameter_area() {
let pef = synthetic_pef();
let mut loaded = load_pef_application(&pef).unwrap();
let caller = loaded.cpu.clone();
let values: Vec<u32> = (1..=crate::guest_call::MAX_POWERPC_GUEST_ARGUMENTS as u32)
.map(|value| 0x1000_0000 | value)
.collect();
let arguments = crate::guest_call::PowerPcArguments::from_slice(&values).unwrap();
assert!(loaded.guest_calls().begin_m68k_to_powerpc(
crate::guest_call::GuestCallTarget {
isa: GuestIsa::PowerPc,
entry: PPC_CODE_BASE + 0x1000,
rtoc: PPC_DATA_BASE + 0x2000,
},
arguments,
0x0010_0000,
0x0010_1000,
None,
));
loaded
.activate_powerpc_from_m68k(&mut crate::cpu::M68kCpu::new())
.unwrap();
let callback_sp = loaded.cpu.gpr[1];
assert!(callback_sp < caller.gpr[1]);
assert_eq!(callback_sp & 0x0f, 0);
assert_eq!(
loaded
.memory
.read_u32_be(callback_sp + PPC_LINKAGE_BACK_CHAIN_OFFSET),
Some(caller.gpr[1])
);
assert_eq!(
loaded
.memory
.read_u32_be(callback_sp + PPC_LINKAGE_SAVED_CR_OFFSET),
Some(caller.cr)
);
assert_eq!(
loaded
.memory
.read_u32_be(callback_sp + PPC_LINKAGE_SAVED_LR_OFFSET),
Some(caller.lr)
);
assert_eq!(
loaded
.memory
.read_u32_be(callback_sp + PPC_LINKAGE_SAVED_RTOC_OFFSET),
Some(caller.gpr[2])
);
assert_eq!(
&loaded.cpu.gpr[3..=10],
&values[..PPC_NATIVE_PARAMETER_GPR_COUNT]
);
for (index, value) in values.into_iter().enumerate() {
assert_eq!(
loaded
.memory
.read_u32_be(ppc_parameter_area_slot_addr(callback_sp, index).unwrap()),
Some(value)
);
}
assert_eq!(loaded.cpu.pc, PPC_CODE_BASE + 0x1000);
assert_eq!(loaded.cpu.lr, PPC_GUEST_CALL_RETURN_PC);
assert_eq!(loaded.cpu.gpr[2], PPC_DATA_BASE + 0x2000);
}
#[test]
fn hle_import_runner_call_universal_proc_rejects_m68k_only_descriptor() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_stack_proc_info(PPC_PROCINFO_SIZE_FOUR, &[PPC_PROCINFO_SIZE_FOUR]);
loaded.memory.add_region(descriptor, vec![0; 0x100]);
loaded
.memory
.write_u16_be(descriptor, PPC_MIXED_MODE_TRAP)
.unwrap();
loaded
.memory
.write_u8(descriptor + 2, PPC_ROUTINE_DESCRIPTOR_VERSION)
.unwrap();
loaded.memory.write_u16_be(descriptor + 10, 0).unwrap();
assert!(ppc_write_routine_record(
&mut loaded.memory,
descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE,
proc_info,
PPC_ROUTINE_RECORD_M68K_ISA,
0,
0x00c0_ffee,
));
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 0);
assert_eq!(probe.unsupported_import_index, Some(0));
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_IMPORT_TRAP_BASE,
cycles: 4,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], descriptor);
}
#[test]
fn hle_import_runner_call_universal_proc_rejects_fake_trap_addresses() {
// Inside Macintosh: PowerPC System Software (1994), pp. 1-67--1-68
// and 2-42--2-43: CallUniversalProc accepts an actual universal
// procedure pointer. A host-encoded trap word is not a procedure.
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let fake_address = 0x00F0_AADBu32;
loaded.cpu.gpr[3] = fake_address;
loaded.cpu.gpr[4] = test_stack_proc_info(PPC_PROCINFO_SIZE_TWO, &[]);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 0);
assert_eq!(probe.unsupported_import_index, Some(0));
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_IMPORT_TRAP_BASE,
cycles: 4,
}
);
assert_eq!(loaded.cpu.gpr[3], fake_address);
}
#[test]
fn ppc_to_m68k_special_cases_build_every_classic_input_layout() {
use crate::guest_call::M68kResultSource;
use crate::guest_procedure::GuestProcedureRepresentation;
use crate::mixed_mode::special_case;
const RECT: u32 = PPC_DATA_BASE + 0x4000;
const RESULT: u32 = PPC_DATA_BASE + 0x4010;
const ENTRY: u32 = 0x00c0_ffee;
let a5 = PPC_DATA_BASE;
let cases = vec![
(
special_case::HIGH_HOOK,
vec![RECT, 0x1300],
[0; 8],
[0, 0, 0, 0x1300, 0, a5, 0],
(1u8..=8).collect::<Vec<_>>(),
false,
),
(
special_case::EOL_HOOK,
vec![0xffff_fff2, 0x1300, 0x1400],
[0xf2, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0x1300, 0x1400, a5, 0],
vec![],
false,
),
(
special_case::WIDTH_HOOK,
vec![0x80f2, 0xff01, 0x1000, 0x1300, 0x1400],
[0x80f2, 0xff01, 0, 0, 0, 0, 0, 0],
[0x1000, 0, 0, 0x1300, 0x1400, a5, 0],
vec![],
false,
),
(
special_case::NWIDTH_HOOK,
vec![
0x80f2,
0xff01,
0xffff_8002,
0xffff_8001,
0x1000,
0x1200,
0x1300,
0x1400,
],
[0x80f2, 0xff01, 0x8001_8002, 0, 0, 0, 0, 0],
[0x1000, 0, 0x1200, 0x1300, 0x1400, a5, 0],
vec![],
false,
),
(
special_case::DRAW_HOOK,
vec![0x80f2, 0xff01, 0x1000, 0x1300, 0x1400],
[0x80f2, 0xff01, 0, 0, 0, 0, 0, 0],
[0x1000, 0, 0, 0x1300, 0x1400, a5, 0],
vec![],
false,
),
(
special_case::HIT_TEST_HOOK,
vec![
0x80f2, 0xff01, 0x8002, 0x1000, 0x1300, 0x1400, 0x1500, 0x1600, 0x1700,
],
[0x80f2, 0xff01, 0x8002, 0, 0, 0, 0, 0],
[0x1000, 0, 0, 0x1300, 0x1400, a5, 0],
vec![],
false,
),
(
special_case::TE_FIND_WORD,
vec![0x80f2, 0xffff_8002, 0x1300, 0x1400, 0x1500, 0x1600],
[0x80f2, 0, 0x8002, 0, 0, 0, 0, 0],
[0, 0, 0, 0x1300, 0x1400, a5, 0],
vec![],
false,
),
(
special_case::PROTOCOL_HANDLER,
vec![0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0xffff_ff01],
[0, 0xff01, 0, 0, 0, 0, 0, 0],
[0x1000, 0x1100, 0x1200, 0x1300, 0x1400, a5, 0],
vec![],
false,
),
(
special_case::SOCKET_LISTENER,
vec![
0x1000,
0x1100,
0x1200,
0x1300,
0x1400,
0xffff_fff2,
0xffff_ff01,
],
[0xf2, 0xff01, 0, 0, 0, 0, 0, 0],
[0x1000, 0x1100, 0x1200, 0x1300, 0x1400, a5, 0],
vec![],
false,
),
(
special_case::TE_RECALC,
vec![0x1300, 0xffff_fffe, 0x1500, 0x1600, 0x1700],
[0, 0, 0, 0, 0, 0, 0, 0xfffe],
[0, 0, 0, 0x1300, 0, a5, 0],
vec![],
false,
),
(
special_case::TE_DO_TEXT,
vec![0x1300, 0x1234, 0x5678, 0xffff_fffe, 0x1500, 0x1600],
[0, 0, 0, 0x1234, 0x5678, 0, 0, 0xfffe],
[0, 0, 0, 0x1300, 0, a5, 0],
vec![],
false,
),
(
special_case::GNE_FILTER_PROC,
vec![0x1100, RESULT],
[1, 0, 0, 0, 0, 0, 0, 0],
[0, 0x1100, 0, 0, 0, a5, 0],
vec![0, 1],
true,
),
(
special_case::MBAR_HOOK,
vec![0xcafe_babe],
[0; 8],
[0, 0, 0, 0, 0, a5, 0],
0xcafe_babeu32.to_be_bytes().to_vec(),
false,
),
];
for (selector, arguments, data, address, stack, has_stack_result) in cases {
let pef = synthetic_pef();
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(RECT, vec![0; 0x20]);
for (offset, byte) in (1u8..=8).enumerate() {
loaded
.memory
.write_u8(RECT + u32::try_from(offset).unwrap(), byte)
.unwrap();
}
loaded.memory.write_u8(RESULT, 1).unwrap();
let proc_info = PPC_PROCINFO_SPECIAL_CASE
| (selector << crate::mixed_mode::special_case::SELECTOR_PHASE);
let expected_arguments =
crate::guest_call::PowerPcArguments::from_slice(&arguments).unwrap();
let target = GuestProcedure {
original_pointer: ENTRY,
representation: GuestProcedureRepresentation::RawCode,
isa: GuestIsa::M68k,
entry: ENTRY,
rtoc: 0,
proc_info,
routine_flags: 0,
};
let action = ppc_begin_m68k_universal_proc(
&loaded.cpu,
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut loaded.toolbox_startup,
target,
proc_info,
None,
arguments,
PPC_HALT_PC,
ppc_call_universal_proc_return_gpr3(proc_info),
);
assert!(
matches!(action, Some(PpcImportAction::Halt)),
"selector {selector}"
);
let pending = loaded.guest_calls().activate_m68k().unwrap();
assert_eq!(pending.registers.data, data, "selector {selector}");
assert_eq!(pending.registers.address, address, "selector {selector}");
assert_eq!(
pending.final_sp,
pending.initial_sp + 4,
"selector {selector}",
);
for (offset, expected) in stack.into_iter().enumerate() {
assert_eq!(
loaded
.memory
.read_u8(pending.initial_sp + 4 + u32::try_from(offset).unwrap()),
Some(expected),
"selector {selector} stack byte {offset}",
);
}
let Some(M68kResultSource::SpecialCase {
selector: result_selector,
arguments: result_arguments,
stack_result,
}) = pending.result
else {
panic!("selector {selector} did not retain a special-case result")
};
assert_eq!(u32::from(result_selector), selector);
assert_eq!(result_arguments, expected_arguments);
assert_eq!(
stack_result,
has_stack_result.then_some(pending.initial_sp + 4)
);
}
}
#[test]
fn hle_import_runner_call_universal_proc_executes_m68k_pascal_descriptor_and_result() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let proc_info = test_stack_proc_info(PPC_PROCINFO_SIZE_FOUR, &[PPC_PROCINFO_SIZE_FOUR]);
install_test_m68k_callback(
&mut loaded,
descriptor,
callback_entry,
proc_info,
0,
&[
0x202f, 0x0004, // MOVE.L 4(SP),D0
0x5e80, // ADDQ.L #7,D0
0x2f40, 0x0008, // MOVE.L D0,8(SP)
0x4e74, 0x0004, // RTD #4
],
);
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pending = loaded.guest_calls().activate_m68k().unwrap();
assert_eq!(
loaded.memory.read_u32_be(pending.initial_sp + 4),
Some(0x1234_5678)
);
assert_eq!(pending.final_sp, pending.initial_sp + 8);
drain_test_m68k_guest_calls(&mut loaded);
assert_eq!(loaded.cpu.gpr[3], 0x1234_567f);
assert!(loaded.guest_calls().is_empty());
}
#[test]
fn hle_import_runner_call_universal_proc_lays_out_m68k_pascal_stack_sizes() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let proc_info = test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_ONE,
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
],
);
install_test_m68k_callback(
&mut loaded,
descriptor,
callback_entry,
proc_info,
0,
&[0x4e74, 0x0008], // RTD #8
);
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1234_5678;
loaded.cpu.gpr[6] = 0x8765_4321;
loaded.cpu.gpr[7] = 0xcafe_babe;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let pending = loaded.guest_calls().activate_m68k().unwrap();
let frame = pending.initial_sp;
assert_eq!(loaded.memory.read_u32_be(frame), Some(pending.return_pc));
assert_eq!(loaded.memory.read_u32_be(frame + 4), Some(0xcafe_babe));
assert_eq!(loaded.memory.read_u16_be(frame + 8), Some(0x4321));
assert_eq!(loaded.memory.read_u8(frame + 10), Some(0));
assert_eq!(loaded.memory.read_u8(frame + 11), Some(0x78));
assert_eq!(pending.final_sp, frame + 12);
drain_test_m68k_guest_calls(&mut loaded);
}
#[test]
fn hle_import_runner_call_universal_proc_distinguishes_mpw_and_think_c_bytes() {
for (convention, byte_offset) in [
(PPC_PROCINFO_C_STACK_BASED, 1),
(PPC_PROCINFO_THINK_C_STACK_BASED, 0),
] {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let proc_info = test_stack_proc_info(
PPC_PROCINFO_SIZE_FOUR,
&[
PPC_PROCINFO_SIZE_ONE,
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
],
) | convention;
install_test_m68k_callback(
&mut loaded,
descriptor,
callback_entry,
proc_info,
0,
&[0x7007, 0x4e75], // MOVEQ #7,D0; RTS
);
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1234_5678;
loaded.cpu.gpr[6] = 0x8765_4321;
loaded.cpu.gpr[7] = 0xcafe_babe;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let pending = loaded.guest_calls().activate_m68k().unwrap();
let frame = pending.initial_sp;
assert_eq!(loaded.memory.read_u8(frame + 4 + byte_offset), Some(0x78));
assert_eq!(loaded.memory.read_u16_be(frame + 6), Some(0x4321));
assert_eq!(loaded.memory.read_u32_be(frame + 8), Some(0xcafe_babe));
assert_eq!(pending.final_sp, frame + 4);
drain_test_m68k_guest_calls(&mut loaded);
assert_eq!(loaded.cpu.gpr[3], 7);
}
}
#[test]
fn hle_import_runner_call_universal_proc_maps_m68k_register_arguments_and_result() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let proc_info = test_register_proc_info_with_result_location(
PPC_PROCINFO_SIZE_FOUR,
4,
&[(1, PPC_PROCINFO_SIZE_TWO), (7, PPC_PROCINFO_SIZE_FOUR)],
);
install_test_m68k_callback(
&mut loaded,
descriptor,
callback_entry,
proc_info,
0,
&[
0x207c, 0xcafe, 0xbabe, // MOVEA.L #$CAFEBABE,A0
0x4e75, // RTS
],
);
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0xabcd_7654;
loaded.cpu.gpr[6] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let pending = loaded.guest_calls().activate_m68k().unwrap();
assert_eq!(pending.registers.data[1], 0x7654);
assert_eq!(pending.registers.address[3], 0x1234_5678);
assert_eq!(pending.registers.address[5], PPC_DATA_BASE);
assert_eq!(pending.final_sp, pending.initial_sp + 4);
drain_test_m68k_guest_calls(&mut loaded);
assert_eq!(loaded.cpu.gpr[3], 0xcafe_babe);
}
#[test]
fn hle_import_runner_call_universal_proc_places_m68k_dispatched_selectors() {
for (convention, selector_register, flags) in [
(PPC_PROCINFO_D0_DISPATCHED_PASCAL_STACK_BASED, Some(0), 0),
(PPC_PROCINFO_D1_DISPATCHED_PASCAL_STACK_BASED, Some(1), 0),
(
PPC_PROCINFO_D0_DISPATCHED_PASCAL_STACK_BASED,
None,
PPC_ROUTINE_FLAG_DONT_PASS_SELECTOR,
),
(PPC_PROCINFO_STACK_DISPATCHED_PASCAL_STACK_BASED, None, 0),
] {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let proc_info = test_dispatched_stack_proc_info(
convention,
PPC_PROCINFO_SIZE_NONE,
PPC_PROCINFO_SIZE_TWO,
&[PPC_PROCINFO_SIZE_FOUR],
);
let stack_selector = convention == PPC_PROCINFO_STACK_DISPATCHED_PASCAL_STACK_BASED;
let cleanup = if stack_selector && flags == 0 { 6 } else { 4 };
install_test_m68k_callback(
&mut loaded,
descriptor,
callback_entry,
proc_info,
flags,
&[0x4e74, cleanup],
);
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1234_5678;
loaded.cpu.gpr[6] = 0xcafe_babe;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let pending = loaded.guest_calls().activate_m68k().unwrap();
if let Some(register) = selector_register {
assert_eq!(pending.registers.data[register], 0x5678);
} else {
assert_eq!(pending.registers.data[0], 0);
assert_eq!(pending.registers.data[1], 0);
}
assert_eq!(
loaded.memory.read_u32_be(pending.initial_sp + 4),
Some(0xcafe_babe)
);
if stack_selector {
assert_eq!(
loaded.memory.read_u16_be(pending.initial_sp + 8),
Some(0x5678)
);
}
drain_test_m68k_guest_calls(&mut loaded);
}
}
#[test]
fn hle_import_runner_call_universal_proc_decodes_stack_procinfo_sizes() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_stack_proc_info(
PPC_PROCINFO_SIZE_FOUR,
&[
PPC_PROCINFO_SIZE_ONE,
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
],
);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(36, 5, 2, 8),
d_form_u(32, 6, 1, PPC_PARAMETER_AREA_OFFSET as u16),
d_form_u(32, 7, 1, (PPC_PARAMETER_AREA_OFFSET + 4) as u16),
d_form_u(32, 8, 1, (PPC_PARAMETER_AREA_OFFSET + 8) as u16),
d_form_u(36, 6, 2, 12),
d_form_u(36, 7, 2, 16),
d_form_u(36, 8, 2, 20),
BLR,
],
);
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1234_5678;
loaded.cpu.gpr[6] = 0x8765_4321;
loaded.cpu.gpr[7] = 0xcafe_babe;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 19,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0x78);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x78));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 4), Some(0x4321));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 8),
Some(0xcafe_babe)
);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 12), Some(0x78));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 16), Some(0x4321));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 20),
Some(0xcafe_babe)
);
}
#[test]
fn hle_import_runner_call_universal_proc_preserves_native_ppc_fpr_args_and_result() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let first = 1.25f64;
let second = 2.5f64;
let proc_info = test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[PPC_PROCINFO_SIZE_FOUR, PPC_PROCINFO_SIZE_FOUR],
);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(54, 1, 2, 0),
d_form_u(54, 2, 2, 8),
a_form_fp(63, 1, 1, 2, 0, 21, false),
d_form_u(54, 1, 2, 16),
BLR,
],
);
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0xaaaa_0001;
loaded.cpu.gpr[6] = 0xbbbb_0002;
loaded.cpu.fpr[1] = first.to_bits();
loaded.cpu.fpr[2] = second.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(matches!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0xaaaa_0001);
assert_eq!(
loaded.memory.read_u64_be(callback_rtoc),
Some(first.to_bits())
);
assert_eq!(
loaded.memory.read_u64_be(callback_rtoc + 8),
Some(second.to_bits())
);
assert_eq!(
loaded.memory.read_u64_be(callback_rtoc + 16),
Some((first + second).to_bits())
);
assert_eq!(f64::from_bits(loaded.cpu.fpr[1]), first + second);
}
#[test]
fn native_arguments_refuse_without_partial_register_or_stack_writes() {
for failure in 0..5 {
let mut cpu = PpcCpu::new();
cpu.gpr.fill(0xfeed_beef);
cpu.gpr[1] = match failure {
3 => u32::MAX - 8,
4 => u32::MAX - 39,
_ => 0x8000,
};
cpu.pc = 0x1234;
cpu.lr = 0x5678;
let mut memory = PpcSectionMem::new();
memory.add_region(0x8018, vec![0xa5; 32]);
match failure {
1 => memory.add_readonly_region(0x8038, vec![0xa5; 4]),
2 => {
memory.add_region(0x8038, vec![0xa5; 4]);
memory.add_readonly_region(0x803a, vec![0xa5; 1]);
}
_ => {}
}
let registers = cpu.gpr;
let arguments = [1, 2, 3, 4, 5, 6, 7, 8, 9];
assert!(install_powerpc_call_arguments(&mut cpu, &mut memory, &arguments).is_none());
assert_eq!(cpu.gpr, registers, "failure {failure}");
assert_eq!((cpu.pc, cpu.lr), (0x1234, 0x5678));
for offset in 0..32 {
assert_eq!(memory.read_u8(0x8018 + offset), Some(0xa5));
}
// Retry across independently mapped words, including a spilled argument.
let mut memory = PpcSectionMem::new();
for slot in 0..9 {
memory.add_region(0x8018 + slot * 4, vec![0xa5; 4]);
}
cpu.gpr[1] = 0x8000;
assert!(install_powerpc_call_arguments(&mut cpu, &mut memory, &arguments).is_some());
assert_eq!(&cpu.gpr[3..11], &arguments[..8]);
for (slot, value) in arguments.iter().enumerate() {
assert_eq!(memory.read_u32_be(0x8018 + slot as u32 * 4), Some(*value));
}
assert_eq!((cpu.pc, cpu.lr), (0x1234, 0x5678));
}
}
#[test]
fn hle_import_runner_call_universal_proc_preserves_arguments_on_stack_refusal() {
for traced in [false, true] {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let proc_info = test_stack_proc_info(PPC_PROCINFO_SIZE_FOUR, &[PPC_PROCINFO_SIZE_FOUR]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
descriptor + 0x80,
PPC_HEAP_BASE + 0x2000,
callback_rtoc,
proc_info,
&[d_form_u(36, 3, 2, 0), BLR],
);
let start_pc = loaded.cpu.pc;
let sp = loaded.cpu.gpr[1];
loaded.memory.write_bytes(sp + 24, &[0xa5; 32]).unwrap();
loaded.memory.add_readonly_region(sp + 52, vec![0xa5; 4]);
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1234_5678;
let registers = loaded.cpu.gpr[3..11].to_vec();
let calls = loaded.guest_calls().clone();
let probe = loaded.run_with_hle_imports_with_trace(64, traced, false, None, None);
assert_eq!(probe.unsupported_import_index, Some(0));
assert_eq!(&loaded.cpu.gpr[3..11], registers.as_slice());
assert_eq!(loaded.guest_calls(), &calls);
for offset in 0..32 {
assert_eq!(loaded.memory.read_u8(sp + 24 + offset), Some(0xa5));
}
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0));
// The same import and arguments can run after moving to a writable frame.
loaded.cpu.pc = start_pc;
loaded.cpu.gpr[1] = PPC_HEAP_BASE + 0x4000;
let probe = loaded.run_with_hle_imports_with_trace(64, traced, false, None, None);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x1234_5678);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x1234_5678));
assert!(loaded.guest_calls().is_empty());
}
}
#[test]
fn hle_import_runner_call_universal_proc_clears_minimum_parameter_area_slots() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_stack_proc_info(PPC_PROCINFO_SIZE_FOUR, &[PPC_PROCINFO_SIZE_FOUR]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(32, 6, 1, PPC_PARAMETER_AREA_OFFSET as u16),
d_form_u(32, 7, 1, (PPC_PARAMETER_AREA_OFFSET + 7 * 4) as u16),
d_form_u(36, 6, 2, 8),
d_form_u(36, 7, 2, 12),
BLR,
],
);
let sp = loaded.cpu.gpr[1];
for slot in 0..PPC_NATIVE_PARAMETER_GPR_COUNT {
let addr = ppc_parameter_area_slot_addr(sp, slot).unwrap();
loaded
.memory
.write_u32_be(addr, 0xdead_0000 | u32::try_from(slot).unwrap())
.unwrap();
}
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 16,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0x1234_5678);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x1234_5678));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 4), Some(0));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 8),
Some(0x1234_5678)
);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 12), Some(0));
}
#[test]
fn hle_import_runner_call_universal_proc_reads_overflow_varargs() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_stack_proc_info(PPC_PROCINFO_SIZE_FOUR, &[PPC_PROCINFO_SIZE_FOUR; 9]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(36, 10, 2, 4),
d_form_u(
32,
11,
1,
(PPC_PARAMETER_AREA_OFFSET + PPC_NATIVE_PARAMETER_GPR_COUNT as u32 * 4) as u16,
),
d_form_u(36, 11, 2, 8),
BLR,
],
);
loaded.cpu.gpr[1] -= PPC_INITIAL_STACK_FRAME_SIZE;
let sp = loaded.cpu.gpr[1];
for (index, value) in [0x101, 0x102, 0x103, 0x104, 0x105, 0x106]
.iter()
.copied()
.enumerate()
{
loaded.cpu.gpr[5 + index] = value;
}
for (vararg_index, value) in [(6, 0x107), (7, 0x108), (8, 0x109)] {
let source_slot = PPC_CALL_UNIVERSAL_PROC_FIXED_WORD_PARAMETERS + vararg_index;
let addr = ppc_parameter_area_slot_addr(sp, source_slot).unwrap();
loaded.memory.write_u32_be(addr, value).unwrap();
}
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 14,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0x101);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x101));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 4), Some(0x108));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 8), Some(0x109));
assert_eq!(
loaded.memory.read_u32_be(
ppc_parameter_area_slot_addr(sp, PPC_NATIVE_PARAMETER_GPR_COUNT).unwrap()
),
Some(0x109)
);
}
#[test]
fn hle_import_runner_call_universal_proc_decodes_register_procinfo() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_register_proc_info(
PPC_PROCINFO_SIZE_FOUR,
&[
(1, PPC_PROCINFO_SIZE_TWO),
(4, PPC_PROCINFO_SIZE_FOUR),
(0, PPC_PROCINFO_SIZE_ONE),
],
);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(36, 5, 2, 8),
BLR,
],
);
let sp = loaded.cpu.gpr[1];
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0xabcd_7654;
loaded.cpu.gpr[6] = 0xcafe_babe;
loaded.cpu.gpr[7] = 0x1234_56ee;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 13,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0x7654);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x7654));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 4),
Some(0xcafe_babe)
);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 8), Some(0xee));
assert_eq!(
loaded
.memory
.read_u32_be(ppc_parameter_area_slot_addr(sp, 0).unwrap()),
Some(0x7654)
);
assert_eq!(
loaded
.memory
.read_u32_be(ppc_parameter_area_slot_addr(sp, 1).unwrap()),
Some(0xcafe_babe)
);
assert_eq!(
loaded
.memory
.read_u32_be(ppc_parameter_area_slot_addr(sp, 2).unwrap()),
Some(0xee)
);
}
#[test]
fn hle_import_runner_call_universal_proc_returns_register_procinfo_ccr_z_bit() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_register_proc_info_with_result_location(
PPC_PROCINFO_SIZE_NONE,
PPC_PROCINFO_REGISTER_CCR_Z,
&[],
);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[d_form_u(28, 3, 3, 0), BLR],
);
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 11,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 1);
}
#[test]
fn hle_import_runner_call_universal_proc_decodes_special_case_eol_hook() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = PPC_PROCINFO_SPECIAL_CASE
| (crate::mixed_mode::special_case::EOL_HOOK << PPC_PROCINFO_RESULT_SIZE_PHASE);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(36, 5, 2, 8),
d_form_u(32, 6, 1, PPC_PARAMETER_AREA_OFFSET as u16),
d_form_u(32, 7, 1, (PPC_PARAMETER_AREA_OFFSET + 7 * 4) as u16),
d_form_u(36, 6, 2, 12),
d_form_u(36, 7, 2, 16),
d_form_u(14, 3, 0, 0x0101),
BLR,
],
);
let sp = loaded.cpu.gpr[1];
for slot in 0..PPC_NATIVE_PARAMETER_GPR_COUNT {
let addr = ppc_parameter_area_slot_addr(sp, slot).unwrap();
loaded
.memory
.write_u32_be(addr, 0xfeed_0000 | u32::try_from(slot).unwrap())
.unwrap();
}
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1111_0001;
loaded.cpu.gpr[6] = 0x2222_0002;
loaded.cpu.gpr[7] = 0x3333_0003;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(matches!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x1111_0001));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 4),
Some(0x2222_0002)
);
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 8),
Some(0x3333_0003)
);
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 12),
Some(0x1111_0001)
);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 16), Some(0));
}
#[test]
fn hle_import_runner_call_universal_proc_passes_all_hit_test_arguments() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = PPC_PROCINFO_SPECIAL_CASE
| (crate::mixed_mode::special_case::HIT_TEST_HOOK << PPC_PROCINFO_RESULT_SIZE_PHASE);
let mut callback = Vec::new();
for register in 3..=10 {
callback.push(d_form_u(36, register, 2, u16::from(register - 3) * 4));
}
callback.extend([
d_form_u(32, 11, 1, (PPC_PARAMETER_AREA_OFFSET + 8 * 4) as u16),
d_form_u(36, 11, 2, 32),
d_form_u(14, 3, 0, 0x0101),
BLR,
]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&callback,
);
let arguments: Vec<u32> = (0..9).map(|index| 0x1000 + index).collect();
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5..=10].copy_from_slice(&arguments[..6]);
for (index, value) in arguments[6..].iter().copied().enumerate() {
loaded
.memory
.write_u32_be(
ppc_parameter_area_slot_addr(loaded.cpu.gpr[1], 8 + index).unwrap(),
value,
)
.unwrap();
}
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(matches!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 1);
for (index, expected) in arguments.into_iter().enumerate() {
assert_eq!(
loaded
.memory
.read_u32_be(callback_rtoc + u32::try_from(index).unwrap() * 4),
Some(expected)
);
}
}
#[test]
fn hle_import_runner_call_universal_proc_decodes_special_case_mbar_hook() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let menu_rect_ptr = PPC_DATA_BASE + 0x4000;
let proc_info = PPC_PROCINFO_SPECIAL_CASE
| (crate::mixed_mode::special_case::MBAR_HOOK << PPC_PROCINFO_RESULT_SIZE_PHASE);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(32, 4, 1, PPC_PARAMETER_AREA_OFFSET as u16),
d_form_u(36, 4, 2, 4),
d_form_u(14, 3, 0, 1),
BLR,
],
);
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = menu_rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(matches!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc),
Some(menu_rect_ptr)
);
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 4),
Some(menu_rect_ptr)
);
}
#[test]
fn hle_import_runner_call_universal_proc_passes_gne_filter_output_pointer() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let event = PPC_DATA_BASE + 0x4000;
let result = callback_rtoc + 0x100;
let proc_info = PPC_PROCINFO_SPECIAL_CASE
| (crate::mixed_mode::special_case::GNE_FILTER_PROC << PPC_PROCINFO_RESULT_SIZE_PHASE);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(14, 5, 0, 1),
d_form_u(38, 5, 4, 0),
BLR,
],
);
loaded.memory.write_u8(result, 0).unwrap();
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = event;
loaded.cpu.gpr[6] = result;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(matches!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(event));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 4), Some(result));
assert_eq!(loaded.memory.read_u8(result), Some(1));
}
#[test]
fn hle_import_runner_call_universal_proc_decodes_d0_dispatched_procinfo() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_dispatched_stack_proc_info(
PPC_PROCINFO_D0_DISPATCHED_PASCAL_STACK_BASED,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_ONE,
&[PPC_PROCINFO_SIZE_TWO, PPC_PROCINFO_SIZE_FOUR],
);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(36, 5, 2, 8),
d_form_u(32, 6, 1, PPC_PARAMETER_AREA_OFFSET as u16),
d_form_u(32, 7, 1, (PPC_PARAMETER_AREA_OFFSET + 4) as u16),
d_form_u(32, 8, 1, (PPC_PARAMETER_AREA_OFFSET + 8) as u16),
d_form_u(36, 6, 2, 12),
d_form_u(36, 7, 2, 16),
d_form_u(36, 8, 2, 20),
BLR,
],
);
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x1234_5678;
loaded.cpu.gpr[6] = 0x8765_4321;
loaded.cpu.gpr[7] = 0xcafe_babe;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 19,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0x78);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x78));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 4), Some(0x4321));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 8),
Some(0xcafe_babe)
);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 12), Some(0x78));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 16), Some(0x4321));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 20),
Some(0xcafe_babe)
);
}
#[test]
fn hle_import_runner_call_universal_proc_decodes_stack_dispatched_overflow_varargs() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_dispatched_stack_proc_info(
PPC_PROCINFO_STACK_DISPATCHED_PASCAL_STACK_BASED,
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_TWO,
&[PPC_PROCINFO_SIZE_FOUR; 8],
);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(36, 10, 2, 4),
d_form_u(32, 11, 1, (PPC_PARAMETER_AREA_OFFSET + 8 * 4) as u16),
d_form_u(36, 11, 2, 8),
d_form_u(15, 3, 0, 0xface),
d_form_u(24, 3, 3, 0xb00c),
BLR,
],
);
loaded.cpu.gpr[1] -= PPC_INITIAL_STACK_FRAME_SIZE;
let sp = loaded.cpu.gpr[1];
for (index, value) in [
0x1000_2222,
0x2000_0001,
0x2000_0002,
0x2000_0003,
0x2000_0004,
0x2000_0005,
]
.iter()
.copied()
.enumerate()
{
loaded.cpu.gpr[5 + index] = value;
}
for (vararg_index, value) in [(6, 0x2000_0006), (7, 0x2000_0007), (8, 0x2000_0008)] {
let source_slot = PPC_CALL_UNIVERSAL_PROC_FIXED_WORD_PARAMETERS + vararg_index;
let addr = ppc_parameter_area_slot_addr(sp, source_slot).unwrap();
loaded.memory.write_u32_be(addr, value).unwrap();
}
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 16,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0xb00c);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x2222));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 4),
Some(0x2000_0007)
);
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 8),
Some(0x2000_0008)
);
assert_eq!(
loaded
.memory
.read_u32_be(ppc_parameter_area_slot_addr(sp, 8).unwrap()),
Some(0x2000_0008)
);
}
#[test]
fn hle_import_runner_call_universal_proc_selects_dispatched_routine_record() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let first_tvector = descriptor + 0x80;
let second_tvector = descriptor + 0x88;
let first_entry = PPC_HEAP_BASE + 0x2000;
let second_entry = PPC_HEAP_BASE + 0x2100;
let first_rtoc = PPC_HEAP_BASE + 0x3000;
let second_rtoc = PPC_HEAP_BASE + 0x3100;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_dispatched_stack_proc_info(
PPC_PROCINFO_D0_DISPATCHED_PASCAL_STACK_BASED,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_ONE,
&[PPC_PROCINFO_SIZE_FOUR],
);
let first_record = descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE;
let second_record = first_record + PPC_ROUTINE_RECORD_SIZE;
loaded.memory.add_region(descriptor, vec![0; 0x100]);
loaded.memory.add_region(first_rtoc, vec![0; 0x100]);
loaded.memory.add_region(second_rtoc, vec![0; 0x100]);
loaded
.memory
.write_u16_be(descriptor, PPC_MIXED_MODE_TRAP)
.unwrap();
loaded
.memory
.write_u8(descriptor + 2, PPC_ROUTINE_DESCRIPTOR_VERSION)
.unwrap();
loaded.memory.write_u16_be(descriptor + 10, 1).unwrap();
ppc_write_routine_record(
&mut loaded.memory,
first_record,
proc_info,
PPC_ROUTINE_RECORD_POWERPC_ISA,
PPC_ROUTINE_FLAG_USE_NATIVE_ISA,
first_tvector,
);
ppc_write_routine_record(
&mut loaded.memory,
second_record,
proc_info,
PPC_ROUTINE_RECORD_POWERPC_ISA,
PPC_ROUTINE_FLAG_USE_NATIVE_ISA,
second_tvector,
);
loaded
.memory
.write_u32_be(first_record + PPC_ROUTINE_RECORD_SELECTOR_OFFSET, 0x11)
.unwrap();
loaded
.memory
.write_u32_be(second_record + PPC_ROUTINE_RECORD_SELECTOR_OFFSET, 0x22)
.unwrap();
loaded
.memory
.write_u32_be(first_tvector, first_entry)
.unwrap();
loaded
.memory
.write_u32_be(first_tvector + 4, first_rtoc)
.unwrap();
loaded
.memory
.write_u32_be(second_tvector, second_entry)
.unwrap();
loaded
.memory
.write_u32_be(second_tvector + 4, second_rtoc)
.unwrap();
let mut first_callback = Vec::new();
for word in [
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(15, 3, 0, 0x1111),
d_form_u(24, 3, 3, 0x0011),
BLR,
] {
first_callback.extend_from_slice(&word.to_be_bytes());
}
let mut second_callback = Vec::new();
for word in [
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(15, 3, 0, 0x2222),
d_form_u(24, 3, 3, 0x0022),
BLR,
] {
second_callback.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(first_entry, first_callback);
loaded.memory.add_region(second_entry, second_callback);
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x22;
loaded.cpu.gpr[6] = 0xcafe_babe;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 14,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0x2222_0022);
assert_eq!(loaded.memory.read_u32_be(first_rtoc), Some(0));
assert_eq!(loaded.memory.read_u32_be(second_rtoc), Some(0x22));
assert_eq!(
loaded.memory.read_u32_be(second_rtoc + 4),
Some(0xcafe_babe)
);
}
#[test]
fn hle_import_runner_call_universal_proc_honors_dont_pass_selector() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_dispatched_stack_proc_info(
PPC_PROCINFO_D0_DISPATCHED_C_STACK_BASED,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_ONE,
&[PPC_PROCINFO_SIZE_TWO, PPC_PROCINFO_SIZE_FOUR],
);
let record = descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE;
loaded.memory.add_region(descriptor, vec![0; 0x100]);
loaded.memory.add_region(callback_rtoc, vec![0; 0x100]);
loaded
.memory
.write_u16_be(descriptor, PPC_MIXED_MODE_TRAP)
.unwrap();
loaded
.memory
.write_u8(descriptor + 2, PPC_ROUTINE_DESCRIPTOR_VERSION)
.unwrap();
loaded.memory.write_u16_be(descriptor + 10, 0).unwrap();
ppc_write_routine_record(
&mut loaded.memory,
record,
proc_info,
PPC_ROUTINE_RECORD_POWERPC_ISA,
PPC_ROUTINE_FLAG_USE_NATIVE_ISA | PPC_ROUTINE_FLAG_DONT_PASS_SELECTOR,
tvector,
);
loaded
.memory
.write_u32_be(record + PPC_ROUTINE_RECORD_SELECTOR_OFFSET, 0x33)
.unwrap();
loaded.memory.write_u32_be(tvector, callback_entry).unwrap();
loaded
.memory
.write_u32_be(tvector + 4, callback_rtoc)
.unwrap();
let mut callback = Vec::new();
for word in [
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(36, 5, 2, 8),
BLR,
] {
callback.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(callback_entry, callback);
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x33;
loaded.cpu.gpr[6] = 0xabcd_7654;
loaded.cpu.gpr[7] = 0xcafe_babe;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 13,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0x7654);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0x7654));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 4),
Some(0xcafe_babe)
);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 8), Some(0));
}
#[test]
fn hle_import_runner_call_universal_proc_masks_procinfo_result_size() {
let pef = synthetic_pef_with_import(b"CallUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_stack_proc_info(PPC_PROCINFO_SIZE_TWO, &[]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[d_form_u(15, 3, 0, 0xcafe), d_form_u(24, 3, 3, 0xbeef), BLR],
);
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 12,
}
);
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0xbeef);
}
#[test]
fn hle_import_runner_call_ostrap_universal_proc_enters_native_ppc_descriptor() {
let pef = synthetic_pef_with_import(b"CallOSTrapUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let tvector = descriptor + 0x80;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_rtoc = PPC_HEAP_BASE + 0x3000;
let caller_rtoc = PPC_DATA_BASE;
let proc_info = test_register_proc_info(
PPC_PROCINFO_SIZE_FOUR,
&[(1, PPC_PROCINFO_SIZE_TWO), (0, PPC_PROCINFO_SIZE_FOUR)],
);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
proc_info,
&[
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(14, 3, 3, 5),
BLR,
],
);
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0xffff_a11c;
loaded.cpu.gpr[6] = 0x20;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(matches!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[3], 0xa121);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(0xa11c));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 4), Some(0x20));
}
#[test]
fn hle_import_runner_call_ostrap_universal_proc_enters_m68k_register_descriptor() {
let pef = synthetic_pef_with_import(b"CallOSTrapUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let callback_entry = PPC_HEAP_BASE + 0x2000;
let proc_info = test_register_proc_info_with_result_location(
PPC_PROCINFO_SIZE_TWO,
0,
&[(1, PPC_PROCINFO_SIZE_TWO)],
);
install_test_m68k_callback(
&mut loaded,
descriptor,
callback_entry,
proc_info,
0,
&[
0x2001, // MOVE.L D1,D0
0x5a80, // ADDQ.L #5,D0
0x4e75, // RTS
],
);
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0xffff_a11c;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pending = loaded.guest_calls().activate_m68k().unwrap();
assert_eq!(pending.registers.data[1], 0xa11c);
drain_test_m68k_guest_calls(&mut loaded);
assert_eq!(loaded.cpu.gpr[3], 0xa121);
}
#[test]
fn hle_import_runner_call_ostrap_universal_proc_enters_raw_m68k_trap_code() {
let pef = synthetic_pef_with_import(b"CallOSTrapUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let callback_entry = PPC_HEAP_BASE + 0x2000;
let callback_words = [
0x2001u16, // MOVE.L D1,D0
0x5a80, // ADDQ.L #5,D0
0x4e75, // RTS
];
loaded.memory.add_region(
callback_entry,
callback_words
.into_iter()
.flat_map(u16::to_be_bytes)
.collect(),
);
loaded.set_heap_cursor(loaded.heap_cursor().max(callback_entry + 6));
let proc_info = test_register_proc_info_with_result_location(
PPC_PROCINFO_SIZE_TWO,
0,
&[(1, PPC_PROCINFO_SIZE_TWO), (0, PPC_PROCINFO_SIZE_FOUR)],
);
loaded.cpu.gpr[3] = callback_entry;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0xffff_a11e;
loaded.cpu.gpr[6] = 0x20;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pending = loaded.guest_calls().activate_m68k().unwrap();
assert_eq!(pending.entry, callback_entry);
assert_eq!(pending.registers.data[1], 0xa11e);
assert_eq!(pending.registers.data[0], 0x20);
drain_test_m68k_guest_calls(&mut loaded);
assert_eq!(loaded.cpu.gpr[3], 0xa123);
}
#[test]
fn hle_import_runner_call_ostrap_universal_proc_rejects_stack_procinfo() {
let pef = synthetic_pef_with_import(b"CallOSTrapUniversalProc");
let mut loaded = load_pef_application(&pef).unwrap();
let proc_info = test_stack_proc_info(PPC_PROCINFO_SIZE_FOUR, &[PPC_PROCINFO_SIZE_FOUR]);
loaded.cpu.gpr[3] = PPC_HEAP_BASE + 0x1000;
loaded.cpu.gpr[4] = proc_info;
loaded.cpu.gpr[5] = 0x20;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 0);
assert_eq!(probe.unsupported_import_index, Some(0));
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_IMPORT_TRAP_BASE,
cycles: 4,
}
);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE + 0x1000);
}
#[test]
fn routine_descriptor_resolver_uses_powerpc_record_in_fat_descriptor() {
let descriptor = PPC_DATA_BASE;
let m68k_record = descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE;
let powerpc_record = m68k_record + PPC_ROUTINE_RECORD_SIZE;
let tvector = descriptor + 0x80;
let callback_entry = PPC_CODE_BASE + 0x40;
let callback_rtoc = PPC_DATA_BASE + 0x200;
let mut memory = PpcSectionMem::new();
memory.add_region(PPC_DATA_BASE, vec![0; 0x100]);
memory.add_region(callback_entry, 0x4e80_0020u32.to_be_bytes().to_vec());
memory
.write_u16_be(descriptor, PPC_MIXED_MODE_TRAP)
.unwrap();
memory
.write_u8(descriptor + 2, PPC_ROUTINE_DESCRIPTOR_VERSION)
.unwrap();
memory.write_u16_be(descriptor + 10, 1).unwrap();
memory
.write_u8(
m68k_record + PPC_ROUTINE_RECORD_ISA_OFFSET,
PPC_ROUTINE_RECORD_M68K_ISA,
)
.unwrap();
memory
.write_u8(
powerpc_record + PPC_ROUTINE_RECORD_ISA_OFFSET,
PPC_ROUTINE_RECORD_POWERPC_ISA,
)
.unwrap();
memory
.write_u16_be(
powerpc_record + PPC_ROUTINE_RECORD_FLAGS_OFFSET,
PPC_ROUTINE_FLAG_USE_NATIVE_ISA,
)
.unwrap();
memory
.write_u32_be(
powerpc_record + PPC_ROUTINE_RECORD_PROC_DESCRIPTOR_OFFSET,
tvector,
)
.unwrap();
memory.write_u32_be(tvector, callback_entry).unwrap();
memory.write_u32_be(tvector + 4, callback_rtoc).unwrap();
let target =
ppc_resolve_callback_target(&mut memory, descriptor, PPC_DATA_BASE, None).unwrap();
assert_eq!(
target,
PpcCallbackTarget {
entry: callback_entry,
rtoc: callback_rtoc,
proc_info: 0,
routine_flags: PPC_ROUTINE_FLAG_USE_NATIVE_ISA,
}
);
}
#[test]
fn routine_descriptor_resolver_handles_relative_powerpc_proc_descriptor() {
let descriptor = PPC_DATA_BASE;
let record = descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE;
let callback_offset = 0x80;
let callback_entry = descriptor + callback_offset;
let default_rtoc = PPC_DATA_BASE + 0x200;
let mut memory = PpcSectionMem::new();
memory.add_region(PPC_DATA_BASE, vec![0; 0x100]);
memory
.write_u16_be(descriptor, PPC_MIXED_MODE_TRAP)
.unwrap();
memory
.write_u8(descriptor + 2, PPC_ROUTINE_DESCRIPTOR_VERSION)
.unwrap();
memory.write_u16_be(descriptor + 10, 0).unwrap();
memory
.write_u8(
record + PPC_ROUTINE_RECORD_ISA_OFFSET,
PPC_ROUTINE_RECORD_POWERPC_ISA,
)
.unwrap();
memory
.write_u16_be(
record + PPC_ROUTINE_RECORD_FLAGS_OFFSET,
PPC_ROUTINE_FLAG_USE_NATIVE_ISA | PPC_ROUTINE_FLAG_PROC_DESCRIPTOR_RELATIVE,
)
.unwrap();
memory
.write_u32_be(
record + PPC_ROUTINE_RECORD_PROC_DESCRIPTOR_OFFSET,
callback_offset,
)
.unwrap();
memory.write_u32_be(callback_entry, 0x4e80_0020).unwrap();
let target =
ppc_resolve_callback_target(&mut memory, descriptor, default_rtoc, None).unwrap();
assert_eq!(
target,
PpcCallbackTarget {
entry: callback_entry,
rtoc: default_rtoc,
proc_info: 0,
routine_flags: PPC_ROUTINE_FLAG_USE_NATIVE_ISA
| PPC_ROUTINE_FLAG_PROC_DESCRIPTOR_RELATIVE,
}
);
}
#[test]
fn hle_import_runner_handles_zone_queries() {
let pef = synthetic_pef_with_import(b"GetZone");
let mut loaded = load_pef_application(&pef).unwrap();
for (target, expected) in [
(PpcImportDispatcherTarget::GetZone, PPC_APPLICATION_ZONE),
(PpcImportDispatcherTarget::SystemZone, PPC_SYSTEM_ZONE),
(
PpcImportDispatcherTarget::ApplicationZone,
PPC_APPLICATION_ZONE,
),
] {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], expected);
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetZone;
loaded.cpu.gpr[3] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x1234_5678);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetZone;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x1234_5678);
}
#[test]
fn native_powerpc_launch_seeds_modern_application_zone() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"GetZone")).unwrap();
assert_eq!(
loaded.memory.read_u32_be(PPC_THE_ZONE_ADDR),
Some(PPC_APPLICATION_ZONE)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_APPL_ZONE_ADDR),
Some(PPC_APPLICATION_ZONE)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_SYS_ZONE_ADDR),
Some(PPC_SYSTEM_ZONE)
);
assert_eq!(
loaded
.memory
.read_u8(PPC_APPLICATION_ZONE + PPC_ZONE_HEAP_TYPE_OFFSET),
Some(PPC_ZONE_32_BIT_HEAP | PPC_ZONE_NEW_STYLE_HEAP)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_APPLICATION_ZONE),
Some(test_heap_limit!(loaded))
);
assert_eq!(
loaded.memory.read_u32_be(PPC_APPLICATION_ZONE + 12),
Some(test_heap_limit!(loaded) - loaded.heap_base())
);
}
#[test]
fn hle_import_runner_init_zone_initializes_header_and_current_zone() {
let pef = synthetic_pef_with_import(b"InitZone");
let mut loaded = load_pef_application(&pef).unwrap();
let start = 0x0308_0000;
let limit = start + 0x400;
loaded.memory.add_region(start, vec![0xaa; 0x400]);
loaded.cpu.gpr[3] = 0x0012_3456;
loaded.cpu.gpr[4] = 4;
loaded.cpu.gpr[5] = limit;
loaded.cpu.gpr[6] = start;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(start), Some(limit));
assert_eq!(loaded.memory.read_u32_be(start + 4), Some(0));
assert_eq!(loaded.memory.read_u32_be(start + 8), Some(start + 60));
assert_eq!(loaded.memory.read_u32_be(start + 12), Some(0x3a8));
assert_eq!(loaded.memory.read_u32_be(start + 16), Some(0x0012_3456));
assert_eq!(loaded.memory.read_u16_be(start + 20), Some(4));
assert_eq!(loaded.memory.read_u32_be(start + 36), Some(0x3a8));
assert_eq!(loaded.memory.read_u32_be(start + 48), Some(start + 52));
assert_eq!(loaded.memory.read_u32_be(PPC_THE_ZONE_ADDR), Some(start));
}
#[test]
fn hle_import_runner_handles_max_appl_zone_as_successful_noop() {
let pef = synthetic_pef_with_import(b"MaxApplZone");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_last_mem_error(PPC_MEM_FULL_ERR);
loaded.cpu.gpr[3] = 0xfeed_face;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
cycles: 8,
}
);
assert_eq!(loaded.cpu.gpr[3], 0xfeed_face);
assert_eq!(loaded.heap_cursor(), PPC_HEAP_BASE);
assert!(loaded.heap_maximized());
assert_eq!(loaded.master_pointer_blocks_requested(), 0);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn native_import_application_limit_is_distinct_from_heap_ceiling() {
let pef = synthetic_pef_with_import(b"SetApplLimit");
let mut loaded = load_pef_application(&pef).unwrap();
let native_heap_limit = loaded.heap_limit();
let requested = loaded.heap_cursor() + 0x1000;
assert!(requested < native_heap_limit);
loaded.cpu.gpr[3] = requested;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetApplLimit);
assert_eq!(loaded.heap_limit(), native_heap_limit);
assert_eq!(loaded.application_heap_limit(), requested);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetApplLimit);
assert_eq!(loaded.cpu.gpr[3], requested);
}
#[test]
fn native_import_allocations_honor_application_limit_within_physical_heap() {
// Inside Macintosh: Memory (1992), pp. 2-42--2-44 and 2-83--2-85:
// NewPtr must stay below the current application boundary, while
// SetApplLimit may raise that boundary without changing the native
// heap's physical mapping ceiling.
let pef = synthetic_pef_with_import(b"NewPtr");
let mut loaded = load_pef_application(&pef).unwrap();
let initial_cursor = loaded.heap_cursor();
let native_heap_ceiling = loaded.heap_limit();
let lowered_limit = initial_cursor + (2 * PPC_HEAP_ALIGNMENT);
assert!(lowered_limit < native_heap_ceiling);
loaded.cpu.gpr[3] = lowered_limit;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetApplLimit);
assert_eq!(loaded.application_heap_limit(), lowered_limit);
assert_eq!(loaded.heap_limit(), native_heap_ceiling);
loaded.cpu.gpr[3] = PPC_HEAP_ALIGNMENT;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewPtr { clear: true });
let first_ptr = loaded.cpu.gpr[3];
assert_eq!(first_ptr, initial_cursor);
assert_eq!(loaded.heap_cursor(), initial_cursor + PPC_HEAP_ALIGNMENT);
// A second aligned allocation would cross the lowered boundary. The
// failed import is transactional: the cursor and pointer records stay
// unchanged while MemError reports memFullErr.
loaded.cpu.gpr[3] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewPtr { clear: true });
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.heap_cursor(), initial_cursor + PPC_HEAP_ALIGNMENT);
assert_eq!(loaded.last_mem_error(), PPC_MEM_FULL_ERR);
assert_eq!(loaded.ptrs().len(), 1);
// Raising ApplLimit re-enables the remaining physical heap space; the
// native ceiling itself never changed during the logical update.
loaded.cpu.gpr[3] = native_heap_ceiling;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetApplLimit);
loaded.cpu.gpr[3] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewPtr { clear: true });
assert_eq!(loaded.cpu.gpr[3], initial_cursor + PPC_HEAP_ALIGNMENT);
assert_eq!(loaded.heap_limit(), native_heap_ceiling);
}
#[test]
fn native_import_reusable_blocks_honor_application_limit() {
// Inside Macintosh: Memory (1992), pp. 2-42--2-44: a disposed fixed
// block can satisfy a later NewPtr, but the application limit still
// bounds every address that the Memory Manager may reuse.
let pef = synthetic_pef_with_import(b"NewPtr");
let mut loaded = load_pef_application(&pef).unwrap();
let initial_cursor = loaded.heap_cursor();
let native_heap_ceiling = loaded.heap_limit();
let lowered_limit = initial_cursor + (2 * PPC_HEAP_ALIGNMENT);
let deferred_block = initial_cursor + (4 * PPC_HEAP_ALIGNMENT);
loaded.with_process_memory_manager(|_, manager| {
manager.set_application_heap_limit(lowered_limit);
manager.mutate_native_allocator(|allocator| {
allocator.free_ptr_blocks.push(ProcessPtrRecord {
ptr: deferred_block,
size: PPC_HEAP_ALIGNMENT,
});
});
});
loaded.cpu.gpr[3] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewPtr { clear: true });
assert_eq!(loaded.cpu.gpr[3], initial_cursor);
assert_eq!(loaded.heap_cursor(), initial_cursor + PPC_HEAP_ALIGNMENT);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MaxMem);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_ALIGNMENT);
// The same reusable block becomes eligible when the logical boundary
// is raised; the physical native ceiling remains unchanged.
loaded.with_process_memory_manager(|_, manager| {
manager.set_application_heap_limit(native_heap_ceiling);
});
loaded.cpu.gpr[3] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewPtr { clear: true });
assert_eq!(loaded.cpu.gpr[3], deferred_block);
assert_eq!(loaded.heap_cursor(), initial_cursor + PPC_HEAP_ALIGNMENT);
assert_eq!(loaded.heap_limit(), native_heap_ceiling);
}
#[test]
fn hle_import_runner_tracks_toolbox_startup_manager_state() {
fn run_toolbox_import(
loaded: &mut PpcLoadedApp,
target: PpcImportDispatcherTarget,
gpr3: u32,
gpr4: u32,
) -> PpcHleRunProbe {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
loaded.cpu.gpr[3] = gpr3;
loaded.cpu.gpr[4] = gpr4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(
matches!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
),
"{:?}",
probe.result
);
assert_eq!(loaded.cpu.gpr[3], gpr3);
assert_eq!(loaded.cpu.gpr[4], gpr4);
probe
}
let pef = synthetic_pef_with_import(b"InitGraf");
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(loaded.toolbox_startup, PpcToolboxStartupState::default());
run_toolbox_import(
&mut loaded,
PpcImportDispatcherTarget::InitGraf,
PPC_DATA_BASE + 0x40,
0x1234_5678,
);
assert_eq!(loaded.toolbox_startup.init_graf_count, 1);
assert_eq!(
loaded.toolbox_startup.init_graf_global_ptr,
PPC_DATA_BASE + 0x40
);
run_toolbox_import(
&mut loaded,
PpcImportDispatcherTarget::InitFonts,
0xfeed_face,
0x1111_2222,
);
assert!(loaded.toolbox_startup.fonts_initialized);
run_toolbox_import(
&mut loaded,
PpcImportDispatcherTarget::InitWindows,
0xabcd_1234,
0x2222_3333,
);
assert!(loaded.toolbox_startup.windows_initialized);
run_toolbox_import(
&mut loaded,
PpcImportDispatcherTarget::InitMenus,
0x8765_4321,
0x3333_4444,
);
assert!(loaded.toolbox_startup.menus_initialized);
run_toolbox_import(
&mut loaded,
PpcImportDispatcherTarget::TEInit,
0x1357_2468,
0x4444_5555,
);
assert!(loaded.toolbox_startup.text_edit_initialized);
run_toolbox_import(
&mut loaded,
PpcImportDispatcherTarget::InitDialogs,
0x2468_1357,
0x5555_6666,
);
assert!(loaded.toolbox_startup.dialogs_initialized);
assert_eq!(loaded.toolbox_startup.dialog_resume_proc, 0x2468_1357);
run_toolbox_import(
&mut loaded,
PpcImportDispatcherTarget::FlushEvents,
0x0001_ffff,
0x0002_0002,
);
assert_eq!(loaded.toolbox_startup.flush_events_count, 1);
assert_eq!(loaded.toolbox_startup.last_flush_event_mask, 0xffff);
assert_eq!(loaded.toolbox_startup.last_flush_stop_mask, 0x0002);
run_toolbox_import(
&mut loaded,
PpcImportDispatcherTarget::SetEventMask,
0x0000_ffdf,
0,
);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::SYS_EVT_MASK),
Some(0xffdf)
);
run_toolbox_import(
&mut loaded,
PpcImportDispatcherTarget::DisposeDialog,
PPC_HEAP_BASE + 0x80,
0x6666_7777,
);
assert_eq!(loaded.toolbox_startup.dispose_dialog_count, 1);
assert_eq!(
loaded.toolbox_startup.last_disposed_dialog,
PPC_HEAP_BASE + 0x80
);
}
#[test]
fn init_graf_initializes_application_quickdraw_globals() {
let pef = synthetic_pef_with_import(b"InitGraf");
let mut loaded = load_pef_application(&pef).unwrap();
let global_ptr = PPC_DATA_BASE + 0x2000;
loaded.memory.add_region(global_ptr - 126, vec![0; 130]);
loaded.cpu.gpr[3] = global_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(global_ptr - 126), Some(1));
assert_eq!(
loaded.memory.read_u32_be(global_ptr - 122),
Some(PPC_MAIN_SCREEN_BASE)
);
assert_eq!(
loaded.memory.read_u16_be(global_ptr - 118),
Some(ppc_main_screen_row_bytes() as u16)
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, global_ptr - 116),
Some((
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
))
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, global_ptr - 24, 8),
Some(vec![0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55])
);
assert_eq!(loaded.memory.read_u32_be(global_ptr), Some(PPC_MAIN_GWORLD));
}
#[test]
fn hle_import_runner_tracks_more_masters_requests() {
let pef = synthetic_pef_with_import(b"MoreMasters");
let mut loaded = load_pef_application(&pef).unwrap();
let heap_cursor = loaded.heap_cursor();
loaded.set_last_mem_error(PPC_MEM_FULL_ERR);
loaded.cpu.gpr[3] = 0xfeed_face;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xfeed_face);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert!(!loaded.heap_maximized());
assert_eq!(loaded.master_pointer_blocks_requested(), 1);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0xface_feed;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xface_feed);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(loaded.master_pointer_blocks_requested(), 2);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn hle_import_runner_handles_compact_mem_as_heap_free_query() {
let pef = synthetic_pef_with_import(b"CompactMem");
let mut loaded = load_pef_application(&pef).unwrap();
let free = test_heap_limit!(loaded) - loaded.heap_cursor();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], free);
}
#[test]
fn hle_import_runner_handles_purge_mem_as_heap_free_probe() {
let pef = synthetic_pef_with_import(b"PurgeMem");
let mut loaded = load_pef_application(&pef).unwrap();
let heap_cursor = loaded.heap_cursor();
let free = test_heap_limit!(loaded) - loaded.heap_cursor();
loaded.set_last_mem_error(PPC_MEM_FULL_ERR);
loaded.cpu.gpr[3] = free;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], free);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = free + 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], free + 1);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(loaded.last_mem_error(), PPC_MEM_FULL_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::PurgeMemSys;
loaded.cpu.gpr[3] = free;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], free);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn hle_import_runner_handles_mem_error() {
let pef = synthetic_pef_with_import(b"MemError");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_last_mem_error(PPC_MEM_FULL_ERR);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_MEM_FULL_ERR));
assert_eq!(loaded.last_mem_error(), PPC_MEM_FULL_ERR);
}
#[test]
fn hle_import_runner_handles_block_move_with_overlap() {
let pef = synthetic_pef_with_import(b"BlockMove");
let mut loaded = load_pef_application(&pef).unwrap();
let buffer_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(buffer_ptr, b"abcdefgh".to_vec());
loaded.cpu.gpr[3] = buffer_ptr;
loaded.cpu.gpr[4] = buffer_ptr + 2;
loaded.cpu.gpr[5] = 6;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], buffer_ptr);
for (offset, byte) in b"ababcdef".iter().copied().enumerate() {
assert_eq!(
loaded.memory.read_u8(buffer_ptr + offset as u32),
Some(byte)
);
}
}
#[test]
fn hle_import_runner_handles_block_move_data_alias() {
let pef = synthetic_pef_with_import(b"BlockMoveData");
let mut loaded = load_pef_application(&pef).unwrap();
let source_ptr = PPC_DATA_BASE + 0x1000;
let dest_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(source_ptr, b"Gridz".to_vec());
loaded.memory.add_region(dest_ptr, vec![0; 5]);
loaded.cpu.gpr[3] = source_ptr;
loaded.cpu.gpr[4] = dest_ptr;
loaded.cpu.gpr[5] = 5;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
for (offset, byte) in b"Gridz".iter().copied().enumerate() {
assert_eq!(loaded.memory.read_u8(dest_ptr + offset as u32), Some(byte));
}
}
#[test]
fn hle_import_runner_handles_handle_size_queries() {
let pef = synthetic_pef_with_import(b"GetHandleSize");
let mut loaded = load_pef_application(&pef).unwrap();
test_handles!(loaded).push(PpcHandleRecord {
handle: PPC_HEAP_BASE,
ptr: PPC_HEAP_BASE + 4,
size: 123,
capacity: 123,
});
loaded
.memory
.write_u32_be(PPC_HEAP_BASE, PPC_HEAP_BASE + 4)
.unwrap();
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 123);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let pef = synthetic_pef_with_import(b"GetHandleSize");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_MAIN_CTABLE_HANDLE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_MAIN_CTABLE_SIZE);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut loaded = load_pef_application(&pef).unwrap();
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
b"abcdefghijkl",
);
assert_ne!(handle, 0);
let old_ptr = loaded.memory.read_u32_be(handle).unwrap();
let old_heap_cursor = loaded.heap_cursor();
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = 48;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], handle);
assert_eq!(test_handle_records!(loaded)[0].size, 48);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let new_ptr = loaded.memory.read_u32_be(handle).unwrap();
assert_eq!(new_ptr, old_ptr);
assert_eq!(test_handle_records!(loaded)[0].ptr, old_ptr);
assert_eq!(
loaded.heap_cursor(),
old_heap_cursor + ppc_allocation_size(48).unwrap() - ppc_allocation_size(12).unwrap()
);
for (offset, byte) in b"abcdefghijkl".iter().copied().enumerate() {
assert_eq!(loaded.memory.read_u8(new_ptr + offset as u32), Some(byte));
}
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut loaded = load_pef_application(&pef).unwrap();
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
b"abcdefghijkl",
);
assert_ne!(handle, 0);
let old_ptr = loaded.memory.read_u32_be(handle).unwrap();
let blocker = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
16,
true,
);
assert_ne!(blocker, 0);
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = 48;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], handle);
assert_eq!(test_handle_records!(loaded)[0].size, 48);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let new_ptr = loaded.memory.read_u32_be(handle).unwrap();
assert_ne!(new_ptr, old_ptr);
assert_eq!(test_handle_records!(loaded)[0].ptr, new_ptr);
assert!(handle < new_ptr || handle >= new_ptr + 48);
for (offset, byte) in b"abcdefghijkl".iter().copied().enumerate() {
assert_eq!(loaded.memory.read_u8(new_ptr + offset as u32), Some(byte));
}
}
#[test]
fn hle_import_runner_dispose_handle_invalidates_tracked_handle() {
let pef = synthetic_pef_with_import(b"DisposeHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
b"data",
);
assert_ne!(handle, 0);
let heap_cursor = loaded.heap_cursor();
loaded.aliases.push(PpcAliasRecord {
handle,
target_vref: PPC_BOOT_VOLUME_REF_NUM,
target_dir_id: PPC_ROOT_DIR_ID,
target_name: b"Target".to_vec(),
});
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"PICT"),
res_id: 128,
name: b"Title".to_vec(),
data: b"data".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle,
});
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], handle);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert!(test_handle_records!(loaded)
.iter()
.all(|record| record.handle != handle));
assert_eq!(loaded.memory.read_u32_be(handle), Some(0));
assert!(loaded.aliases.is_empty());
assert_eq!(loaded.process_file_system.vfs_resources[0].handle, 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetHandleSize;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.last_mem_error(), PPC_NIL_HANDLE_ERR);
}
#[test]
fn hle_import_runner_tracks_handle_lock_and_no_purge_state() {
let pef = synthetic_pef_with_import(b"HLock");
let mut loaded = load_pef_application(&pef).unwrap();
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
b"lockable",
);
assert_ne!(handle, 0);
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], handle);
assert_eq!(
loaded.handle_states(),
vec![PpcHandleStateRecord {
handle,
locked: true,
high_locked: false,
no_purge: false,
resource: false,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HNoPurge;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.handle_states(),
vec![PpcHandleStateRecord {
handle,
locked: true,
high_locked: false,
no_purge: true,
resource: false,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HLockHi;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.handle_states(),
vec![PpcHandleStateRecord {
handle,
locked: true,
high_locked: true,
no_purge: true,
resource: false,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HUnlock;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.handle_states(),
vec![PpcHandleStateRecord {
handle,
locked: false,
high_locked: false,
no_purge: true,
resource: false,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HLock;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.handle_states(),
vec![PpcHandleStateRecord {
handle,
locked: true,
high_locked: false,
no_purge: true,
resource: false,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HPurge;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.handle_states(),
vec![PpcHandleStateRecord {
handle,
locked: true,
high_locked: false,
no_purge: false,
resource: false,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HNoPurge;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.handle_states(),
vec![PpcHandleStateRecord {
handle,
locked: true,
high_locked: false,
no_purge: true,
resource: false,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MoveHHi;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], handle);
assert_eq!(
loaded.handle_states(),
vec![PpcHandleStateRecord {
handle,
locked: true,
high_locked: false,
no_purge: true,
resource: false,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HGetState;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x80);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HSetState;
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = 0x40;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.handle_states(),
vec![PpcHandleStateRecord {
handle,
locked: false,
high_locked: false,
no_purge: false,
resource: false,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = PPC_HEAP_BASE + 0x8000;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.handle_states().len(), 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(loaded.handle_states().is_empty());
assert!(test_handle_records!(loaded)
.iter()
.all(|record| record.handle != handle));
assert_eq!(loaded.memory.read_u32_be(handle), Some(0));
}
#[test]
fn hle_import_runner_dispose_handle_tolerates_unknown_handle() {
let pef = synthetic_pef_with_import(b"DisposeHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let heap_cursor = loaded.heap_cursor();
loaded.set_last_mem_error(PPC_MEM_FULL_ERR);
loaded.cpu.gpr[3] = PPC_HEAP_BASE + 0x4000;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE + 0x4000);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert!(test_handle_records!(loaded).is_empty());
}
#[test]
fn hle_import_runner_handles_new_handle_clear_allocation() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut loaded = load_pef_application(&pef).unwrap();
let heap_cursor = loaded.heap_cursor();
loaded.cpu.gpr[3] = 12;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let handle = loaded.cpu.gpr[3];
assert_ne!(handle, 0);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(test_handle_records!(loaded).len(), 1);
assert_eq!(test_handle_records!(loaded)[0].handle, handle);
assert_eq!(handle, heap_cursor);
assert_eq!(handle & (PPC_HEAP_ALIGNMENT - 1), 0);
assert_eq!(
test_handle_records!(loaded)[0].ptr,
heap_cursor + PPC_HEAP_ALIGNMENT
);
assert_eq!(
test_handle_records!(loaded)[0].ptr & (PPC_HEAP_ALIGNMENT - 1),
0
);
assert_eq!(test_handle_records!(loaded)[0].size, 12);
assert_eq!(
loaded.memory.read_u32_be(handle),
Some(heap_cursor + PPC_HEAP_ALIGNMENT)
);
assert_eq!(
loaded.heap_cursor(),
heap_cursor + ppc_allocation_size(4).unwrap() + ppc_allocation_size(12).unwrap()
);
for offset in 0..12 {
assert_eq!(
loaded
.memory
.read_u8(heap_cursor + PPC_HEAP_ALIGNMENT + offset),
Some(0)
);
}
}
#[test]
fn new_handle_abi_marshalling_shares_semantics_without_sharing_addresses() {
fn classic_outcome(
trap_word: u16,
clear: bool,
size: u32,
) -> (bool, i16, Option<u8>, Option<u32>, Option<bool>) {
let (mut dispatcher, mut cpu, mut bus) = crate::trap::test_helpers::setup();
dispatcher.current_trap_word = trap_word;
cpu.write_reg(Register::D0, size);
dispatcher
.dispatch_memory(false, 0x22, &mut cpu, &mut bus)
.expect("classic NewHandle should be handled")
.expect("classic NewHandle should return cleanly");
let handle = cpu.read_reg(Register::A0);
let error = cpu.read_reg(Register::D0) as i16;
if handle == 0 {
return (false, error, None, None, None);
}
let state = dispatcher.handle_state_bits(handle);
let ptr = bus.read_long(handle);
let memory_manager = dispatcher.process_memory_manager();
let memory_manager = memory_manager.borrow();
let allocation_size = memory_manager.classic_allocation_size(ptr);
let contents_zero = clear.then(|| {
bus.read_bytes(ptr, allocation_size.unwrap_or(0) as usize)
.iter()
.all(|&byte| byte == 0)
});
(true, error, state, allocation_size, contents_zero)
}
fn native_outcome(
clear: bool,
size: u32,
) -> (bool, i16, Option<u8>, Option<u32>, Option<bool>) {
let import = if clear {
b"NewHandleClear".as_slice()
} else {
b"NewHandle".as_slice()
};
let pef = synthetic_pef_with_import(import);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = size;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::NewHandle { clear },
);
let handle = loaded.cpu.gpr[3];
let error = loaded.last_mem_error();
let (state, record) = {
let memory_manager = loaded.process_memory_manager.0.borrow();
(
memory_manager.state_for_handle(handle),
memory_manager.native_allocation(handle),
)
};
let contents_zero = if clear {
record.map(|record| {
(0..record.size)
.all(|offset| loaded.memory.read_u8(record.ptr + offset) == Some(0))
})
} else {
// Ordinary NewHandle contents are undefined. Do not compare
// whatever byte pattern a backend happens to leave there.
None
};
(
handle != 0,
error,
state,
record.map(|record| record.size),
contents_zero,
)
}
// The four classic trap variants (current/system × clear/non-clear)
// must reach the same semantic operation as the native InterfaceLib
// entry points. Handles and data pointers are intentionally omitted
// from the compared outcome because each allocator owns its physical
// address, alignment, and layout.
for (trap_word, clear) in [
(0xA022, false),
(0xA322, true),
(0xA422, false),
(0xA622, true),
] {
let classic = classic_outcome(trap_word, clear, 13);
let native = native_outcome(clear, 13);
assert_eq!(classic, native, "trap ${trap_word:04X} semantic outcome");
assert_eq!(
classic,
(true, 0, Some(0), Some(13), clear.then_some(true))
);
}
// Macintosh Size is signed. Both ABI adapters reject the same
// negative value before entering an unsigned physical allocator.
let classic = classic_outcome(0xA022, false, u32::MAX);
let native = native_outcome(false, u32::MAX);
assert_eq!(classic, native);
assert_eq!(classic, (false, -108, None, None, None));
fn classic_mem_full_outcome() -> (bool, i16, Option<u8>, Option<u32>, Option<bool>) {
let (mut dispatcher, mut cpu, mut bus) = crate::trap::test_helpers::setup();
let heap_limit = bus.classic_heap_limit();
bus.reserve_heap_until(heap_limit);
dispatcher.current_trap_word = 0xA022;
cpu.write_reg(Register::D0, 24);
dispatcher
.dispatch_memory(false, 0x22, &mut cpu, &mut bus)
.expect("classic NewHandle should be handled")
.expect("classic NewHandle failure should stay in the ABI shim");
(
cpu.read_reg(Register::A0) != 0,
cpu.read_reg(Register::D0) as i16,
dispatcher.handle_state_bits(cpu.read_reg(Register::A0)),
None,
None,
)
}
fn native_mem_full_outcome() -> (bool, i16, Option<u8>, Option<u32>, Option<bool>) {
let pef = synthetic_pef_with_import(b"NewHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let heap_cursor = loaded.heap_cursor();
loaded.set_heap_limit(heap_cursor + 8);
loaded.cpu.gpr[3] = 24;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::NewHandle { clear: false },
);
let handle = loaded.cpu.gpr[3];
let state = loaded
.process_memory_manager
.0
.borrow()
.state_for_handle(handle);
(
handle != 0,
loaded.last_mem_error(),
state,
None,
None,
)
}
let classic = classic_mem_full_outcome();
let native = native_mem_full_outcome();
assert_eq!(classic, native);
assert_eq!(classic, (false, -108, None, None, None));
// TempNewHandle has a result-code pointer and temporary lifetime, so
// it remains a distinct ABI route rather than silently inheriting the
// ordinary NewHandle request/result operation above.
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "TempNewHandle"),
PpcImportDispatcherTarget::TempNewHandle
);
}
#[test]
fn hle_import_runner_reuses_disposed_handle_capacity() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 64;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let handle = loaded.cpu.gpr[3];
let ptr = loaded.memory.read_u32_be(handle).unwrap();
let heap_cursor = loaded.heap_cursor();
loaded.memory.write_u8(ptr, 0xff).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert!(test_handle_records!(loaded).is_empty());
assert_eq!(loaded.free_handle_blocks().len(), 1);
assert_eq!(loaded.free_handle_blocks()[0].capacity, 64);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::NewHandle { clear: true };
loaded.cpu.gpr[3] = 16;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], handle);
assert_eq!(loaded.memory.read_u32_be(handle), Some(ptr));
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(test_handle_records!(loaded)[0].size, 16);
assert_eq!(test_handle_records!(loaded)[0].capacity, 64);
assert!(loaded.free_handle_blocks().is_empty());
for offset in 0..16 {
assert_eq!(loaded.memory.read_u8(ptr + offset), Some(0));
}
}
#[test]
fn hle_import_runner_handles_temp_new_handle_result_code() {
let pef = synthetic_pef_with_import(b"TempNewHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let result_code_ptr = PPC_DATA_BASE;
loaded.memory.add_region(result_code_ptr, vec![0xff; 4]);
loaded.cpu.gpr[3] = 5;
loaded.cpu.gpr[4] = result_code_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let handle = loaded.cpu.gpr[3];
assert_ne!(handle, 0);
assert_eq!(
loaded.memory.read_u16_be(result_code_ptr),
Some(PPC_NO_ERR as u16)
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(test_handle_records!(loaded).len(), 1);
assert_eq!(test_handle_records!(loaded)[0].handle, handle);
assert_eq!(test_handle_records!(loaded)[0].size, 5);
}
#[test]
fn hle_import_runner_temp_new_handle_heap_full_reports_result_code() {
let pef = synthetic_pef_with_import(b"TempNewHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let result_code_ptr = PPC_DATA_BASE;
let heap_cursor = loaded.heap_cursor();
loaded.memory.add_region(result_code_ptr, vec![0xff; 4]);
loaded.set_heap_limit(heap_cursor + 8);
loaded.cpu.gpr[3] = 4;
loaded.cpu.gpr[4] = result_code_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u16_be(result_code_ptr),
Some(PPC_MEM_FULL_ERR as u16)
);
assert_eq!(loaded.last_mem_error(), PPC_MEM_FULL_ERR);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert!(test_handle_records!(loaded).is_empty());
}
#[test]
fn hle_import_runner_handles_max_mem_and_writes_zero_grow() {
let pef = synthetic_pef_with_import(b"MaxMem");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_DATA_BASE;
loaded
.memory
.write_u32_be(PPC_DATA_BASE, 0xffff_ffff)
.unwrap();
let free = test_heap_limit!(loaded) - loaded.heap_cursor();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], free);
assert_eq!(loaded.memory.read_u32_be(PPC_DATA_BASE), Some(0));
}
#[test]
fn hle_import_runner_handles_cur_res_file() {
let pef = synthetic_pef_with_import(b"CurResFile");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_current_resource_refnum(7);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 7);
}
#[test]
fn hle_import_runner_handles_use_res_file_and_res_error_state() {
let pef = synthetic_pef_with_import(b"UseResFile");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 5;
loaded.set_test_resource_error(-192);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 5);
assert_eq!(*loaded.process_file_system.current_resource_file, 5);
assert_eq!(loaded.test_resource_error(), 0);
}
#[test]
fn hle_import_runner_handles_signed_res_error() {
let pef = synthetic_pef_with_import(b"ResError");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_test_resource_error(-192);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], (-192i32) as u32);
}
#[test]
fn hle_import_runner_models_stdc_signal_install_ignore_and_default() {
let pef = synthetic_pef_with_library_import(b"StdCLib", b"signal");
let mut loaded = load_pef_application(&pef).unwrap();
let signal = 16;
let first_handler = 0x0302_9b38;
let second_handler = 0x0302_9b3c;
loaded.cpu.gpr[3] = signal;
loaded.cpu.gpr[4] = first_handler;
let first = loaded.run_with_hle_imports(64);
assert_eq!(first.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = signal;
loaded.cpu.gpr[4] = second_handler;
let second = loaded.run_with_hle_imports(64);
assert_eq!(second.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], first_handler);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = signal;
loaded.cpu.gpr[4] = 1; // SIG_IGN
let ignored = loaded.run_with_hle_imports(64);
assert_eq!(ignored.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], second_handler);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = signal;
loaded.cpu.gpr[4] = 0; // SIG_DFL
let defaulted = loaded.run_with_hle_imports(64);
assert_eq!(defaulted.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = signal;
loaded.cpu.gpr[4] = first_handler;
let reinstalled = loaded.run_with_hle_imports(64);
assert_eq!(reinstalled.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0; // invalid signal number
loaded.cpu.gpr[4] = second_handler;
let invalid = loaded.run_with_hle_imports(64);
assert_eq!(invalid.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], u32::MAX);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = signal;
loaded.cpu.gpr[4] = 0;
let unchanged = loaded.run_with_hle_imports(64);
assert_eq!(unchanged.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], first_handler);
}
#[test]
fn cfm_initializer_storage_reuses_only_completed_or_refused_allocations() {
let calls = SharedGuestCallStack::default();
let owner = PpcProcessMemoryManager::with_heap(PPC_HEAP_BASE, PPC_HEAP_BASE + 0x1000);
let mut manager = owner.0.borrow_mut();
let mut memory = PpcSectionMem::new();
memory.add_region(0x1000, 0x4e80_0020u32.to_be_bytes().to_vec());
memory.add_region(
0x2000,
[0x1000u32, 0x2100]
.into_iter()
.flat_map(u32::to_be_bytes)
.collect(),
);
memory.add_region(0x8000, vec![0; 128]);
let mut cursor = PPC_HEAP_BASE;
let mut allocate = |manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem| {
ppc_create_mem_fragment_init_block(
Some(manager),
memory,
&mut cursor,
PPC_HEAP_BASE + 0x1000,
1,
0x6000,
123,
"nested",
)
.unwrap()
};
let first = allocate(&mut manager, &mut memory);
let mut cpu = PpcCpu::new();
cpu.gpr[1] = 0x8000;
cpu.lr = 0x4000;
assert_eq!(
ppc_activate_cfm_initializer(
&mut cpu,
&mut memory,
&calls,
&mut manager,
0x2000,
first,
None,
),
PpcImportAction::Continue
);
let second = allocate(&mut manager, &mut memory);
assert_ne!(first, second);
cpu.lr = 0x1000;
assert_eq!(
ppc_activate_cfm_initializer(
&mut cpu,
&mut memory,
&calls,
&mut manager,
0x2000,
second,
None,
),
PpcImportAction::Continue
);
cpu.pc = PPC_GUEST_CALL_RETURN_PC;
assert!(calls.complete_powerpc_releasing_scratch(&mut cpu, &mut manager));
assert_eq!(
manager
.native_ptr_records()
.iter()
.map(|p| p.ptr)
.collect::<Vec<_>>(),
vec![first]
);
let third = allocate(&mut manager, &mut memory);
assert_eq!(third, second, "the live outer block must not be reused");
let outer_name = first + PPC_CFM_INIT_BLOCK_SIZE;
assert_eq!(
ppc_read_pstring_bytes(&mut memory, outer_name),
Some(b"nested".to_vec())
);
cpu.gpr[1] = u32::MAX;
let before = calls.clone();
assert_eq!(
ppc_activate_cfm_initializer(
&mut cpu,
&mut memory,
&calls,
&mut manager,
0x2000,
third,
None,
),
PpcImportAction::Return(ppc_i16_result(PPC_FRAG_CORRUPT_ERR))
);
assert_eq!(calls, before);
assert_eq!(
manager
.native_ptr_records()
.iter()
.map(|p| p.ptr)
.collect::<Vec<_>>(),
vec![first]
);
let fourth = allocate(&mut manager, &mut memory);
assert_eq!(fourth, second);
assert_eq!(
ppc_activate_cfm_initializer(
&mut cpu,
&mut memory,
&calls,
&mut manager,
u32::MAX - 3,
fourth,
None,
),
PpcImportAction::Return(ppc_i16_result(PPC_FRAG_CORRUPT_ERR))
);
cpu.pc = PPC_GUEST_CALL_RETURN_PC;
assert!(calls.complete_powerpc_releasing_scratch(&mut cpu, &mut manager));
assert_eq!(cpu.pc, 0x4000);
assert!(manager.native_ptr_records().is_empty());
assert_eq!(manager.native_free_ptr_blocks().len(), 2);
}
#[test]
fn cfm_load_resumes_after_initialization_and_failed_loads_can_retry() {
use crate::execution_kernel::ExecutionTaskState;
for (use_memory, failed) in [(false, false), (false, true), (true, false), (true, true)] {
let calls = SharedGuestCallStack::default();
let worker = calls.create_task().unwrap();
assert!(calls.set_scheduling_state(worker, ExecutionTaskState::Ready));
assert!(calls.switch_to_task(worker));
let owner = PpcProcessMemoryManager::with_heap(PPC_HEAP_BASE, PPC_HEAP_BASE + 0x10000);
let mut manager = owner.0.borrow_mut();
let mut memory = PpcSectionMem::new();
memory.add_region(PPC_HEAP_BASE, vec![0; 0x10000]);
memory.add_region(0x5000, b"\x04test".to_vec());
memory.add_region(0x6000, vec![0xa5; 64]);
memory.add_region(0x8000, vec![0; 128]);
let fragment = synthetic_pef_with_initializer();
memory.add_region(0x9000, fragment.clone());
let mut libraries = vec![PpcCfmLibraryFragment {
name: "test".to_string(),
bytes: synthetic_pef_with_initializer(),
}];
let mut connections = Vec::new();
let mut next_connection = PPC_FIRST_CFM_CONNECTION_ID;
let mut import_run_state =
PpcImportRunState::from_parts(Vec::new(), 0, ppc_import_layout());
let mut cursor = PPC_HEAP_BASE;
let mut cpu = PpcCpu::new();
cpu.gpr[1] = 0x8000;
cpu.gpr[2] = 0x2200;
cpu.lr = 0x4000;
cpu.gpr[3] = 0x5000;
cpu.gpr[4] = PPC_CFM_POWERPC_ARCH;
cpu.gpr[5] = PPC_CFM_LOAD_LIB;
cpu.gpr[6] = 0x6000;
cpu.gpr[7] = 0x6004;
cpu.gpr[8] = 0x6008;
if use_memory {
cpu.gpr[3] = 0x9000;
cpu.gpr[4] = fragment.len() as u32;
cpu.gpr[5] = 0x5000;
cpu.gpr[6] = PPC_CFM_LOAD_LIB;
cpu.gpr[7] = 0x6000;
cpu.gpr[8] = 0x6004;
cpu.gpr[9] = 0x6008;
}
let request = cpu.clone();
macro_rules! load {
($cpu:expr) => {
if use_memory {
ppc_get_mem_fragment(
$cpu,
&calls,
&mut manager,
&mut memory,
&mut cursor,
PPC_HEAP_BASE + 0x10000,
&mut connections,
&mut next_connection,
&mut import_run_state,
)
} else {
ppc_get_shared_library(
$cpu,
&calls,
&mut manager,
&mut memory,
&mut cursor,
PPC_HEAP_BASE + 0x10000,
&mut connections,
&mut libraries,
&mut next_connection,
&mut import_run_state,
)
}
};
}
assert_eq!(load!(&mut cpu), PpcImportAction::Continue);
let id = connections[0].id;
assert!(calls.is_cfm_load_pending(CfmLoadId(id)));
assert_eq!(import_run_state.total_count(), 1);
assert_eq!(
import_run_state.binding_cloned(0).unwrap().symbol_name,
"TestImport"
);
assert_eq!(memory.read_u32_be(0x6000), Some(0xa5a5_a5a5));
assert_eq!(memory.read_u32_be(0x6004), Some(0xa5a5_a5a5));
let mut recursive = request.clone();
assert_eq!(
load!(&mut recursive),
PpcImportAction::Return(ppc_i16_result(PPC_FRAG_INIT_LOOP))
);
assert_eq!(import_run_state.total_count(), 1);
assert_eq!(connections.len(), 1);
assert_eq!(manager.native_ptr_records().len(), 1);
memory.add_region(0x5100, b"\x05inner".to_vec());
libraries.push(PpcCfmLibraryFragment {
name: "inner".to_string(),
bytes: fragment.clone(),
});
let mut inner = request.clone();
inner.gpr[if use_memory { 5 } else { 3 }] = 0x5100;
assert_eq!(load!(&mut inner), PpcImportAction::Continue);
let inner_id = connections[1].id;
assert_ne!(inner_id, id);
assert!(calls.is_cfm_load_pending(CfmLoadId(inner_id)));
assert_eq!(import_run_state.total_count(), 2);
assert_eq!(
import_run_state.binding_cloned(0).unwrap().symbol_name,
"TestImport"
);
assert_eq!(
import_run_state.binding_cloned(1).unwrap().symbol_name,
"TestImport"
);
inner.pc = PPC_GUEST_CALL_RETURN_PC;
inner.gpr[3] = 1;
assert!(calls.complete_powerpc_resuming_load(
&mut inner,
&mut manager,
|operation, result| ppc_complete_cfm_load(
operation,
result,
&mut memory,
&mut connections
)
));
assert!(!calls.is_cfm_load_pending(CfmLoadId(inner_id)));
assert!(calls.is_cfm_load_pending(CfmLoadId(id)));
assert_eq!(connections.len(), 1);
assert_eq!(connections[0].id, id);
assert_eq!(manager.native_ptr_records().len(), 1);
// Give the prepared test fragment an initializer returning the chosen OSErr.
memory
.write_u32_be(cpu.pc, 0x3860_0000 | u32::from(failed))
.unwrap();
memory.write_u32_be(cpu.pc + 4, 0x4e80_0020).unwrap();
assert_eq!(
cpu.run_with_imports(&mut memory, 2, 0, 0xff00_0000, 0, |_, _, _| {
PpcImportAction::Halt
}),
PpcRunResult::CycleLimit { cycles: 2 }
);
assert_eq!(cpu.pc, PPC_GUEST_CALL_RETURN_PC);
let before = calls.clone();
assert!(!calls.complete_powerpc_releasing_scratch(&mut cpu, &mut manager));
assert_eq!(
calls, before,
"the manager operation cannot be discarded by a plain return"
);
assert!(calls.complete_powerpc_resuming_load(
&mut cpu,
&mut manager,
|operation, result| ppc_complete_cfm_load(
operation,
result,
&mut memory,
&mut connections
)
));
assert_eq!(import_run_state.total_count(), 2);
assert_eq!((cpu.pc, cpu.gpr[2]), (0x4000, 0x2200));
assert!(!calls.is_cfm_load_pending(CfmLoadId(id)));
assert!(manager.native_ptr_records().is_empty());
if failed {
assert_eq!(cpu.gpr[3], ppc_i16_result(PPC_FRAG_USER_INIT_PROC_ERR));
assert!(connections.is_empty());
assert_eq!(memory.read_u32_be(0x6000), Some(0xa5a5_a5a5));
cpu = request.clone();
assert_eq!(load!(&mut cpu), PpcImportAction::Continue);
assert_eq!(import_run_state.total_count(), 3);
assert!(connections[0].id > id);
cpu.pc = PPC_GUEST_CALL_RETURN_PC;
cpu.gpr[3] = 1;
assert!(calls.complete_powerpc_resuming_load(
&mut cpu,
&mut manager,
|operation, result| ppc_complete_cfm_load(
operation,
result,
&mut memory,
&mut connections
)
));
assert!(connections.is_empty());
assert_eq!(import_run_state.total_count(), 3);
} else {
assert_eq!(cpu.gpr[3], 0);
assert_eq!(import_run_state.total_count(), 2);
assert!(import_run_state.binding_cloned(0).is_some());
assert!(import_run_state.binding_cloned(1).is_some());
assert_eq!(memory.read_u32_be(0x6000), Some(id));
assert_eq!(memory.read_u32_be(0x6004), Some(connections[0].main_addr));
cpu = request.clone();
assert_eq!(load!(&mut cpu), PpcImportAction::Return(0));
assert_eq!(connections.len(), 1);
cpu.gpr[if use_memory { 7 } else { 6 }] = 0x7000;
assert_eq!(
load!(&mut cpu),
PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR))
);
assert_eq!(
connections[0].id, id,
"bad outputs must not invalidate a reused ready connection"
);
}
assert!(calls.is_empty());
assert!(manager.native_ptr_records().is_empty());
}
}
#[test]
fn cfm_initializer_storage_is_released_when_load_outputs_become_readonly() {
for invalid_register in [6, 7, 8] {
let calls = SharedGuestCallStack::default();
let owner = PpcProcessMemoryManager::with_heap(PPC_HEAP_BASE, PPC_HEAP_BASE + 0x10000);
let mut manager = owner.0.borrow_mut();
let mut memory = PpcSectionMem::new();
memory.add_region(PPC_HEAP_BASE, vec![0; 0x10000]);
let fragment = synthetic_pef_with_initializer();
let mut cpu = PpcCpu::new();
cpu.gpr[1] = 0x8000;
memory.add_region(0x8000, vec![0; 128]);
cpu.gpr[3] = 0x5000;
cpu.gpr[4] = PPC_CFM_POWERPC_ARCH;
cpu.gpr[5] = PPC_CFM_LOAD_LIB;
cpu.gpr[6] = 0x6000;
cpu.gpr[7] = 0x6004;
cpu.gpr[8] = 0x6008;
cpu.gpr[invalid_register] = 0x7000;
memory.add_region(0x5000, b"\x06nested".to_vec());
let mut libraries = vec![PpcCfmLibraryFragment {
name: "nested".to_string(),
bytes: fragment,
}];
memory.add_region(0x6000, vec![0; 64]);
memory.add_region(0x7000, vec![0; 4]);
let mut cursor = PPC_HEAP_BASE;
let mut connections = Vec::new();
let mut next_connection = PPC_FIRST_CFM_CONNECTION_ID;
let mut import_run_state =
PpcImportRunState::from_parts(Vec::new(), 0, ppc_import_layout());
assert_eq!(
ppc_get_shared_library(
&mut cpu,
&calls,
&mut manager,
&mut memory,
&mut cursor,
PPC_HEAP_BASE + 0x10000,
&mut connections,
&mut libraries,
&mut next_connection,
&mut import_run_state
),
PpcImportAction::Continue
);
assert_eq!(
connections.len(),
1,
"reached output publication after preparing the initializer"
);
assert!(calls.is_cfm_load_pending(CfmLoadId(connections[0].id)));
assert_eq!(memory.read_u32_be(0x6000), Some(0));
memory.add_readonly_region(0x7000, vec![0; 4]);
cpu.pc = PPC_GUEST_CALL_RETURN_PC;
cpu.gpr[3] = 0;
assert!(calls.complete_powerpc_resuming_load(
&mut cpu,
&mut manager,
|operation, result| ppc_complete_cfm_load(
operation,
result,
&mut memory,
&mut connections
)
));
assert_eq!(cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert!(connections.is_empty());
assert!(manager.native_ptr_records().is_empty());
assert_eq!(manager.native_free_ptr_blocks().len(), 1);
assert!(calls.is_empty());
}
}
#[test]
fn cfm_initializer_storage_allocation_failure_leaves_no_partial_block() {
let owner = PpcProcessMemoryManager::with_heap(PPC_HEAP_BASE, PPC_HEAP_BASE + 64);
let mut manager = owner.0.borrow_mut();
manager.set_native_mem_error(-42);
let mut memory = PpcSectionMem::new();
memory.add_region(PPC_HEAP_BASE, vec![0xa5; 64]);
let mut cursor = PPC_HEAP_BASE;
assert_eq!(
ppc_create_mem_fragment_init_block(
Some(&mut manager),
&mut memory,
&mut cursor,
PPC_HEAP_BASE + 64,
1,
0x6000,
123,
&"x".repeat(40)
),
Err(PPC_FRAG_NO_MEM)
);
assert_eq!(cursor, PPC_HEAP_BASE);
assert_eq!(manager.native_heap_state().unwrap().last_mem_error, -42);
assert_eq!(
manager.native_heap_state().unwrap().heap_cursor,
PPC_HEAP_BASE
);
assert!(manager.native_ptr_records().is_empty());
assert!((0..64).all(|offset| memory.read_u8(PPC_HEAP_BASE + offset) == Some(0xa5)));
}
#[test]
fn cfm_initializer_effect_executes_and_returns_to_its_worker() {
use crate::execution_kernel::ExecutionTaskState;
for result in [0u16, 0xffff] {
let calls = SharedGuestCallStack::default();
let worker = calls.create_task().unwrap();
assert!(calls.set_scheduling_state(worker, ExecutionTaskState::Ready));
assert!(calls.switch_to_task(worker));
let mut memory = PpcSectionMem::new();
memory.add_region(
0x1000,
[0x3860_0000 | u32::from(result), 0x4e80_0020]
.into_iter()
.flat_map(u32::to_be_bytes)
.collect(),
);
memory.add_region(
0x2000,
[0x1000u32, 0x2100]
.into_iter()
.flat_map(u32::to_be_bytes)
.collect(),
);
memory.add_region(0x8000, vec![0xa5; 128]);
let owner = PpcProcessMemoryManager::with_heap(PPC_HEAP_BASE, PPC_HEAP_BASE + 0x1000);
let mut manager = owner.0.borrow_mut();
let mut cursor = PPC_HEAP_BASE;
let init_block = ppc_create_mem_fragment_init_block(
Some(&mut manager),
&mut memory,
&mut cursor,
PPC_HEAP_BASE + 0x1000,
17,
0x6000,
123,
"worker initializer",
)
.unwrap();
assert_eq!(manager.native_ptr_records().len(), 1);
assert_eq!(
memory.read_u32_be(init_block + 28),
Some(init_block + PPC_CFM_INIT_BLOCK_SIZE)
);
assert_eq!(memory.read_u32_be(init_block + 8), Some(17));
let mut cpu = PpcCpu::new();
cpu.gpr[1] = 0x8000;
cpu.gpr[2] = 0x2200;
cpu.lr = 0x4000;
assert_eq!(
ppc_activate_cfm_initializer(
&mut cpu,
&mut memory,
&calls,
&mut manager,
0x2000,
init_block,
None,
),
PpcImportAction::Continue
);
assert_eq!((cpu.gpr[3], cpu.gpr[12]), (init_block, 0x2000));
assert_eq!(calls.current_task(), worker);
assert_eq!(calls.task_depth(worker), 1);
assert_eq!(
cpu.run_with_imports(&mut memory, 2, 0, 0xff00_0000, 0, |_, _, _| {
PpcImportAction::Halt
}),
PpcRunResult::CycleLimit { cycles: 2 }
);
assert_eq!(cpu.pc, PPC_GUEST_CALL_RETURN_PC);
let before = calls.clone();
assert!(!calls.complete_powerpc(&mut cpu));
assert_eq!(
calls, before,
"a return without the allocator must retain its storage"
);
manager.set_native_mem_error(-108);
assert!(calls.complete_powerpc_releasing_scratch(&mut cpu, &mut manager));
assert!(manager.native_ptr_records().is_empty());
assert_eq!(manager.native_free_ptr_blocks().len(), 1);
assert_eq!(manager.native_heap_state().unwrap().last_mem_error, -108);
assert!(!calls.complete_powerpc_releasing_scratch(&mut cpu, &mut manager));
assert_eq!(manager.native_free_ptr_blocks().len(), 1);
assert_eq!((cpu.pc, cpu.lr, cpu.gpr[2]), (0x4000, 0x4000, 0x2200));
assert_eq!(
cpu.gpr[3],
ppc_i16_result(if result == 0 {
PPC_NO_ERR
} else {
PPC_FRAG_USER_INIT_PROC_ERR
})
);
assert!(calls.is_empty());
}
}
#[test]
fn hle_import_runner_handles_get_shared_library_and_reuses_connection() {
let pef = synthetic_pef_with_import(b"GetSharedLibrary");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_HEAP_BASE;
loaded.memory.add_region(scratch, vec![0; 128]);
write_ppc_pstring(&mut loaded.memory, scratch, b"QuickDraw\xaa 3D");
let conn_id_ptr = scratch + 32;
let main_addr_ptr = scratch + 36;
let err_name_ptr = scratch + 40;
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"pwpc");
loaded.cpu.gpr[5] = 1; // kLoadLib
loaded.cpu.gpr[6] = conn_id_ptr;
loaded.cpu.gpr[7] = main_addr_ptr;
loaded.cpu.gpr[8] = err_name_ptr;
let first = loaded.run_with_hle_imports(64);
assert_eq!(first.handled_import_count, 1);
assert_eq!(first.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(conn_id_ptr),
Some(PPC_FIRST_CFM_CONNECTION_ID)
);
assert_eq!(
loaded.memory.read_u32_be(main_addr_ptr),
Some(PPC_CFM_MAIN_STUB_BASE)
);
assert_eq!(loaded.memory.read_u8(err_name_ptr), Some(0));
assert_eq!(loaded.cfm.as_ref().unwrap().connections.len(), 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.memory.write_u32_be(conn_id_ptr, 0).unwrap();
loaded.memory.write_u32_be(main_addr_ptr, 0).unwrap();
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"pwpc");
loaded.cpu.gpr[5] = 2; // kFindLib
loaded.cpu.gpr[6] = conn_id_ptr;
loaded.cpu.gpr[7] = main_addr_ptr;
loaded.cpu.gpr[8] = err_name_ptr;
let second = loaded.run_with_hle_imports(64);
assert_eq!(second.handled_import_count, 1);
assert_eq!(second.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(conn_id_ptr),
Some(PPC_FIRST_CFM_CONNECTION_ID)
);
assert_eq!(
loaded.memory.read_u32_be(main_addr_ptr),
Some(PPC_CFM_MAIN_STUB_BASE)
);
assert_eq!(loaded.cfm.as_ref().unwrap().connections.len(), 1);
}
#[test]
fn cfm_symbol_enumeration_imports_route_aliases_and_preserve_failed_outputs() {
for library in [
"InterfaceLib",
"CodeFragmentMgr",
"CarbonCore.vlib",
"CFMPriv_CarbonCore",
] {
for count in [false, true] {
let name = if count {
"CountSymbols"
} else {
"GetIndSymbol"
};
for fault in 0..4 {
let mut loaded = load_pef_application(&synthetic_pef_with_library_import(
library.as_bytes(),
name.as_bytes(),
))
.unwrap();
const OUTPUT: u32 = PPC_HEAP_BASE + 0x100;
loaded.memory.add_region(OUTPUT, vec![0xa5; 64]);
loaded
.cfm
.as_mut()
.unwrap()
.connections
.push(PpcCfmConnection {
id: 7,
library_name: "fixture".into(),
main_addr: 0,
init_addr: 0,
term_addr: 0,
exports: vec![PpcCfmExport {
name: "Café™".into(),
class: 2,
address: 0x1234_5678,
}],
});
loaded.cpu.gpr[3] = if fault == 1 { 99 } else { 7 };
loaded.cpu.gpr[4] = if count {
OUTPUT
} else if fault == 2 {
2
} else {
1
};
loaded.cpu.gpr[5] = OUTPUT;
loaded.cpu.gpr[6] = OUTPUT + 32;
loaded.cpu.gpr[7] = OUTPUT + 40;
if fault == 3 {
loaded
.memory
.add_readonly_region(OUTPUT + if count { 1 } else { 40 }, vec![0xa5]);
}
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.handled_import_count, 1, "{library} {name}");
assert_eq!(probe.unsupported_import_index, None);
let error: i16 = match fault {
1 => -2801,
2 if !count => -2802,
3 => -50,
_ => 0,
};
assert_eq!(loaded.cpu.gpr[3], error as i32 as u32);
if error != 0 {
assert!((0..64).all(|i| loaded.memory.read_u8(OUTPUT + i) == Some(0xa5)));
} else if count {
assert_eq!(loaded.memory.read_u32_be(OUTPUT), Some(1));
} else {
assert_eq!(loaded.memory.read_u32_be(OUTPUT + 32), Some(0x1234_5678));
assert_eq!(loaded.memory.read_u8(OUTPUT + 40), Some(2));
}
}
}
}
}
pub(crate) fn synthetic_pef_with_enumerable_exports() -> Vec<u8> {
let name = b"Caf\x8e\xaa";
let strings_offset = 56usize;
let hash_offset = strings_offset + name.len() + 1;
let key_offset = hash_offset + 4;
let symbol_offset = key_offset + 4;
let mut loader = vec![0; symbol_offset + 10];
write_i32(&mut loader, 0, -1);
write_i32(&mut loader, 8, -1);
write_i32(&mut loader, 16, -1);
write_u32(&mut loader, 40, strings_offset as u32);
write_u32(&mut loader, 44, hash_offset as u32);
write_u32(&mut loader, 52, 1);
loader[strings_offset..strings_offset + name.len()].copy_from_slice(name);
write_u32(&mut loader, hash_offset, 1 << 18);
write_u32(&mut loader, key_offset, (name.len() as u32) << 16);
write_u32(&mut loader, symbol_offset, 1 << 24); // data, string offset zero
write_u32(&mut loader, symbol_offset + 4, 0x1234_5678);
write_u16(&mut loader, symbol_offset + 8, (-2i16) as u16); // absolute export
synthetic_pef_with_loader_and_data(loader, &[0; 8])
}
#[test]
fn cfm_reifies_real_pef_exports_with_section_absolute_and_reexported_addresses() {
let fragment = synthetic_pef_with_exports();
let mapped = vec![MappedSection {
index: 1,
section_kind: SECTION_KIND_UNPACKED_DATA,
base: 0x0310_0000,
bytes: vec![0; 8],
}];
let exports = crate::cfm::fragment::resolve_fragment_exports(
&fragment,
&mapped,
&[0xcafe_babe, 0xdead_beef],
)
.unwrap();
assert_eq!(
exports,
vec![
PpcCfmExport {
name: "tvector".to_string(),
class: 2,
address: 0x0310_0000,
},
PpcCfmExport {
name: "absolute".to_string(),
class: 1,
address: 0x1234_5678,
},
PpcCfmExport {
name: "reexport".to_string(),
class: 2,
address: 0xcafe_babe,
},
]
);
}
#[test]
fn get_shared_library_does_not_fabricate_unknown_connections() {
let pef = synthetic_pef_with_import(b"GetSharedLibrary");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_HEAP_BASE;
loaded.memory.add_region(scratch, vec![0; 128]);
write_ppc_pstring(&mut loaded.memory, scratch, b"MissingLibrary");
let conn_id_ptr = scratch + 32;
let main_addr_ptr = scratch + 36;
let err_name_ptr = scratch + 40;
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = PPC_CFM_POWERPC_ARCH;
loaded.cpu.gpr[5] = PPC_CFM_LOAD_LIB;
loaded.cpu.gpr[6] = conn_id_ptr;
loaded.cpu.gpr[7] = main_addr_ptr;
loaded.cpu.gpr[8] = err_name_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_FRAG_LIB_NOT_FOUND));
assert!(loaded.cfm.as_ref().unwrap().connections.is_empty());
}
#[test]
fn get_shared_library_requires_powerpc_architecture() {
let pef = synthetic_pef_with_import(b"GetSharedLibrary");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_HEAP_BASE;
loaded.memory.add_region(scratch, vec![0; 128]);
write_ppc_pstring(&mut loaded.memory, scratch, b"InterfaceLib");
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = PPC_CFM_LOAD_LIB;
loaded.cpu.gpr[6] = scratch + 32;
loaded.cpu.gpr[7] = scratch + 36;
loaded.cpu.gpr[8] = scratch + 40;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_FRAG_ARCH_ERR));
assert!(loaded.cfm.as_ref().unwrap().connections.is_empty());
}
#[test]
fn get_shared_library_find_only_does_not_prepare_seeded_fragment() {
let pef = synthetic_pef_with_import(b"GetSharedLibrary");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.seed_cfm_library_fragments(vec![PpcCfmLibraryFragment {
name: "SeededLibrary".to_string(),
bytes: synthetic_pef_with_exports(),
}]);
let scratch = PPC_HEAP_BASE;
loaded.memory.add_region(scratch, vec![0; 128]);
write_ppc_pstring(&mut loaded.memory, scratch, b"SeededLibrary");
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = PPC_CFM_POWERPC_ARCH;
loaded.cpu.gpr[5] = PPC_CFM_FIND_LIB;
loaded.cpu.gpr[6] = scratch + 32;
loaded.cpu.gpr[7] = scratch + 36;
loaded.cpu.gpr[8] = scratch + 40;
let heap_before = loaded.heap_cursor();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_FRAG_LIB_NOT_FOUND));
assert!(loaded.cfm.as_ref().unwrap().connections.is_empty());
assert_eq!(loaded.heap_cursor(), heap_before);
}
#[test]
fn close_connection_import_preserves_live_registry_on_protected_output_and_retries() {
for partial in [false, true] {
let mut loaded =
load_pef_application(&synthetic_pef_with_import(b"CloseConnection")).unwrap();
let pointer = PPC_HEAP_BASE + 0x1000;
loaded.memory.write_u32_be(pointer, 77).unwrap();
let connection = PpcCfmConnection {
id: 77,
library_name: "Library".to_string(),
main_addr: 0x1234,
init_addr: 0,
term_addr: 0,
exports: Vec::new(),
};
loaded.cfm.as_mut().unwrap().connections.push(connection);
loaded
.cfm
.as_mut()
.unwrap()
.connections
.push(PpcCfmConnection {
id: 78,
library_name: "Other".to_string(),
main_addr: 0x5678,
init_addr: 0,
term_addr: 0,
exports: Vec::new(),
});
if partial {
loaded.memory.add_readonly_region(pointer + 3, vec![77]);
} else {
loaded
.memory
.add_readonly_region(pointer, 77u32.to_be_bytes().to_vec());
}
let before = loaded.cfm.clone();
let entry = loaded.cpu.pc;
loaded.cpu.gpr[3] = pointer;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.cfm, before);
assert_eq!(loaded.memory.read_u32_be(pointer), Some(77));
loaded.memory.write_u32_be(pointer + 8, 77).unwrap();
loaded.cpu.pc = entry;
loaded.cpu.gpr[3] = pointer + 8;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(pointer + 8), Some(0));
let mut expected = before.unwrap();
expected.connections.remove(0);
assert_eq!(loaded.cfm.as_ref(), Some(&expected));
}
}
#[test]
fn find_symbol_returns_real_export_class_before_hle_fallback() {
let pef = synthetic_pef_with_import(b"FindSymbol");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_HEAP_BASE;
loaded.memory.add_region(scratch, vec![0; 128]);
let symbol_ptr = scratch;
let address_ptr = scratch + 32;
let class_ptr = scratch + 36;
write_ppc_pstring(&mut loaded.memory, symbol_ptr, b"RealExport");
loaded
.cfm
.as_mut()
.unwrap()
.connections
.push(PpcCfmConnection {
id: 77,
library_name: "RealLibrary".to_string(),
main_addr: 0,
init_addr: 0,
term_addr: 0,
exports: vec![PpcCfmExport {
name: "RealExport".to_string(),
class: 1,
address: 0x0312_3456,
}],
});
loaded.cpu.gpr[3] = 77;
loaded.cpu.gpr[4] = symbol_ptr;
loaded.cpu.gpr[5] = address_ptr;
loaded.cpu.gpr[6] = class_ptr;
let import_len_before = loaded.imports.len();
let mut import_run_state = PpcImportRunState::from_parts(
std::mem::take(&mut loaded.imports),
loaded.import_count,
ppc_import_layout(),
);
let action = ppc_find_symbol(
&loaded.cpu,
&mut loaded.memory,
&loaded.cfm.as_ref().unwrap().connections,
&mut import_run_state,
);
(loaded.imports, loaded.import_count) = import_run_state.into_parts();
assert_eq!(action, PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR)));
assert_eq!(loaded.memory.read_u32_be(address_ptr), Some(0x0312_3456));
assert_eq!(loaded.memory.read_u8(class_ptr), Some(1));
assert_eq!(loaded.imports.len(), import_len_before);
}
#[test]
fn find_symbol_import_refuses_partial_outputs_retries_and_reuses_callable_bindings() {
const OUTPUT: u32 = PPC_HEAP_BASE + 0x100;
for dynamic in [false, true] {
let mut loaded =
load_pef_application(&synthetic_pef_with_import(b"FindSymbol")).unwrap();
loaded.memory.add_region(OUTPUT, vec![0xa5; 128]);
loaded.memory.add_readonly_region(OUTPUT + 8, vec![0xa5]);
let symbol = if dynamic {
b"TickCount".as_slice()
} else {
b"RealExport".as_slice()
};
write_ppc_pstring(&mut loaded.memory, OUTPUT + 32, symbol);
loaded
.cfm
.as_mut()
.unwrap()
.connections
.push(PpcCfmConnection {
id: 7,
library_name: if dynamic {
"InterfaceLib"
} else {
"RealLibrary"
}
.into(),
main_addr: 0,
init_addr: 0,
term_addr: 0,
exports: if dynamic {
vec![]
} else {
vec![PpcCfmExport {
name: "RealExport".into(),
class: 1,
address: 0x1234_5678,
}]
},
});
if dynamic {
loaded
.cfm
.as_mut()
.unwrap()
.connections
.push(PpcCfmConnection {
id: 8,
library_name: "StdCLib".into(),
main_addr: 0,
init_addr: 0,
term_addr: 0,
exports: vec![],
});
}
let original_count = loaded.import_count;
let original_len = loaded.imports.len();
let mut returned = None;
for attempt in 0..3 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 7;
loaded.cpu.gpr[4] = OUTPUT + 32;
loaded.cpu.gpr[5] = OUTPUT;
loaded.cpu.gpr[6] = OUTPUT + if attempt == 0 { 8 } else { 9 };
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
if attempt == 0 {
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.memory.read_u32_be(OUTPUT), Some(0xa5a5_a5a5));
assert_eq!(loaded.import_count, original_count);
assert_eq!(loaded.imports.len(), original_len);
if dynamic {
write_ppc_pstring(&mut loaded.memory, OUTPUT + 32, b"errno");
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 8;
loaded.cpu.gpr[4] = OUTPUT + 32;
loaded.cpu.gpr[5] = OUTPUT + 16;
loaded.cpu.gpr[6] = OUTPUT + 24;
let unrelated = loaded.run_with_hle_imports(128);
assert_eq!(unrelated.handled_import_count, 1);
assert_eq!(unrelated.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(OUTPUT + 16),
Some(PPC_IMPORT_STD_ERRNO)
);
assert_eq!(loaded.import_count, original_count);
assert_eq!(loaded.imports.len(), original_len);
write_ppc_pstring(&mut loaded.memory, OUTPUT + 32, b"TickCount");
}
} else {
assert_eq!(loaded.cpu.gpr[3], 0);
let address = loaded.memory.read_u32_be(OUTPUT).unwrap();
if let Some(previous) = returned {
assert_eq!(address, previous);
}
returned = Some(address);
assert_eq!(loaded.import_count, original_count + u32::from(dynamic));
assert_eq!(loaded.imports.len(), original_len + usize::from(dynamic));
}
}
if dynamic {
let vector = returned.unwrap();
loaded
.memory
.write_u32_be(crate::memory::globals::addr::TICKS, 0x1234)
.unwrap();
loaded.cpu.pc = loaded.memory.read_u32_be(vector).unwrap();
loaded.cpu.gpr[2] = loaded.memory.read_u32_be(vector + 4).unwrap();
loaded.cpu.lr = PPC_HALT_PC;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 0x1234);
// An existing symbol remains available when the gateway pool is full.
loaded.import_count = PPC_IMPORT_CAPACITY;
let mut bindings = loaded.cfm_symbol_bindings();
assert_eq!(
crate::cfm::CfmSymbolBindings::prepare(
&mut bindings,
"InterfaceLib",
"TickCount"
),
Ok((vector, 2))
);
crate::cfm::CfmSymbolBindings::commit(&mut bindings);
drop(bindings);
assert_eq!(loaded.import_count, PPC_IMPORT_CAPACITY);
assert_eq!(loaded.imports.len(), original_len + 1);
}
}
}
#[test]
fn find_symbol_returns_the_static_stdclib_data_identity() {
let pef = synthetic_pef_with_import(b"FindSymbol");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_HEAP_BASE;
loaded.memory.add_region(scratch, vec![0; 128]);
let symbol_ptr = scratch;
let address_ptr = scratch + 32;
let class_ptr = scratch + 36;
loaded
.cfm
.as_mut()
.unwrap()
.connections
.push(PpcCfmConnection {
id: 78,
library_name: "StdCLib".to_string(),
main_addr: 0,
init_addr: 0,
term_addr: 0,
exports: Vec::new(),
});
loaded.cpu.gpr[3] = 78;
loaded.cpu.gpr[4] = symbol_ptr;
loaded.cpu.gpr[5] = address_ptr;
loaded.cpu.gpr[6] = class_ptr;
let import_len_before = loaded.imports.len();
let import_count_before = loaded.import_count;
for (symbol, expected_address) in [
(b"errno".as_slice(), PPC_IMPORT_STD_ERRNO),
(b"MacOSErr".as_slice(), PPC_IMPORT_STD_MAC_OS_ERR),
] {
write_ppc_pstring(&mut loaded.memory, symbol_ptr, symbol);
let mut import_run_state = PpcImportRunState::from_parts(
std::mem::take(&mut loaded.imports),
loaded.import_count,
ppc_import_layout(),
);
let action = ppc_find_symbol(
&loaded.cpu,
&mut loaded.memory,
&loaded.cfm.as_ref().unwrap().connections,
&mut import_run_state,
);
(loaded.imports, loaded.import_count) = import_run_state.into_parts();
assert_eq!(action, PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR)));
assert_eq!(
loaded.memory.read_u32_be(address_ptr),
Some(expected_address)
);
assert_eq!(loaded.memory.read_u8(class_ptr), Some(1));
assert_eq!(loaded.imports.len(), import_len_before);
assert_eq!(loaded.import_count, import_count_before);
}
}
#[test]
fn memory_fragment_preparation_rejects_without_publication_and_retries() {
use crate::memory::{MacMemoryBus, MemoryBus};
use crate::process_context::{ProcessNativeHeapState, ProcessNativeMemoryManager};
const HEAP: u32 = 0x0300_0000;
const LIMIT: u32 = HEAP + 0x1000;
let loader = synthetic_loader_with_chunks(
b"InterfaceLib",
b"TickCount",
&[run_reloc(0x23, 1), run_reloc(0x25, 1)],
);
let fragment = synthetic_pef_with_loader_and_data(loader, &[0; 12]);
let heap_state = |cursor, limit| ProcessNativeHeapState {
heap_base: HEAP,
heap_cursor: cursor,
heap_limit: limit,
last_mem_error: 0,
heap_maximized: false,
master_pointer_blocks_requested: 0,
};
for refusal in 0..5 {
let mut memory = PpcSectionMem::new();
let mapped = if refusal == 0 {
synthetic_code().len()
} else {
0x1000
};
memory.add_region(HEAP, vec![0xa5; mapped]);
let mut classic = MacMemoryBus::new(0x10000);
classic.set_addressing_32_bit(true);
classic.attach_guest_address_space(memory.shared_view());
let mut manager = ProcessNativeMemoryManager::default();
if refusal != 1 {
let state = match refusal {
2 => heap_state(HEAP + 0x800, LIMIT),
3 => heap_state(HEAP, HEAP + 0x20),
// The planned end is ahead of the canonical cursor, but
// the first section would overwrite an existing allocation.
4 => heap_state(HEAP + 0x10, LIMIT),
_ => heap_state(HEAP, LIMIT),
};
manager.publish_native_allocator(state, &[], &[], &[]);
}
let before_allocator = manager.native_allocator_snapshot();
let before_update = manager.native_allocator_update();
let mut cursor = HEAP;
let mut import_run_state =
PpcImportRunState::from_parts(Vec::new(), 0, ppc_import_layout());
assert_eq!(
ppc_prepare_mem_fragment(
&fragment,
&mut manager,
&mut memory,
&mut cursor,
LIMIT,
&mut import_run_state
),
Err(PPC_FRAG_NO_ADDR_SPACE),
"refusal {refusal}"
);
let mut bytes = vec![0; mapped];
memory.read_bytes_into(HEAP, &mut bytes).unwrap();
assert_eq!(
bytes,
vec![0xa5; mapped],
"refusal {refusal} changed section bytes"
);
assert_eq!(classic.read_long(HEAP), 0xa5a5_a5a5);
assert_eq!(manager.native_allocator_snapshot(), before_allocator);
assert_eq!(manager.native_allocator_update(), before_update);
assert_eq!(cursor, HEAP);
assert!(import_run_state.bindings().is_empty());
assert_eq!(import_run_state.total_count(), 0);
assert_eq!(import_run_state.binding_cloned(0), None);
memory.add_region(HEAP, vec![0xa5; 0x1000]);
manager.publish_native_allocator(heap_state(HEAP, LIMIT), &[], &[], &[]);
let prepared = ppc_prepare_mem_fragment(
&fragment,
&mut manager,
&mut memory,
&mut cursor,
LIMIT,
&mut import_run_state,
)
.unwrap();
assert_eq!(manager.native_heap_state().unwrap().heap_cursor, cursor);
assert!(cursor > HEAP);
assert_eq!(import_run_state.total_count(), 1);
assert_eq!(import_run_state.bindings().len(), 1);
assert_eq!(
import_run_state.binding_cloned(0).unwrap().symbol_name,
"TickCount"
);
assert_eq!(memory.read_u32_be(prepared.main_addr), Some(HEAP));
assert_eq!(classic.read_long(prepared.main_addr), HEAP);
assert_eq!(
memory.read_u32_be(prepared.main_addr + 8),
Some(PPC_IMPORT_TVECTOR_BASE)
);
}
}
#[test]
fn hle_import_runner_loads_and_runs_a_memory_fragment_with_dynamic_imports() {
let pef = synthetic_pef_with_import(b"GetMemFragment");
let mut loaded = load_pef_application(&pef).unwrap();
let chunks = [run_reloc(0x23, 1), run_reloc(0x25, 1)];
let loader = synthetic_loader_with_chunks(b"InterfaceLib", b"TickCount", &chunks);
let mut fragment = synthetic_pef_with_loader_and_data(loader, &[0; 12]);
let code_offset = parse_pef_sections(&fragment).unwrap()[0].container_offset as usize;
let dynamic_trap = PPC_IMPORT_TRAP_BASE + 4;
write_u32(
&mut fragment,
code_offset,
d_form_u(15, 12, 0, (dynamic_trap >> 16) as u16),
);
write_u32(
&mut fragment,
code_offset + 4,
d_form_u(24, 12, 12, dynamic_trap as u16),
);
let fragment_addr = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
fragment.len() as u32,
false,
);
assert_ne!(fragment_addr, 0);
loaded.memory.write_bytes(fragment_addr, &fragment).unwrap();
let scratch = ppc_heap_alloc(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
128,
true,
);
assert_ne!(scratch, 0);
write_ppc_pstring(&mut loaded.memory, scratch, b"dynamic test fragment");
let conn_id_ptr = scratch + 64;
let main_addr_ptr = scratch + 68;
let err_name_ptr = scratch + 72;
loaded.cpu.gpr[3] = fragment_addr;
loaded.cpu.gpr[4] = fragment.len() as u32;
loaded.cpu.gpr[5] = scratch;
loaded.cpu.gpr[6] = PPC_CFM_LOAD_NEW_COPY;
loaded.cpu.gpr[7] = conn_id_ptr;
loaded.cpu.gpr[8] = main_addr_ptr;
loaded.cpu.gpr[9] = err_name_ptr;
let load_probe = loaded.run_with_hle_imports(128);
assert_eq!(load_probe.handled_import_count, 1);
assert_eq!(load_probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(conn_id_ptr),
Some(PPC_FIRST_CFM_CONNECTION_ID)
);
let main_addr = loaded.memory.read_u32_be(main_addr_ptr).unwrap();
assert_ne!(main_addr, 0);
assert_ne!(main_addr, PPC_CFM_MAIN_STUB_BASE);
assert_eq!(loaded.memory.read_u8(err_name_ptr), Some(0));
assert_eq!(loaded.import_count, 2);
assert_eq!(loaded.heap_cursor() & (PPC_HEAP_ALIGNMENT - 1), 0);
let dynamic_import = loaded.import_binding(1).unwrap();
assert_eq!(dynamic_import.symbol_name, "TickCount");
assert_eq!(dynamic_import.address, PPC_IMPORT_TVECTOR_BASE + 8);
assert_eq!(dynamic_import.trap_pc, dynamic_trap);
assert_eq!(
loaded.memory.read_u32_be(main_addr + 8),
Some(PPC_IMPORT_TVECTOR_BASE + 8)
);
loaded.cpu.pc = loaded.memory.read_u32_be(main_addr).unwrap();
loaded.cpu.gpr[2] = loaded.memory.read_u32_be(main_addr + 4).unwrap();
loaded.cpu.lr = PPC_HALT_PC;
loaded.set_tick_count(77);
loaded.set_clock_cycle_timing(1_000, 0);
let run_probe = loaded.run_with_hle_imports(128);
assert_eq!(run_probe.handled_import_count, 1);
assert_eq!(run_probe.last_import_index, Some(1));
assert_eq!(run_probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 77);
assert!(matches!(
run_probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
let committed_imports = loaded.imports.clone();
let committed_count = loaded.import_count;
let assert_registry = |loaded: &PpcLoadedApp| {
assert_eq!(loaded.imports, committed_imports);
assert_eq!(loaded.import_count, committed_count);
assert_eq!(loaded.import_binding(1).unwrap().symbol_name, "TickCount");
};
assert_registry(&loaded);
loaded.cpu.pc = PPC_IMPORT_TRAP_BASE + committed_count * 4;
let unsupported = loaded.run_with_hle_imports(1);
assert_eq!(unsupported.unsupported_import_index, Some(committed_count));
assert_registry(&loaded);
native_exceptions::install_test_unmapped_load(&mut loaded);
let fault = loaded.run_with_hle_imports(64);
assert!(matches!(fault.result, PpcRunResult::MemoryFault { .. }));
assert_registry(&loaded);
loaded.cpu.pc = loaded.entry_pc;
let cycle_limit = loaded.run_with_hle_imports(0);
assert_eq!(cycle_limit.result, PpcRunResult::CycleLimit { cycles: 0 });
assert_registry(&loaded);
}
#[test]
fn hle_import_runner_handles_quickdraw_3d_initialize_success() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Initialize");
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(loaded.q3_lifecycle, PpcQ3LifecycleState::default());
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_lifecycle.initialize_count, 1);
assert_eq!(loaded.q3_lifecycle.exit_count, 0);
assert_eq!(loaded.q3_lifecycle.initialized_depth, 1);
assert!(loaded.q3_lifecycle.initialized());
}
#[test]
fn hle_import_runner_handles_quickdraw_3d_exit_success() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Exit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.q3_lifecycle.initialized_depth = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_lifecycle.initialize_count, 0);
assert_eq!(loaded.q3_lifecycle.exit_count, 1);
assert_eq!(loaded.q3_lifecycle.initialized_depth, 0);
assert!(!loaded.q3_lifecycle.initialized());
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_lifecycle.exit_count, 2);
assert_eq!(loaded.q3_lifecycle.initialized_depth, 0);
}
#[test]
fn hle_import_runner_handles_q3_memory_storage_new() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MemoryStorage_New");
let mut loaded = load_pef_application(&pef).unwrap();
let source_ptr = PPC_DATA_BASE + 0x1000;
let output_ptr = PPC_DATA_BASE + 0x1100;
let size_read_ptr = PPC_DATA_BASE + 0x1200;
loaded.memory.add_region(source_ptr, vec![1, 2, 3, 4]);
loaded.memory.add_region(output_ptr, vec![0; 8]);
loaded.memory.add_region(size_read_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = source_ptr;
loaded.cpu.gpr[4] = 4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let storage = loaded.cpu.gpr[3];
assert_eq!(storage, PPC_Q3_OBJECT_BASE);
assert_eq!(
loaded.next_q3_object,
PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE
);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].object, storage);
assert_eq!(loaded.q3_objects[0].kind, PpcQ3ObjectKind::MemoryStorage);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_STORAGE_TYPE_MEMORY);
assert_eq!(loaded.q3_objects[0].data_ptr, PPC_HEAP_BASE);
assert_eq!(loaded.q3_objects[0].data_size, 4);
assert_eq!(
loaded.q3_memory_storages,
vec![PpcQ3MemoryStorageRecord {
storage,
buffer_ptr: PPC_HEAP_BASE,
valid_size: 4,
buffer_size: 4,
owns_buffer: true,
}]
);
loaded.memory.write_u8(source_ptr, 9).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StorageGetData;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 4;
loaded.cpu.gpr[6] = output_ptr;
loaded.cpu.gpr[7] = size_read_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(size_read_ptr), Some(4));
assert_eq!(loaded.memory.read_u8(output_ptr), Some(1));
assert_eq!(loaded.memory.read_u8(output_ptr + 1), Some(2));
assert_eq!(loaded.memory.read_u8(output_ptr + 2), Some(3));
assert_eq!(loaded.memory.read_u8(output_ptr + 3), Some(4));
}
#[test]
fn hle_import_runner_handles_q3_memory_storage_buffer_state() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MemoryStorage_NewBuffer");
let mut loaded = load_pef_application(&pef).unwrap();
let buffer_ptr = PPC_DATA_BASE + 0x1000;
let output_ptr = PPC_DATA_BASE + 0x1080;
let buffer_out_ptr = PPC_DATA_BASE + 0x10c0;
let valid_size_out_ptr = PPC_DATA_BASE + 0x10c4;
let buffer_size_out_ptr = PPC_DATA_BASE + 0x10c8;
let source_ptr = PPC_DATA_BASE + 0x1100;
loaded
.memory
.add_region(buffer_ptr, vec![10, 11, 12, 13, 14, 15, 0, 0]);
loaded.memory.add_region(output_ptr, vec![0; 16]);
loaded.memory.add_region(buffer_out_ptr, vec![0; 12]);
loaded
.memory
.add_region(source_ptr, vec![21, 22, 23, 24, 25, 26]);
loaded.cpu.gpr[3] = buffer_ptr;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = 8;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let storage = loaded.cpu.gpr[3];
assert_eq!(storage, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects[0].data_ptr, buffer_ptr);
assert_eq!(loaded.q3_objects[0].data_size, 6);
assert_eq!(
loaded.q3_memory_storages[0],
PpcQ3MemoryStorageRecord {
storage,
buffer_ptr,
valid_size: 6,
buffer_size: 8,
owns_buffer: false,
}
);
loaded.memory.write_u8(buffer_ptr, 99).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StorageGetData;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 2;
loaded.cpu.gpr[6] = output_ptr;
loaded.cpu.gpr[7] = valid_size_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(valid_size_out_ptr), Some(2));
assert_eq!(loaded.memory.read_u8(output_ptr), Some(99));
assert_eq!(loaded.memory.read_u8(output_ptr + 1), Some(11));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MemoryStorageGetBuffer;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = buffer_out_ptr;
loaded.cpu.gpr[5] = valid_size_out_ptr;
loaded.cpu.gpr[6] = buffer_size_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(buffer_out_ptr), Some(buffer_ptr));
assert_eq!(loaded.memory.read_u32_be(valid_size_out_ptr), Some(6));
assert_eq!(loaded.memory.read_u32_be(buffer_size_out_ptr), Some(8));
let invalid_buffer_out_ptr = PPC_DATA_BASE + 0x1120;
let invalid_valid_size_out_ptr = PPC_DATA_BASE + 0x1130;
let invalid_buffer_size_out_ptr = PPC_DATA_BASE + 0x1140;
loaded
.memory
.add_region(invalid_buffer_out_ptr, vec![0xaa; 4]);
loaded
.memory
.add_region(invalid_valid_size_out_ptr, vec![0xbb; 2]);
loaded
.memory
.add_region(invalid_buffer_size_out_ptr, vec![0xcc; 4]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MemoryStorageGetBuffer;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = invalid_buffer_out_ptr;
loaded.cpu.gpr[5] = invalid_valid_size_out_ptr;
loaded.cpu.gpr[6] = invalid_buffer_size_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(invalid_buffer_out_ptr),
Some(0xaaaa_aaaa)
);
assert_eq!(
loaded.memory.read_u8(invalid_valid_size_out_ptr),
Some(0xbb)
);
assert_eq!(
loaded.memory.read_u8(invalid_valid_size_out_ptr + 1),
Some(0xbb)
);
assert_eq!(
loaded.memory.read_u32_be(invalid_buffer_size_out_ptr),
Some(0xcccc_cccc)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StorageGetType;
loaded.cpu.gpr[3] = storage;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_STORAGE_TYPE_MEMORY);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MemoryStorageGetType;
loaded.cpu.gpr[3] = storage;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_MEMORY_STORAGE_TYPE_HANDLE);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StorageSetData;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = 6;
loaded.cpu.gpr[6] = source_ptr;
loaded.cpu.gpr[7] = valid_size_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(valid_size_out_ptr), Some(6));
assert_eq!(loaded.q3_memory_storages[0].valid_size, 12);
assert!(loaded.q3_memory_storages[0].buffer_size >= 12);
assert!(loaded.q3_memory_storages[0].owns_buffer);
assert_ne!(loaded.q3_memory_storages[0].buffer_ptr, buffer_ptr);
assert_eq!(
loaded.q3_objects[0].data_ptr,
loaded.q3_memory_storages[0].buffer_ptr
);
assert_eq!(loaded.q3_objects[0].data_size, 12);
let wrong_class = storage + PPC_Q3_OBJECT_STRIDE;
let wrong_record = PpcQ3MemoryStorageRecord {
storage: wrong_class,
buffer_ptr: source_ptr,
valid_size: 3,
buffer_size: 6,
owns_buffer: false,
};
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: wrong_class,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: source_ptr,
data_size: 3,
});
loaded.q3_memory_storages.push(wrong_record);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StorageGetType;
loaded.cpu.gpr[3] = wrong_class;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_NONE);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MemoryStorageGetType;
loaded.cpu.gpr[3] = wrong_class;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_NONE);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded
.memory
.write_u32_be(buffer_out_ptr, 0xaaaa_aaaa)
.unwrap();
loaded
.memory
.write_u32_be(valid_size_out_ptr, 0xbbbb_bbbb)
.unwrap();
loaded
.memory
.write_u32_be(buffer_size_out_ptr, 0xcccc_cccc)
.unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MemoryStorageGetBuffer;
loaded.cpu.gpr[3] = wrong_class;
loaded.cpu.gpr[4] = buffer_out_ptr;
loaded.cpu.gpr[5] = valid_size_out_ptr;
loaded.cpu.gpr[6] = buffer_size_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(buffer_out_ptr), Some(0xaaaa_aaaa));
assert_eq!(
loaded.memory.read_u32_be(valid_size_out_ptr),
Some(0xbbbb_bbbb)
);
assert_eq!(
loaded.memory.read_u32_be(buffer_size_out_ptr),
Some(0xcccc_cccc)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MemoryStorageSetBuffer;
loaded.cpu.gpr[3] = wrong_class;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded
.q3_memory_storages
.iter()
.find(|record| record.storage == wrong_class)
.copied(),
Some(wrong_record)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_fsspec_storage_from_vfs_data_fork() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3FSSpecStorage_New");
let mut loaded = load_pef_application(&pef).unwrap();
let spec_ptr = PPC_DATA_BASE + 0x1000;
let size_out_ptr = spec_ptr + 0x80;
let object_type_out_ptr = spec_ptr + 0x84;
let file = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 10;
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
loaded.memory.add_region(spec_ptr, vec![0; 0x100]);
write_ppc_fsspec(
&mut loaded.memory,
spec_ptr,
PPC_BOOT_VOLUME_REF_NUM,
PPC_ROOT_DIR_ID,
b"model.3dmf",
);
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: "model.3dmf".to_string(),
data: (storage_bytes.clone()).into(),
creator: 0,
file_type: u32::from_be_bytes(*b"3DMF"),
finder_flags: 0,
dirty: false,
});
loaded.cpu.gpr[3] = spec_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let storage = loaded.cpu.gpr[3];
assert_eq!(storage, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].object, storage);
assert_eq!(loaded.q3_objects[0].kind, PpcQ3ObjectKind::Generic);
assert_eq!(
loaded.q3_objects[0].object_type,
PPC_Q3_STORAGE_TYPE_MACINTOSH
);
assert_eq!(loaded.q3_objects[0].data_ptr, PPC_HEAP_BASE);
assert_eq!(
loaded.q3_objects[0].data_size,
u32::try_from(storage_bytes.len()).unwrap()
);
assert!(loaded.q3_memory_storages.is_empty());
for (offset, byte) in storage_bytes.iter().copied().enumerate() {
assert_eq!(
loaded
.memory
.read_u8(PPC_HEAP_BASE + u32::try_from(offset).unwrap()),
Some(byte)
);
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StorageGetType;
loaded.cpu.gpr[3] = storage;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_STORAGE_TYPE_MACINTOSH);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StorageGetSize;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = size_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(size_out_ptr),
Some(u32::try_from(storage_bytes.len()).unwrap())
);
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileSetStorage;
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = storage;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileOpenRead;
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = object_type_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(object_type_out_ptr), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileReadObject;
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
let read_object = loaded.cpu.gpr[3];
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(read_object, PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE);
assert_eq!(loaded.q3_objects[2].object, read_object);
assert_eq!(loaded.q3_objects[2].object_type, PPC_Q3_TYPE_CONTAINER);
assert_eq!(loaded.q3_objects[2].data_ptr, PPC_HEAP_BASE + 8);
assert_eq!(loaded.q3_objects[2].data_size, 8);
assert_eq!(loaded.q3_objects[2].source.file, file);
assert_eq!(loaded.q3_objects[2].source.offset, 8);
}
#[test]
fn hle_import_runner_q3_fsspec_storage_resolves_stale_alias_dir_ids() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3FSSpecStorage_New");
let mut loaded = load_pef_application(&pef).unwrap();
let spec_ptr = PPC_DATA_BASE + 0x1000;
let storage_bytes = b"3DMFmodel".to_vec();
loaded.memory.add_region(spec_ptr, vec![0; 0x100]);
write_ppc_fsspec(
&mut loaded.memory,
spec_ptr,
PPC_BOOT_VOLUME_REF_NUM,
13720,
b"New T-REX_Finished.3df",
);
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: "Data/Skeletons/New T-REX_Finished.3df".to_string(),
data: (storage_bytes.clone()).into(),
creator: 0,
file_type: u32::from_be_bytes(*b"3DMF"),
finder_flags: 0,
dirty: false,
});
loaded.cpu.gpr[3] = spec_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let storage = loaded.cpu.gpr[3];
assert_eq!(storage, PPC_Q3_OBJECT_BASE);
assert_eq!(
loaded.q3_objects[0].data_size,
u32::try_from(storage_bytes.len()).unwrap()
);
for (offset, byte) in storage_bytes.iter().copied().enumerate() {
assert_eq!(
loaded
.memory
.read_u8(PPC_HEAP_BASE + u32::try_from(offset).unwrap()),
Some(byte)
);
}
}
#[test]
fn hle_import_runner_handles_q3_generic_new_object() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Unknown_New");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_DATA_BASE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].kind, PpcQ3ObjectKind::Generic);
assert_eq!(loaded.q3_objects[0].data_ptr, PPC_DATA_BASE);
}
#[test]
fn hle_import_runner_handles_q3_view_new_object_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_New");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
let view = loaded.cpu.gpr[3];
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(view, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].object, view);
assert_eq!(loaded.q3_objects[0].kind, PpcQ3ObjectKind::Generic);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_TYPE_VIEW);
assert_eq!(loaded.q3_objects[0].data_ptr, 0);
assert_eq!(loaded.q3_objects[0].data_size, 0);
assert_eq!(loaded.q3_views, vec![PpcQ3ViewStateRecord::new(view)]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectGetType;
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_VIEW);
let renderer = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: renderer,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_RENDERER_TYPE_GENERIC,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ViewSetRenderer;
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_views.len(), 1);
assert_eq!(loaded.q3_views[0].renderer, renderer);
let renderer_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(renderer_out_ptr, vec![0xaa; 4]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ViewGetRenderer;
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(renderer_out_ptr), Some(renderer));
}
#[test]
fn hle_import_runner_handles_q3_file_new_object_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_New");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
let file = loaded.cpu.gpr[3];
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(file, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].object, file);
assert_eq!(loaded.q3_objects[0].kind, PpcQ3ObjectKind::Generic);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_TYPE_FILE);
assert_eq!(loaded.q3_objects[0].data_ptr, 0);
assert_eq!(loaded.q3_objects[0].data_size, 0);
assert_eq!(
loaded.q3_files,
vec![PpcQ3FileRecord {
file,
storage: 0,
is_open: false,
object_type: 0,
read_offset: 0,
read_object: 0,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectGetType;
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_FILE);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MemoryStorageNewBuffer;
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], storage);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileSetStorage;
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = storage;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_files[0].storage, storage);
}
#[test]
fn hle_import_runner_retains_q3_file_storage_until_file_dispose() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_New");
let mut loaded = load_pef_application(&pef).unwrap();
let file = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileNew);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let storage_a = run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3MemoryStorageNewBuffer,
);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let storage_b = run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3MemoryStorageNewBuffer,
);
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = storage_a;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileSetStorage),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage_a),
Some(2)
);
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = file;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileSetStorage),
0
);
assert_eq!(loaded.q3_files[0].storage, storage_a);
loaded.cpu.gpr[3] = storage_a;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage_a),
Some(1)
);
assert!(ppc_q3_object_exists(&loaded.q3_objects, storage_a));
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = storage_b;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileSetStorage),
1
);
assert!(!ppc_q3_object_exists(&loaded.q3_objects, storage_a));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage_b),
Some(2)
);
assert_eq!(loaded.q3_files[0].storage, storage_b);
loaded.cpu.gpr[3] = storage_b;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage_b),
Some(1)
);
loaded.cpu.gpr[3] = file;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(!ppc_q3_object_exists(&loaded.q3_objects, file));
assert!(!ppc_q3_object_exists(&loaded.q3_objects, storage_b));
assert!(loaded.q3_files.is_empty());
assert!(loaded.q3_object_refs.is_empty());
}
#[test]
fn hle_import_runner_handles_q3_display_and_illumination_objects() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3DisplayGroup_New");
let mut loaded = load_pef_application(&pef).unwrap();
let calls = [
(
PpcImportDispatcherTarget::Q3DisplayGroupNew,
PPC_Q3_GROUP_TYPE_DISPLAY,
),
(
PpcImportDispatcherTarget::Q3LambertIlluminationNew,
PPC_Q3_ILLUMINATION_TYPE_LAMBERT,
),
(
PpcImportDispatcherTarget::Q3NullIlluminationNew,
PPC_Q3_ILLUMINATION_TYPE_NULL,
),
(
PpcImportDispatcherTarget::Q3PhongIlluminationNew,
PPC_Q3_ILLUMINATION_TYPE_PHONG,
),
];
for (index, (target, object_type)) in calls.into_iter().enumerate() {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
let object = PPC_Q3_OBJECT_BASE
+ PPC_Q3_OBJECT_STRIDE * u32::try_from(index).expect("small test object index");
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], object);
assert_eq!(loaded.q3_objects[index].object, object);
assert_eq!(loaded.q3_objects[index].kind, PpcQ3ObjectKind::Generic);
assert_eq!(loaded.q3_objects[index].object_type, object_type);
assert_eq!(loaded.q3_objects[index].data_ptr, 0);
assert_eq!(loaded.q3_objects[index].data_size, 0);
}
}
#[test]
fn hle_import_runner_handles_q3_renderer_type_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Renderer_NewFromType");
let mut loaded = load_pef_application(&pef).unwrap();
let renderer_type = u32::from_be_bytes(*b"irnd");
loaded.cpu.gpr[3] = renderer_type;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let renderer = loaded.cpu.gpr[3];
assert_eq!(renderer, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].kind, PpcQ3ObjectKind::Generic);
assert_eq!(loaded.q3_objects[0].object_type, renderer_type);
assert_eq!(loaded.q3_objects[0].data_ptr, 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3RendererGetType;
loaded.cpu.gpr[3] = renderer;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], renderer_type);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectGetType;
loaded.cpu.gpr[3] = renderer;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], renderer_type);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3RendererSync;
loaded.cpu.gpr[3] = renderer;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3RendererFlush;
loaded.cpu.gpr[3] = renderer;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = renderer + PPC_Q3_OBJECT_STRIDE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
let next_renderer = loaded.next_q3_object;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3RendererNewFromType;
loaded.cpu.gpr[3] = PPC_Q3_TYPE_NONE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.next_q3_object, next_renderer);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = PPC_Q3_TYPE_TRIMESH;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.next_q3_object, next_renderer);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_tracks_q3_interactive_renderer_preferences() {
let pef = synthetic_pef_with_library_import(
b"QuickDraw\xaa 3D",
b"Q3InteractiveRenderer_SetDoubleBufferBypass",
);
let mut loaded = load_pef_application(&pef).unwrap();
let renderer = PPC_Q3_OBJECT_BASE;
let renderer_type = u32::from_be_bytes(*b"irnd");
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: renderer,
kind: PpcQ3ObjectKind::Generic,
object_type: renderer_type,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = renderer;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_renderer_preferences,
vec![PpcQ3RendererPreferenceRecord {
renderer,
double_buffer_bypass: Some(1),
preference_vendor: None,
preference_engine: None,
rave_context_hints: None,
rave_texture_filter: None,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3InteractiveRendererSetPreferences;
loaded.cpu.gpr[3] = renderer;
loaded.cpu.gpr[4] = PPC_QA_VENDOR_APPLE;
loaded.cpu.gpr[5] = PPC_QA_ENGINE_APPLE_SW;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_renderer_preferences[0],
PpcQ3RendererPreferenceRecord {
renderer,
double_buffer_bypass: Some(1),
preference_vendor: Some(PPC_QA_VENDOR_APPLE),
preference_engine: Some(PPC_QA_ENGINE_APPLE_SW),
rave_context_hints: None,
rave_texture_filter: None,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3InteractiveRendererSetRaveTextureFilter;
loaded.cpu.gpr[3] = renderer;
loaded.cpu.gpr[4] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_renderer_preferences[0],
PpcQ3RendererPreferenceRecord {
renderer,
double_buffer_bypass: Some(1),
preference_vendor: Some(PPC_QA_VENDOR_APPLE),
preference_engine: Some(PPC_QA_ENGINE_APPLE_SW),
rave_context_hints: None,
rave_texture_filter: Some(2),
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3InteractiveRendererSetRaveContextHints;
loaded.cpu.gpr[3] = renderer;
loaded.cpu.gpr[4] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_renderer_preferences[0],
PpcQ3RendererPreferenceRecord {
renderer,
double_buffer_bypass: Some(1),
preference_vendor: Some(PPC_QA_VENDOR_APPLE),
preference_engine: Some(PPC_QA_ENGINE_APPLE_SW),
rave_context_hints: Some(0x1234_5678),
rave_texture_filter: Some(2),
}
);
let hints_out_ptr = PPC_DATA_BASE + 0x1000;
let draw_contexts_out_ptr = hints_out_ptr + 4;
let engines_out_ptr = hints_out_ptr + 8;
let count_out_ptr = hints_out_ptr + 12;
loaded.memory.add_region(hints_out_ptr, vec![0xff; 0x20]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3InteractiveRendererGetRaveContextHints;
loaded.cpu.gpr[3] = renderer;
loaded.cpu.gpr[4] = hints_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(hints_out_ptr), Some(0x1234_5678));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3InteractiveRendererGetRaveDrawContexts;
loaded.cpu.gpr[3] = renderer;
loaded.cpu.gpr[4] = draw_contexts_out_ptr;
loaded.cpu.gpr[5] = engines_out_ptr;
loaded.cpu.gpr[6] = count_out_ptr;
loaded.cpu.gpr[7] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(draw_contexts_out_ptr),
Some(PPC_QA_DRAW_CONTEXT)
);
assert_eq!(
loaded.memory.read_u32_be(engines_out_ptr),
Some(PPC_QA_ENGINE)
);
assert_eq!(loaded.memory.read_u32_be(count_out_ptr), Some(1));
assert_eq!(
loaded.memory.read_u32_be(PPC_QA_DRAW_CONTEXT),
Some(PPC_QA_DRAW_CONTEXT_PRIVATE)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_QA_DRAW_CONTEXT + 4),
Some(PPC_QA_METHOD_RETURN_ZERO_TVECTOR)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_QA_METHOD_RETURN_ZERO_TVECTOR),
Some(PPC_QA_METHOD_RETURN_ZERO_ENTRY)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_QA_METHOD_RETURN_ZERO_ENTRY),
Some(0x3860_0000)
);
assert_eq!(
loaded
.memory
.read_u32_be(PPC_QA_METHOD_RETURN_ZERO_ENTRY + 4),
Some(BLR)
);
let invalid_draw_contexts_out_ptr = PPC_DATA_BASE + 0x1100;
let invalid_engines_out_ptr = PPC_DATA_BASE + 0x1200;
let invalid_count_out_ptr = PPC_DATA_BASE + 0x1300;
loaded
.memory
.add_region(invalid_draw_contexts_out_ptr, vec![0xaa; 4]);
loaded
.memory
.add_region(invalid_engines_out_ptr, vec![0xbb; 2]);
loaded
.memory
.add_region(invalid_count_out_ptr, vec![0xcc; 4]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3InteractiveRendererGetRaveDrawContexts;
loaded.cpu.gpr[3] = renderer;
loaded.cpu.gpr[4] = invalid_draw_contexts_out_ptr;
loaded.cpu.gpr[5] = invalid_engines_out_ptr;
loaded.cpu.gpr[6] = invalid_count_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(invalid_draw_contexts_out_ptr),
Some(0xaaaa_aaaa)
);
assert_eq!(loaded.memory.read_u8(invalid_engines_out_ptr), Some(0xbb));
assert_eq!(
loaded.memory.read_u8(invalid_engines_out_ptr + 1),
Some(0xbb)
);
assert_eq!(
loaded.memory.read_u32_be(invalid_count_out_ptr),
Some(0xcccc_cccc)
);
assert_eq!(loaded.q3_error_state, PpcQ3ErrorState::default());
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3InteractiveRendererSetRaveTextureFilter;
loaded.cpu.gpr[3] = renderer + PPC_Q3_OBJECT_STRIDE;
loaded.cpu.gpr[4] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_renderer_preferences.len(), 1);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_pixmap_draw_context_state() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3PixmapDrawContext_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let data_ptr = scratch_ptr;
let pane_out_ptr = scratch_ptr + 0x100;
loaded.memory.add_region(scratch_ptr, vec![0; 0x200]);
ppc_write_q3_area(
&mut loaded.memory,
data_ptr + PPC_Q3_DRAW_CONTEXT_PANE_OFFSET,
9.0,
9.0,
9.0,
9.0,
)
.unwrap();
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_DRAW_CONTEXT_PANE_STATE_OFFSET, 0)
.unwrap();
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_DRAW_CONTEXT_DATA_SIZE, 0x1234_5678)
.unwrap();
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_PIXMAP_DRAW_CONTEXT_WIDTH_OFFSET, 320)
.unwrap();
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_PIXMAP_DRAW_CONTEXT_HEIGHT_OFFSET, 240)
.unwrap();
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 12, 1280)
.unwrap();
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 16, 32)
.unwrap();
loaded
.memory
.write_u32_be(
data_ptr + PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 20,
PPC_Q3_PIXEL_TYPE_RGB32,
)
.unwrap();
loaded
.memory
.write_u32_be(
data_ptr + PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 24,
PPC_Q3_ENDIAN_BIG,
)
.unwrap();
loaded
.memory
.write_u32_be(
data_ptr + PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 28,
PPC_Q3_ENDIAN_BIG,
)
.unwrap();
let copied_data = ppc_q3_read_bytes(
&mut loaded.memory,
data_ptr,
PPC_Q3_PIXMAP_DRAW_CONTEXT_DATA_SIZE,
)
.unwrap();
loaded.cpu.gpr[3] = data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let draw_context = loaded.cpu.gpr[3];
assert_eq!(draw_context, PPC_Q3_OBJECT_BASE);
assert_eq!(
loaded.q3_objects[0].object_type,
PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP
);
assert_eq!(
loaded.q3_objects[0].data_size,
PPC_Q3_PIXMAP_DRAW_CONTEXT_DATA_SIZE
);
assert_eq!(
loaded.q3_draw_contexts,
vec![PpcQ3DrawContextRecord {
draw_context,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP,
data: copied_data,
}]
);
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_PIXMAP_DRAW_CONTEXT_WIDTH_OFFSET, 640)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3DrawContextGetPane;
loaded.cpu.gpr[3] = draw_context;
loaded.cpu.gpr[4] = pane_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_vector2d(&mut loaded.memory, pane_out_ptr),
Some((0.0, 0.0))
);
assert_eq!(
ppc_read_q3_vector2d(&mut loaded.memory, pane_out_ptr + 8),
Some((320.0, 240.0))
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.q3_objects[0].object_type = PPC_Q3_TEXTURE_TYPE_MIPMAP;
for offset in 0..PPC_Q3_DRAW_CONTEXT_PANE_SIZE {
loaded.memory.write_u8(pane_out_ptr + offset, 0xdd).unwrap();
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = draw_context;
loaded.cpu.gpr[4] = pane_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..PPC_Q3_DRAW_CONTEXT_PANE_SIZE {
assert_eq!(loaded.memory.read_u8(pane_out_ptr + offset), Some(0xdd));
}
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_mac_draw_context_explicit_pane() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MacDrawContext_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let data_ptr = scratch_ptr;
let pane_out_ptr = scratch_ptr + 0x100;
loaded.memory.add_region(scratch_ptr, vec![0; 0x200]);
ppc_write_q3_area(
&mut loaded.memory,
data_ptr + PPC_Q3_DRAW_CONTEXT_PANE_OFFSET,
10.0,
20.0,
630.0,
460.0,
)
.unwrap();
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_DRAW_CONTEXT_PANE_STATE_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_DRAW_CONTEXT_DATA_SIZE, 0x0102_0304)
.unwrap();
let copied_data = ppc_q3_read_bytes(
&mut loaded.memory,
data_ptr,
PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE,
)
.unwrap();
loaded.cpu.gpr[3] = data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let draw_context = loaded.cpu.gpr[3];
assert_eq!(draw_context, PPC_Q3_OBJECT_BASE);
assert_eq!(
loaded.q3_objects[0].object_type,
PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH
);
assert_eq!(
loaded.q3_draw_contexts,
vec![PpcQ3DrawContextRecord {
draw_context,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
data: copied_data,
}]
);
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_DRAW_CONTEXT_PANE_STATE_OFFSET, 0)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3DrawContextGetPane;
loaded.cpu.gpr[3] = draw_context;
loaded.cpu.gpr[4] = pane_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_vector2d(&mut loaded.memory, pane_out_ptr),
Some((10.0, 20.0))
);
assert_eq!(
ppc_read_q3_vector2d(&mut loaded.memory, pane_out_ptr + 8),
Some((630.0, 460.0))
);
}
#[test]
fn q3_mac_draw_context_front_buffer_uses_registered_port() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MacDrawContext_New");
let mut loaded = load_pef_application(&pef).unwrap();
let draw_context = PPC_Q3_OBJECT_BASE;
let window_port = PPC_HEAP_BASE + 0x2000;
let window_base = PPC_HEAP_BASE + 0x4000;
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: window_port,
pixmap_handle: 0,
pixmap: 0,
base_addr: window_base,
gdevice: PPC_MAIN_GDEVICE,
width: 320,
height: 240,
depth: 16,
row_bytes: 640,
pixels_locked: false,
pixels_no_purge: false,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: draw_context,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE,
});
let mut data = vec![0; PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE as usize];
data[PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET as usize
..PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET as usize + 4]
.copy_from_slice(&window_port.to_be_bytes());
loaded.q3_draw_contexts.push(PpcQ3DrawContextRecord {
draw_context,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
data,
});
assert_eq!(
loaded.q3_draw_context_front_buffer(draw_context),
Some(PpcFrontBuffer {
base_addr: window_base,
row_bytes: 640,
width: 320,
height: 240,
depth: 16,
})
);
let pane_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(pane_out_ptr, vec![0xaa; 16]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3DrawContextGetPane;
loaded.cpu.gpr[3] = draw_context;
loaded.cpu.gpr[4] = pane_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_vector2d(&mut loaded.memory, pane_out_ptr),
Some((0.0, 0.0))
);
assert_eq!(
ppc_read_q3_vector2d(&mut loaded.memory, pane_out_ptr + 8),
Some((320.0, 240.0))
);
}
#[test]
fn hle_import_runner_handles_q3_mipmap_texture_new_with_copied_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MipmapTexture_New");
let mut loaded = load_pef_application(&pef).unwrap();
let mipmap_ptr = PPC_DATA_BASE + 0x1000;
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
for (index, byte) in mipmap.iter_mut().enumerate() {
*byte = (index.wrapping_mul(3) & 0xff) as u8;
}
loaded.memory.add_region(mipmap_ptr, mipmap.clone());
loaded.cpu.gpr[3] = mipmap_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].kind, PpcQ3ObjectKind::Generic);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_TEXTURE_TYPE_MIPMAP);
assert_eq!(loaded.q3_objects[0].data_ptr, 0);
assert_eq!(loaded.q3_objects[0].data_size, PPC_Q3_MIPMAP_COPY_SIZE);
assert_eq!(
loaded.q3_mipmap_textures,
vec![PpcQ3MipmapTextureRecord {
texture: PPC_Q3_OBJECT_BASE,
mipmap: mipmap.clone(),
}]
);
loaded.memory.write_u8(mipmap_ptr, 0xff).unwrap();
assert_eq!(loaded.q3_mipmap_textures[0].mipmap[0], mipmap[0]);
}
#[test]
fn hle_import_runner_retains_q3_mipmap_storage_until_texture_dispose() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MipmapTexture_New");
let mut loaded = load_pef_application(&pef).unwrap();
let storage = PPC_Q3_OBJECT_BASE;
let texture = storage + PPC_Q3_OBJECT_STRIDE;
let mipmap_ptr = PPC_DATA_BASE + 0x1000;
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4].copy_from_slice(&storage.to_be_bytes());
loaded.memory.add_region(mipmap_ptr, mipmap);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.next_q3_object = texture;
loaded.cpu.gpr[3] = mipmap_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], texture);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage),
Some(2)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectDispose;
loaded.cpu.gpr[3] = storage;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(ppc_q3_object_exists(&loaded.q3_objects, storage));
assert!(ppc_q3_object_exists(&loaded.q3_objects, texture));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage),
Some(1)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = texture;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_objects.is_empty());
assert!(loaded.q3_object_refs.is_empty());
assert!(loaded.q3_mipmap_textures.is_empty());
}
#[test]
fn hle_import_runner_validates_q3_mipmap_texture_image_storage() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MipmapTexture_New");
let mut loaded = load_pef_application(&pef).unwrap();
let wrong_storage = PPC_Q3_OBJECT_BASE;
let texture = wrong_storage + PPC_Q3_OBJECT_STRIDE;
let mipmap_ptr = PPC_DATA_BASE + 0x1000;
let raw_image_storage = 0x0bad_cafe;
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4]
.copy_from_slice(&wrong_storage.to_be_bytes());
loaded.memory.add_region(mipmap_ptr, mipmap.clone());
loaded
.q3_objects
.push(test_q3_object(wrong_storage, PPC_Q3_TYPE_TRIMESH));
loaded.next_q3_object = texture;
loaded.cpu.gpr[3] = mipmap_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.next_q3_object, texture);
assert!(loaded.q3_mipmap_textures.is_empty());
assert!(loaded.q3_object_refs.is_empty());
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded
.memory
.write_u32_be(mipmap_ptr + PPC_Q3_MIPMAP_IMAGE_OFFSET, raw_image_storage)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = mipmap_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], texture);
assert_eq!(loaded.q3_objects.len(), 2);
assert_eq!(loaded.q3_objects[1].object_type, PPC_Q3_TEXTURE_TYPE_MIPMAP);
assert!(loaded.q3_object_refs.is_empty());
let stored_image_storage =
ppc_q3_mipmap_texture_image_storage(loaded.q3_mipmap_textures[0].mipmap.as_slice());
assert_eq!(stored_image_storage, raw_image_storage);
assert_eq!(loaded.q3_error_state, PpcQ3ErrorState::default());
loaded.q3_mipmap_textures[0].mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4]
.copy_from_slice(&wrong_storage.to_be_bytes());
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectDispose;
loaded.cpu.gpr[3] = texture;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(ppc_q3_object_exists(&loaded.q3_objects, wrong_storage));
assert!(!ppc_q3_object_exists(&loaded.q3_objects, texture));
assert!(loaded.q3_object_refs.is_empty());
assert!(loaded.q3_mipmap_textures.is_empty());
}
#[test]
fn hle_import_runner_handles_q3_texture_shader_new_links_texture() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TextureShader_New");
let mut loaded = load_pef_application(&pef).unwrap();
let texture = PPC_Q3_OBJECT_BASE;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: texture,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MIPMAP_COPY_SIZE,
});
loaded.next_q3_object = shader;
loaded.cpu.gpr[3] = texture;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], shader);
assert_eq!(loaded.q3_objects.len(), 2);
assert_eq!(
loaded.q3_objects[1].object_type,
PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE
);
assert_eq!(loaded.q3_objects[1].data_ptr, texture);
assert_eq!(
loaded.q3_texture_shaders,
vec![PpcQ3TextureShaderRecord { shader, texture }]
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, texture),
Some(2)
);
let wrong_class = shader + PPC_Q3_OBJECT_STRIDE * 8;
let next_after_shader = loaded.next_q3_object;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: wrong_class,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_STYLE_TYPE_FILL,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 4,
});
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = wrong_class;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_objects.len(), 3);
assert_eq!(loaded.next_q3_object, next_after_shader);
assert_eq!(
loaded.q3_texture_shaders,
vec![PpcQ3TextureShaderRecord { shader, texture }]
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, wrong_class),
Some(1)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_retains_q3_texture_until_texture_shader_dispose() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TextureShader_New");
let mut loaded = load_pef_application(&pef).unwrap();
let texture = PPC_Q3_OBJECT_BASE;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: texture,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MIPMAP_COPY_SIZE,
});
loaded.q3_mipmap_textures.push(PpcQ3MipmapTextureRecord {
texture,
mipmap: vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize],
});
loaded.next_q3_object = shader;
loaded.cpu.gpr[3] = texture;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], shader);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, texture),
Some(2)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectDispose;
loaded.cpu.gpr[3] = texture;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(ppc_q3_object_exists(&loaded.q3_objects, texture));
assert!(ppc_q3_object_exists(&loaded.q3_objects, shader));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, texture),
Some(1)
);
assert_eq!(
loaded.q3_texture_shaders,
vec![PpcQ3TextureShaderRecord { shader, texture }]
);
assert_eq!(loaded.q3_mipmap_textures.len(), 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = shader;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_objects.is_empty());
assert!(loaded.q3_object_refs.is_empty());
assert!(loaded.q3_texture_shaders.is_empty());
assert!(loaded.q3_mipmap_textures.is_empty());
}
#[test]
fn hle_import_runner_handles_q3_texture_shader_new_with_untracked_texture_pointer() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TextureShader_New");
let mut loaded = load_pef_application(&pef).unwrap();
let texture = PPC_DATA_BASE + 0x1000;
loaded.cpu.gpr[3] = texture;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(
loaded.q3_objects[0].object_type,
PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE
);
assert_eq!(loaded.q3_objects[0].data_ptr, texture);
assert_eq!(
loaded.q3_texture_shaders,
vec![PpcQ3TextureShaderRecord {
shader: PPC_Q3_OBJECT_BASE,
texture,
}]
);
}
#[test]
fn hle_import_runner_handles_q3_object_dispose() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Dispose");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: PPC_Q3_OBJECT_BASE,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_NONE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = PPC_Q3_OBJECT_BASE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_objects.is_empty());
}
#[test]
fn hle_import_runner_duplicates_q3_object_references() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Duplicate");
let mut loaded = load_pef_application(&pef).unwrap();
let object = PPC_Q3_OBJECT_BASE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDuplicate),
object
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, object),
Some(2)
);
loaded.cpu.gpr[3] = object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(ppc_q3_object_exists(&loaded.q3_objects, object));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, object),
Some(1)
);
loaded.cpu.gpr[3] = object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(!ppc_q3_object_exists(&loaded.q3_objects, object));
assert!(loaded.q3_object_refs.is_empty());
loaded.cpu.gpr[3] = object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDuplicate),
0
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_error_state.last_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_gets_q3_shared_object_references() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Shared_GetReference");
let mut loaded = load_pef_application(&pef).unwrap();
let shared_object = PPC_Q3_OBJECT_BASE;
let view_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: shared_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: view_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_VIEW,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = shared_object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3SharedGetReference),
shared_object
);
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
shared_object
),
Some(2)
);
loaded.cpu.gpr[3] = shared_object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3SharedIsReferenced),
1
);
loaded.cpu.gpr[3] = shared_object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3SharedGetType),
PPC_Q3_SHARED_TYPE_SHAPE
);
loaded.cpu.gpr[3] = shared_object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(ppc_q3_object_exists(&loaded.q3_objects, shared_object));
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
shared_object
),
Some(1)
);
loaded.cpu.gpr[3] = shared_object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3SharedIsReferenced),
0
);
loaded.cpu.gpr[3] = view_object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3SharedGetReference),
0
);
loaded.cpu.gpr[3] = view_object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3SharedGetType),
PPC_Q3_TYPE_NONE
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, view_object),
Some(1)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_error_state.last_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_shape_type_queries() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Shape_GetType");
let mut loaded = load_pef_application(&pef).unwrap();
let geometry = PPC_Q3_OBJECT_BASE;
let group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let camera = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let view = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: geometry,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: camera,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: view,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_VIEW,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = geometry;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ShapeGetType),
PPC_Q3_SHAPE_TYPE_GEOMETRY
);
loaded.cpu.gpr[3] = group;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ShapeGetType),
PPC_Q3_SHAPE_TYPE_GROUP
);
loaded.cpu.gpr[3] = camera;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ShapeGetType),
PPC_Q3_SHAPE_TYPE_CAMERA
);
loaded.cpu.gpr[3] = geometry;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ShapeGetLeafType),
PPC_Q3_TYPE_TRIMESH
);
loaded.cpu.gpr[3] = view;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ShapeGetType),
PPC_Q3_TYPE_NONE
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_error_state.last_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_reports_q3_error_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Dispose");
let mut loaded = load_pef_application(&pef).unwrap();
let first_error_out_ptr = PPC_DATA_BASE + 0x1000;
let short_first_error_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(first_error_out_ptr, vec![0xaa; 4]);
loaded
.memory
.add_region(short_first_error_out_ptr, vec![0xee; 2]);
loaded.cpu.gpr[3] = PPC_Q3_OBJECT_BASE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_error_state.last_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ErrorGet;
loaded.cpu.gpr[3] = short_first_error_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
assert_eq!(
loaded.memory.read_u16_be(short_first_error_out_ptr),
Some(0xeeee)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_error_state.last_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert!(!loaded.q3_error_state.clear_on_next_q3_call);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ErrorGet;
loaded.cpu.gpr[3] = first_error_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
assert_eq!(
loaded.memory.read_u32_be(first_error_out_ptr),
Some(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER)
);
assert!(loaded.q3_error_state.clear_on_next_q3_call);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].symbol_name = "Q3Initialize".to_string();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Initialize;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_error_state, PpcQ3ErrorState::default());
assert_eq!(loaded.q3_lifecycle.initialize_count, 1);
assert_eq!(loaded.q3_lifecycle.initialized_depth, 1);
}
#[test]
fn hle_import_runner_keeps_q3_texture_shader_link_when_texture_disposed() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Dispose");
let mut loaded = load_pef_application(&pef).unwrap();
let texture = PPC_Q3_OBJECT_BASE;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: texture,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MIPMAP_COPY_SIZE,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
source: PpcQ3ObjectSource::default(),
data_ptr: texture,
data_size: 0,
});
loaded
.q3_texture_shaders
.push(PpcQ3TextureShaderRecord { shader, texture });
loaded.cpu.gpr[3] = texture;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].object, shader);
assert_eq!(
loaded.q3_texture_shaders,
vec![PpcQ3TextureShaderRecord { shader, texture }]
);
}
#[test]
fn q3_object_type_matching_handles_known_quickdraw_3d_hierarchy() {
assert!(ppc_q3_object_type_matches(
PPC_Q3_TYPE_TRIMESH,
PPC_Q3_TYPE_TRIMESH
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_TYPE_TRIMESH,
PPC_Q3_SHAPE_TYPE_GEOMETRY
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_TYPE_TRIMESH,
PPC_Q3_SHARED_TYPE_SHAPE
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
PPC_Q3_SHADER_TYPE_SURFACE
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
PPC_Q3_SHAPE_TYPE_SHADER
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_SHADER_TYPE_SURFACE,
PPC_Q3_SHAPE_TYPE_SHADER
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_ILLUMINATION_TYPE_PHONG,
PPC_Q3_SHADER_TYPE_ILLUMINATION
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_SHADER_TYPE_ILLUMINATION,
PPC_Q3_SHAPE_TYPE_SHADER
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_LIGHT_TYPE_SPOT,
PPC_Q3_SHAPE_TYPE_LIGHT
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC,
PPC_Q3_SHAPE_TYPE_CAMERA
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_CAMERA_TYPE_VIEW_PLANE,
PPC_Q3_SHARED_TYPE_SHAPE
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_GROUP_TYPE_LIGHT,
PPC_Q3_SHAPE_TYPE_GROUP
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_GROUP_TYPE_ORDERED_DISPLAY,
PPC_Q3_GROUP_TYPE_DISPLAY
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_GROUP_TYPE_IO_PROXY_DISPLAY,
PPC_Q3_SHAPE_TYPE_GROUP
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_TYPE_ATTRIBUTE_SET,
PPC_Q3_SHARED_TYPE_SET
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_TEXTURE_TYPE_MIPMAP,
PPC_Q3_OBJECT_TYPE_SHARED
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_RENDERER_TYPE_INTERACTIVE,
PPC_Q3_SHARED_TYPE_RENDERER
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_STORAGE_TYPE_MEMORY,
PPC_Q3_STORAGE_TYPE_MEMORY
));
assert!(ppc_q3_object_type_matches(
PPC_Q3_MEMORY_STORAGE_TYPE_HANDLE,
PPC_Q3_STORAGE_TYPE_MEMORY
));
assert!(!ppc_q3_object_type_matches(
PPC_Q3_TYPE_TRIMESH,
PPC_Q3_SHAPE_TYPE_LIGHT
));
assert!(!ppc_q3_object_type_matches(
PPC_Q3_TYPE_NONE,
PPC_Q3_OBJECT_TYPE_SHARED
));
assert!(!ppc_q3_object_type_matches(
PPC_Q3_TYPE_TRIMESH,
PPC_Q3_TYPE_NONE
));
}
#[test]
fn q3_object_drawable_matching_handles_known_quickdraw_3d_classes() {
assert!(ppc_q3_object_type_is_drawable(PPC_Q3_TYPE_CONTAINER));
assert!(ppc_q3_object_type_is_drawable(PPC_Q3_TYPE_TRIMESH));
assert!(ppc_q3_object_type_is_drawable(
PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE
));
assert!(ppc_q3_object_type_is_drawable(
PPC_Q3_ILLUMINATION_TYPE_LAMBERT
));
assert!(ppc_q3_object_type_is_drawable(PPC_Q3_STYLE_TYPE_BACKFACING));
assert!(ppc_q3_object_type_is_drawable(PPC_Q3_TRANSFORM_TYPE_MATRIX));
assert!(ppc_q3_object_type_is_drawable(PPC_Q3_GROUP_TYPE_DISPLAY));
assert!(ppc_q3_object_type_is_drawable(
PPC_Q3_GROUP_TYPE_ORDERED_DISPLAY
));
assert!(ppc_q3_object_type_is_drawable(
PPC_Q3_GROUP_TYPE_IO_PROXY_DISPLAY
));
assert!(ppc_q3_object_type_is_drawable(PPC_Q3_TYPE_ATTRIBUTE_SET));
assert!(!ppc_q3_object_type_is_drawable(PPC_Q3_GROUP_TYPE_LIGHT));
assert!(!ppc_q3_object_type_is_drawable(PPC_Q3_LIGHT_TYPE_AMBIENT));
assert!(!ppc_q3_object_type_is_drawable(
PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT
));
assert!(!ppc_q3_object_type_is_drawable(
PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC
));
assert!(!ppc_q3_object_type_is_drawable(
PPC_Q3_CAMERA_TYPE_VIEW_PLANE
));
assert!(!ppc_q3_object_type_is_drawable(PPC_Q3_TYPE_FILE));
assert!(!ppc_q3_object_type_is_drawable(PPC_Q3_TEXTURE_TYPE_MIPMAP));
assert!(!ppc_q3_object_type_is_drawable(
PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP
));
assert!(!ppc_q3_object_type_is_drawable(
PPC_Q3_RENDERER_TYPE_INTERACTIVE
));
}
#[test]
fn hle_import_runner_handles_q3_object_type_queries() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_GetType");
let mut loaded = load_pef_application(&pef).unwrap();
let object = PPC_Q3_OBJECT_BASE;
let display_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let memory_storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: display_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: memory_storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = object;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_TRIMESH);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectIsDrawable;
loaded.cpu.gpr[3] = object;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = display_group;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectIsType;
loaded.cpu.gpr[3] = object;
loaded.cpu.gpr[4] = PPC_Q3_TYPE_TRIMESH;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = object;
loaded.cpu.gpr[4] = PPC_Q3_SHAPE_TYPE_GEOMETRY;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = object;
loaded.cpu.gpr[4] = PPC_Q3_SHARED_TYPE_SHAPE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = memory_storage;
loaded.cpu.gpr[4] = PPC_Q3_STORAGE_TYPE_MEMORY;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = object;
loaded.cpu.gpr[4] = PPC_Q3_TYPE_CONTAINER;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectGetType;
loaded.cpu.gpr[3] = object;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_TRIMESH);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GeometryGetType;
loaded.cpu.gpr[3] = object;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_TRIMESH);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupGetType;
loaded.cpu.gpr[3] = display_group;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_GROUP_TYPE_DISPLAY);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderGetType;
loaded.cpu.gpr[3] = shader;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectGetLeafType;
loaded.cpu.gpr[3] = object;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_TRIMESH);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = object + PPC_Q3_OBJECT_STRIDE * 4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_NONE);
assert_eq!(loaded.q3_error_state.first_error, PPC_Q3_ERROR_NONE);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectIsDrawable;
loaded.cpu.gpr[3] = memory_storage;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_error_state.first_error, PPC_Q3_ERROR_NONE);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = object + PPC_Q3_OBJECT_STRIDE * 4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectIsType;
loaded.cpu.gpr[3] = object + PPC_Q3_OBJECT_STRIDE * 4;
loaded.cpu.gpr[4] = PPC_Q3_SHARED_TYPE_SHAPE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GeometryGetType;
loaded.cpu.gpr[3] = memory_storage;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_TYPE_NONE);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_error_state.last_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_texture_shader_get_texture() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TextureShader_GetTexture");
let mut loaded = load_pef_application(&pef).unwrap();
let texture = PPC_Q3_OBJECT_BASE;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let texture_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(texture_out_ptr, vec![0; 4]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: texture,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MIPMAP_COPY_SIZE,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded
.q3_texture_shaders
.push(PpcQ3TextureShaderRecord { shader, texture });
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = texture_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(texture_out_ptr), Some(texture));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, texture),
Some(2)
);
let wrong_class_texture = shader + PPC_Q3_OBJECT_STRIDE * 8;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: wrong_class_texture,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_STYLE_TYPE_FILL,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 4,
});
loaded.q3_texture_shaders[0].texture = wrong_class_texture;
loaded
.memory
.write_u32_be(texture_out_ptr, 0xcccc_cccc)
.unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = texture_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(texture_out_ptr),
Some(0xcccc_cccc)
);
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
wrong_class_texture,
),
Some(1)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_texture_shaders[0].texture = texture;
loaded.q3_error_state = PpcQ3ErrorState::default();
let wrong_class_shader = shader + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: wrong_class_shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: texture,
data_size: 0,
});
loaded
.memory
.write_u32_be(texture_out_ptr, 0xdddd_dddd)
.unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = wrong_class_shader;
loaded.cpu.gpr[4] = texture_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(texture_out_ptr),
Some(0xdddd_dddd)
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, texture),
Some(2)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_texture_shader_get_texture_from_object_payload() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TextureShader_GetTexture");
let mut loaded = load_pef_application(&pef).unwrap();
let shader = PPC_Q3_OBJECT_BASE;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let texture_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(texture_out_ptr, vec![0; 4]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
source: PpcQ3ObjectSource::default(),
data_ptr: texture,
data_size: 0,
});
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = texture_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(texture_out_ptr), Some(texture));
}
#[test]
fn hle_import_runner_prevalidates_q3_renderer_getter_outputs() {
fn q3_test_object(
object: u32,
object_type: u32,
data_ptr: u32,
data_size: u32,
) -> PpcQ3ObjectRecord {
PpcQ3ObjectRecord {
object,
kind: PpcQ3ObjectKind::Generic,
object_type,
source: PpcQ3ObjectSource::default(),
data_ptr,
data_size,
}
}
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MipmapTexture_GetMipmap");
let mut loaded = load_pef_application(&pef).unwrap();
let texture = PPC_Q3_OBJECT_BASE;
let draw_context = texture + PPC_Q3_OBJECT_STRIDE;
let trimesh = texture + PPC_Q3_OBJECT_STRIDE * 2;
let shader = texture + PPC_Q3_OBJECT_STRIDE * 3;
let attribute_set = texture + PPC_Q3_OBJECT_STRIDE * 4;
let transform = texture + PPC_Q3_OBJECT_STRIDE * 5;
let mipmap_storage = texture + PPC_Q3_OBJECT_STRIDE * 6;
let matrix_ptr = PPC_DATA_BASE + 0x2000;
let mut mipmap = vec![0x11; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4]
.copy_from_slice(&mipmap_storage.to_be_bytes());
loaded
.memory
.add_region(matrix_ptr, vec![0; PPC_Q3_MATRIX4X4_SIZE as usize]);
loaded.q3_objects.extend([
q3_test_object(
texture,
PPC_Q3_TEXTURE_TYPE_MIPMAP,
0,
PPC_Q3_MIPMAP_COPY_SIZE,
),
q3_test_object(
draw_context,
PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP,
0,
PPC_Q3_PIXMAP_DRAW_CONTEXT_DATA_SIZE,
),
q3_test_object(trimesh, PPC_Q3_TYPE_TRIMESH, 0, PPC_Q3_TRIMESH_DATA_SIZE),
q3_test_object(shader, PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE, 0, 0),
q3_test_object(attribute_set, PPC_Q3_TYPE_ATTRIBUTE_SET, 0, 0),
q3_test_object(
transform,
PPC_Q3_TRANSFORM_TYPE_MATRIX,
matrix_ptr,
PPC_Q3_MATRIX4X4_SIZE,
),
q3_test_object(mipmap_storage, PPC_Q3_STORAGE_TYPE_MEMORY, 0, 0),
]);
loaded
.q3_mipmap_textures
.push(PpcQ3MipmapTextureRecord { texture, mipmap });
loaded.q3_draw_contexts.push(PpcQ3DrawContextRecord {
draw_context,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP,
data: vec![0x22; PPC_Q3_PIXMAP_DRAW_CONTEXT_DATA_SIZE as usize],
});
loaded.q3_trimeshes.push(PpcQ3TriMeshRecord {
trimesh,
data: vec![0x33; PPC_Q3_TRIMESH_DATA_SIZE as usize],
triangle_attribute_sets: Vec::new(),
get_data_copies: Vec::new(),
});
loaded
.q3_shader_uv_transforms
.push(PpcQ3ShaderUvTransformRecord {
shader,
matrix: ppc_q3_matrix3x3_identity(),
});
loaded.q3_attributes.push(PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: vec![0x44; PPC_Q3_VECTOR3D_SIZE as usize],
});
let invalid_getters = [
(
PpcImportDispatcherTarget::Q3MipmapTextureGetMipmap,
texture,
0,
4,
PPC_Q3_MIPMAP_COPY_SIZE,
0xd1u8,
),
(
PpcImportDispatcherTarget::Q3DrawContextGetPane,
draw_context,
0,
4,
PPC_Q3_DRAW_CONTEXT_PANE_SIZE,
0xd2u8,
),
(
PpcImportDispatcherTarget::Q3TriMeshGetData,
trimesh,
0,
4,
PPC_Q3_TRIMESH_DATA_SIZE,
0xd3u8,
),
(
PpcImportDispatcherTarget::Q3ShaderGetUVTransform,
shader,
0,
4,
PPC_Q3_MATRIX3X3_SIZE,
0xd4u8,
),
(
PpcImportDispatcherTarget::Q3AttributeSetGet,
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
5,
PPC_Q3_VECTOR3D_SIZE,
0xd5u8,
),
(
PpcImportDispatcherTarget::Q3TransformGetMatrix,
transform,
0,
4,
PPC_Q3_MATRIX4X4_SIZE,
0xd6u8,
),
];
for (index, (target, object, arg4, output_gpr, size, sentinel)) in
invalid_getters.iter().enumerate()
{
let invalid_output_ptr = PPC_DATA_BASE + 0x5000 + (index as u32) * 0x400;
loaded
.memory
.add_region(invalid_output_ptr, vec![*sentinel; (*size - 1) as usize]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target.clone();
loaded.cpu.gpr[3] = *object;
loaded.cpu.gpr[4] = if *output_gpr == 4 {
invalid_output_ptr
} else {
*arg4
};
loaded.cpu.gpr[5] = if *output_gpr == 5 {
invalid_output_ptr
} else {
0
};
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..(*size - 1) {
assert_eq!(
loaded.memory.read_u8(invalid_output_ptr + offset),
Some(*sentinel)
);
}
}
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
mipmap_storage
),
Some(1)
);
}
#[test]
fn hle_import_runner_prevalidates_q3_scalar_getter_outputs() {
fn q3_test_object(
object: u32,
object_type: u32,
data_ptr: u32,
data_size: u32,
) -> PpcQ3ObjectRecord {
PpcQ3ObjectRecord {
object,
kind: PpcQ3ObjectKind::Generic,
object_type,
source: PpcQ3ObjectSource::default(),
data_ptr,
data_size,
}
}
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TextureShader_GetTexture");
let mut loaded = load_pef_application(&pef).unwrap();
let texture = PPC_Q3_OBJECT_BASE;
let shader = texture + PPC_Q3_OBJECT_STRIDE;
let fill_style = texture + PPC_Q3_OBJECT_STRIDE * 2;
let group = texture + PPC_Q3_OBJECT_STRIDE * 3;
let container = texture + PPC_Q3_OBJECT_STRIDE * 4;
let trimesh = texture + PPC_Q3_OBJECT_STRIDE * 5;
let view = texture + PPC_Q3_OBJECT_STRIDE * 6;
let renderer = texture + PPC_Q3_OBJECT_STRIDE * 7;
let draw_context = texture + PPC_Q3_OBJECT_STRIDE * 8;
let camera = texture + PPC_Q3_OBJECT_STRIDE * 9;
let light_group = texture + PPC_Q3_OBJECT_STRIDE * 10;
loaded.q3_objects.extend([
q3_test_object(texture, PPC_Q3_TEXTURE_TYPE_MIPMAP, 0, 0),
q3_test_object(shader, PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE, 0, 0),
q3_test_object(fill_style, PPC_Q3_STYLE_TYPE_FILL, 0, 0),
q3_test_object(group, PPC_Q3_GROUP_TYPE_DISPLAY, 0, 0),
q3_test_object(container, PPC_Q3_TYPE_CONTAINER, 0, 0),
q3_test_object(trimesh, PPC_Q3_TYPE_TRIMESH, 0, PPC_Q3_TRIMESH_DATA_SIZE),
q3_test_object(view, PPC_Q3_TYPE_VIEW, 0, 0),
q3_test_object(renderer, PPC_Q3_RENDERER_TYPE_GENERIC, 0, 0),
q3_test_object(draw_context, PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP, 0, 0),
q3_test_object(camera, PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT, 0, 0),
q3_test_object(light_group, PPC_Q3_GROUP_TYPE_LIGHT, 0, 0),
]);
loaded
.q3_texture_shaders
.push(PpcQ3TextureShaderRecord { shader, texture });
loaded.q3_shader_boundaries.push(PpcQ3ShaderBoundaryRecord {
shader,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
});
loaded.q3_styles.push(PpcQ3StyleRecord {
style: fill_style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_POINTS,
});
loaded.q3_group_memberships.extend([
PpcQ3GroupMembershipRecord {
group,
object: container,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: trimesh,
before: None,
},
]);
loaded.q3_views.push(PpcQ3ViewStateRecord {
view,
renderer,
light_group,
draw_context,
camera,
rendering_depth: 0,
bounding_box_depth: 0,
cancelled: false,
});
let invalid_getters = [
(
PpcImportDispatcherTarget::Q3TextureShaderGetTexture,
shader,
0,
4,
0xe1u8,
Some(texture),
),
(
PpcImportDispatcherTarget::Q3ShaderGetUBoundary,
shader,
0,
4,
0xe2u8,
None,
),
(
PpcImportDispatcherTarget::Q3FillStyleGet,
fill_style,
0,
4,
0xe3u8,
None,
),
(
PpcImportDispatcherTarget::Q3GroupCountObjects,
group,
0,
4,
0xe4u8,
None,
),
(
PpcImportDispatcherTarget::Q3GroupGetFirstPosition,
group,
0,
4,
0xe5u8,
None,
),
(
PpcImportDispatcherTarget::Q3GroupGetFirstPositionOfType,
group,
PPC_Q3_TYPE_TRIMESH,
5,
0xe6u8,
None,
),
(
PpcImportDispatcherTarget::Q3GroupGetPositionObject,
group,
1,
5,
0xe7u8,
Some(container),
),
(
PpcImportDispatcherTarget::Q3ViewGetRenderer,
view,
0,
4,
0xe8u8,
Some(renderer),
),
(
PpcImportDispatcherTarget::Q3ViewGetDrawContext,
view,
0,
4,
0xe9u8,
Some(draw_context),
),
(
PpcImportDispatcherTarget::Q3ViewGetCamera,
view,
0,
4,
0xeau8,
Some(camera),
),
(
PpcImportDispatcherTarget::Q3ViewGetLightGroup,
view,
0,
4,
0xebu8,
Some(light_group),
),
];
for (index, (target, object, arg4, output_gpr, sentinel, retained_object)) in
invalid_getters.iter().enumerate()
{
let invalid_output_ptr = PPC_DATA_BASE + 0x7000 + (index as u32) * 0x100;
loaded
.memory
.add_region(invalid_output_ptr, vec![*sentinel; 3]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target.clone();
loaded.cpu.gpr[3] = *object;
loaded.cpu.gpr[4] = if *output_gpr == 4 {
invalid_output_ptr
} else {
*arg4
};
loaded.cpu.gpr[5] = if *output_gpr == 5 {
invalid_output_ptr
} else {
0
};
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..3 {
assert_eq!(
loaded.memory.read_u8(invalid_output_ptr + offset),
Some(*sentinel)
);
}
if let Some(retained_object) = retained_object {
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
*retained_object
),
Some(1)
);
}
}
let file = texture + PPC_Q3_OBJECT_STRIDE * 11;
let storage = texture + PPC_Q3_OBJECT_STRIDE * 12;
let file_output_ptr = PPC_DATA_BASE + 0x7c00;
loaded.memory.add_region(file_output_ptr, vec![0xec; 3]);
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: false,
object_type: PPC_Q3_TYPE_TRIMESH,
read_offset: 7,
read_object: 9,
});
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileOpenRead;
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = file_output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u8(file_output_ptr), Some(0xec));
assert_eq!(loaded.memory.read_u8(file_output_ptr + 1), Some(0xec));
assert_eq!(loaded.memory.read_u8(file_output_ptr + 2), Some(0xec));
assert_eq!(
loaded.q3_files[0],
PpcQ3FileRecord {
file,
storage,
is_open: false,
object_type: PPC_Q3_TYPE_TRIMESH,
read_offset: 7,
read_object: 9,
}
);
}
#[test]
fn hle_import_runner_prevalidates_q3_storage_get_data_outputs() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Storage_GetData");
let mut loaded = load_pef_application(&pef).unwrap();
let storage = PPC_Q3_OBJECT_BASE;
let source_ptr = PPC_DATA_BASE + 0x1000;
let dest_ptr = PPC_DATA_BASE + 0x1100;
let size_read_ptr = PPC_DATA_BASE + 0x1200;
let size_out_ptr = PPC_DATA_BASE + 0x1300;
loaded.memory.add_region(source_ptr, b"abcdef".to_vec());
loaded.memory.add_region(dest_ptr, vec![0xfa; 2]);
loaded.memory.add_region(size_read_ptr, vec![0xfb; 4]);
loaded.memory.add_region(size_out_ptr, vec![0xfc; 3]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_TYPE_NONE,
source: PpcQ3ObjectSource::default(),
data_ptr: source_ptr,
data_size: 6,
});
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StorageGetSize;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = size_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u8(size_out_ptr), Some(0xfc));
assert_eq!(loaded.memory.read_u8(size_out_ptr + 1), Some(0xfc));
assert_eq!(loaded.memory.read_u8(size_out_ptr + 2), Some(0xfc));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StorageGetData;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = 3;
loaded.cpu.gpr[6] = dest_ptr;
loaded.cpu.gpr[7] = size_read_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u8(dest_ptr), Some(0xfa));
assert_eq!(loaded.memory.read_u8(dest_ptr + 1), Some(0xfa));
assert_eq!(loaded.memory.read_u32_be(size_read_ptr), Some(0xfbfb_fbfb));
}
#[test]
fn hle_import_runner_handles_q3_mipmap_texture_get_mipmap() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MipmapTexture_GetMipmap");
let mut loaded = load_pef_application(&pef).unwrap();
let texture = PPC_Q3_OBJECT_BASE;
let storage = texture + PPC_Q3_OBJECT_STRIDE;
let mipmap_ptr = PPC_DATA_BASE + 0x1000;
let mipmap_out_ptr = PPC_DATA_BASE + 0x1100;
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
for (index, byte) in mipmap.iter_mut().enumerate() {
*byte = index as u8;
}
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4].copy_from_slice(&storage.to_be_bytes());
loaded.memory.add_region(mipmap_ptr, mipmap.clone());
loaded
.memory
.add_region(mipmap_out_ptr, vec![0xaa; PPC_Q3_MIPMAP_COPY_SIZE as usize]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: texture,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MIPMAP_COPY_SIZE,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded
.q3_mipmap_textures
.push(PpcQ3MipmapTextureRecord { texture, mipmap });
loaded.cpu.gpr[3] = texture;
loaded.cpu.gpr[4] = mipmap_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(mipmap_out_ptr), Some(storage));
assert_eq!(
loaded
.memory
.read_u8(mipmap_out_ptr + PPC_Q3_MIPMAP_COPY_SIZE - 1),
Some((PPC_Q3_MIPMAP_COPY_SIZE - 1) as u8)
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage),
Some(2)
);
let wrong_storage = storage + PPC_Q3_OBJECT_STRIDE;
loaded
.q3_objects
.push(test_q3_object(wrong_storage, PPC_Q3_TYPE_TRIMESH));
loaded.q3_mipmap_textures[0].mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4]
.copy_from_slice(&wrong_storage.to_be_bytes());
for offset in 0..PPC_Q3_MIPMAP_COPY_SIZE {
loaded
.memory
.write_u8(mipmap_out_ptr + offset, 0xee)
.unwrap();
}
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = texture;
loaded.cpu.gpr[4] = mipmap_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u8(mipmap_out_ptr), Some(0xee));
assert_eq!(
loaded
.memory
.read_u8(mipmap_out_ptr + PPC_Q3_MIPMAP_COPY_SIZE - 1),
Some(0xee)
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage),
Some(2)
);
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
wrong_storage
),
Some(1)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_mipmap_textures[0].mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4]
.copy_from_slice(&storage.to_be_bytes());
loaded.memory.write_u8(mipmap_out_ptr, 0xdd).unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = mipmap_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u8(mipmap_out_ptr), Some(0xdd));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage),
Some(2)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_mipmap_texture_get_mipmap_from_object_payload() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MipmapTexture_GetMipmap");
let mut loaded = load_pef_application(&pef).unwrap();
let texture = PPC_Q3_OBJECT_BASE;
let storage = texture + PPC_Q3_OBJECT_STRIDE;
let mipmap_ptr = PPC_DATA_BASE + 0x1000;
let mipmap_out_ptr = PPC_DATA_BASE + 0x1300;
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
for (index, byte) in mipmap.iter_mut().enumerate() {
*byte = 0xffu8.wrapping_sub(index as u8);
}
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4].copy_from_slice(&storage.to_be_bytes());
loaded.memory.add_region(mipmap_ptr, mipmap);
loaded
.memory
.add_region(mipmap_out_ptr, vec![0xaa; PPC_Q3_MIPMAP_COPY_SIZE as usize]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: texture,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: mipmap_ptr,
data_size: PPC_Q3_MIPMAP_COPY_SIZE,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = texture;
loaded.cpu.gpr[4] = mipmap_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(mipmap_out_ptr), Some(storage));
assert_eq!(
loaded
.memory
.read_u8(mipmap_out_ptr + PPC_Q3_MIPMAP_COPY_SIZE - 1),
Some(0xffu8.wrapping_sub((PPC_Q3_MIPMAP_COPY_SIZE - 1) as u8))
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage),
Some(2)
);
}
#[test]
fn hle_import_runner_handles_q3_storage_get_size() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Storage_GetSize");
let mut loaded = load_pef_application(&pef).unwrap();
let storage = PPC_Q3_OBJECT_BASE;
let size_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(size_out_ptr, vec![0; 4]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: PPC_DATA_BASE,
data_size: 4096,
});
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = size_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(size_out_ptr), Some(4096));
loaded.q3_objects[0].object_type = PPC_Q3_TEXTURE_TYPE_MIPMAP;
loaded
.memory
.write_u32_be(size_out_ptr, 0xdddd_dddd)
.unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = size_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(size_out_ptr), Some(0xdddd_dddd));
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_storage_get_data() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Storage_GetData");
let mut loaded = load_pef_application(&pef).unwrap();
let storage = PPC_Q3_OBJECT_BASE;
let source_ptr = PPC_DATA_BASE + 0x1000;
let dest_ptr = PPC_DATA_BASE + 0x1100;
let size_read_ptr = PPC_DATA_BASE + 0x1200;
loaded.memory.add_region(source_ptr, b"abcdef".to_vec());
loaded.memory.add_region(dest_ptr, vec![0; 3]);
loaded.memory.add_region(size_read_ptr, vec![0; 4]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: source_ptr,
data_size: 6,
});
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = 3;
loaded.cpu.gpr[6] = dest_ptr;
loaded.cpu.gpr[7] = size_read_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(size_read_ptr), Some(3));
assert_eq!(loaded.memory.read_u8(dest_ptr), Some(b'c'));
assert_eq!(loaded.memory.read_u8(dest_ptr + 1), Some(b'd'));
assert_eq!(loaded.memory.read_u8(dest_ptr + 2), Some(b'e'));
loaded.q3_objects[0].object_type = PPC_Q3_TEXTURE_TYPE_MIPMAP;
for offset in 0..3 {
loaded.memory.write_u8(dest_ptr + offset, 0xdd).unwrap();
}
loaded
.memory
.write_u32_be(size_read_ptr, 0xeeee_eeee)
.unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = 3;
loaded.cpu.gpr[6] = dest_ptr;
loaded.cpu.gpr[7] = size_read_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..3 {
assert_eq!(loaded.memory.read_u8(dest_ptr + offset), Some(0xdd));
}
assert_eq!(loaded.memory.read_u32_be(size_read_ptr), Some(0xeeee_eeee));
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_storage_set_data() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Storage_SetData");
let mut loaded = load_pef_application(&pef).unwrap();
let storage = PPC_Q3_OBJECT_BASE;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let source_ptr = PPC_DATA_BASE + 0x1100;
let size_written_ptr = PPC_DATA_BASE + 0x1200;
loaded.memory.add_region(storage_ptr, vec![0; 6]);
loaded.memory.add_region(source_ptr, b"XYZ".to_vec());
loaded.memory.add_region(size_written_ptr, vec![0; 4]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: 6,
});
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = 3;
loaded.cpu.gpr[6] = source_ptr;
loaded.cpu.gpr[7] = size_written_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(size_written_ptr), Some(3));
assert_eq!(loaded.memory.read_u8(storage_ptr + 2), Some(b'X'));
assert_eq!(loaded.memory.read_u8(storage_ptr + 3), Some(b'Y'));
assert_eq!(loaded.memory.read_u8(storage_ptr + 4), Some(b'Z'));
loaded.q3_objects[0].object_type = PPC_Q3_TEXTURE_TYPE_MIPMAP;
loaded.memory.write_u8(storage_ptr + 2, 0xaa).unwrap();
loaded.memory.write_u8(storage_ptr + 3, 0xbb).unwrap();
loaded.memory.write_u8(storage_ptr + 4, 0xcc).unwrap();
loaded
.memory
.write_u32_be(size_written_ptr, 0xeeee_eeee)
.unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = storage;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = 3;
loaded.cpu.gpr[6] = source_ptr;
loaded.cpu.gpr[7] = size_written_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(size_written_ptr),
Some(0xeeee_eeee)
);
assert_eq!(loaded.memory.read_u8(storage_ptr + 2), Some(0xaa));
assert_eq!(loaded.memory.read_u8(storage_ptr + 3), Some(0xbb));
assert_eq!(loaded.memory.read_u8(storage_ptr + 4), Some(0xcc));
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_vector3d_normalize() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Vector3D_Normalize");
let mut loaded = load_pef_application(&pef).unwrap();
let vector_ptr = PPC_DATA_BASE + 0x1000;
let result_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(vector_ptr, vec![0; 12]);
loaded.memory.add_region(result_ptr, vec![0; 12]);
ppc_write_q3_vector3d(&mut loaded.memory, vector_ptr, (3.0, 4.0, 0.0)).unwrap();
loaded.cpu.gpr[3] = vector_ptr;
loaded.cpu.gpr[4] = result_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], result_ptr);
let (x, y, z) = ppc_read_q3_vector3d(&mut loaded.memory, result_ptr).unwrap();
assert!((x - 0.6).abs() < 1e-6);
assert!((y - 0.8).abs() < 1e-6);
assert_eq!(z, 0.0);
}
#[test]
fn hle_import_runner_handles_q3_vector_and_point_math() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Vector2D_Normalize");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let vector2_ptr = scratch_ptr;
let vector2_result_ptr = scratch_ptr + 0x20;
let vector3_left_ptr = scratch_ptr + 0x40;
let vector3_right_ptr = scratch_ptr + 0x60;
let vector3_result_ptr = scratch_ptr + 0x80;
let point2_a_ptr = scratch_ptr + 0xa0;
let point2_b_ptr = scratch_ptr + 0xc0;
let point3_a_ptr = scratch_ptr + 0xe0;
let point3_b_ptr = scratch_ptr + 0x100;
let tri_a_ptr = scratch_ptr + 0x120;
let tri_b_ptr = scratch_ptr + 0x140;
let tri_c_ptr = scratch_ptr + 0x160;
let tri_result_ptr = scratch_ptr + 0x180;
loaded.memory.add_region(scratch_ptr, vec![0; 0x200]);
ppc_write_q3_vector2d(&mut loaded.memory, vector2_ptr, (6.0, 8.0)).unwrap();
loaded.cpu.gpr[3] = vector2_ptr;
loaded.cpu.gpr[4] = vector2_result_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], vector2_result_ptr);
let (x, y) = ppc_read_q3_vector2d(&mut loaded.memory, vector2_result_ptr).unwrap();
assert!((x - 0.6).abs() < 1e-6);
assert!((y - 0.8).abs() < 1e-6);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Vector3DCross;
ppc_write_q3_vector3d(&mut loaded.memory, vector3_left_ptr, (1.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, vector3_right_ptr, (0.0, 1.0, 0.0)).unwrap();
loaded.cpu.gpr[3] = vector3_left_ptr;
loaded.cpu.gpr[4] = vector3_right_ptr;
loaded.cpu.gpr[5] = vector3_result_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], vector3_result_ptr);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, vector3_result_ptr).unwrap(),
(0.0, 0.0, 1.0)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Point2DDistance;
ppc_write_q3_vector2d(&mut loaded.memory, point2_a_ptr, (1.0, 2.0)).unwrap();
ppc_write_q3_vector2d(&mut loaded.memory, point2_b_ptr, (4.0, 6.0)).unwrap();
loaded.cpu.gpr[3] = point2_a_ptr;
loaded.cpu.gpr[4] = point2_b_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!((f64::from_bits(loaded.cpu.fpr[1]) - 5.0).abs() < 1e-6);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Point3DDistance;
ppc_write_q3_vector3d(&mut loaded.memory, point3_a_ptr, (1.0, 2.0, 3.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, point3_b_ptr, (4.0, 6.0, 15.0)).unwrap();
loaded.cpu.gpr[3] = point3_a_ptr;
loaded.cpu.gpr[4] = point3_b_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!((f64::from_bits(loaded.cpu.fpr[1]) - 13.0).abs() < 1e-6);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Point3DCrossProductTri;
ppc_write_q3_vector3d(&mut loaded.memory, tri_a_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, tri_b_ptr, (1.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, tri_c_ptr, (0.0, 2.0, 0.0)).unwrap();
loaded.cpu.gpr[3] = tri_a_ptr;
loaded.cpu.gpr[4] = tri_b_ptr;
loaded.cpu.gpr[5] = tri_c_ptr;
loaded.cpu.gpr[6] = tri_result_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], tri_result_ptr);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, tri_result_ptr).unwrap(),
(0.0, 0.0, 2.0)
);
}
#[test]
fn hle_import_runner_prevalidates_q3_vector_math_outputs() {
fn run_vector_math_call(
loaded: &mut PpcLoadedApp,
target: PpcImportDispatcherTarget,
args: &[u32],
) -> PpcHleRunProbe {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
for (index, arg) in args.iter().copied().enumerate() {
loaded.cpu.gpr[3 + index] = arg;
}
loaded.run_with_hle_imports(64)
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Vector2D_Normalize");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let vector2_ptr = scratch_ptr;
let vector3_left_ptr = scratch_ptr + 0x20;
let vector3_right_ptr = scratch_ptr + 0x40;
let vector3_third_ptr = scratch_ptr + 0x60;
let short_vector2_out = PPC_DATA_BASE + 0x4000;
let short_vector3_out = PPC_DATA_BASE + 0x4100;
loaded.memory.add_region(scratch_ptr, vec![0; 0x100]);
loaded.memory.add_region(
short_vector2_out,
vec![0xa2; (PPC_Q3_VECTOR2D_SIZE - 1) as usize],
);
loaded.memory.add_region(
short_vector3_out,
vec![0xa3; (PPC_Q3_VECTOR3D_SIZE - 1) as usize],
);
ppc_write_q3_vector2d(&mut loaded.memory, vector2_ptr, (6.0, 8.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, vector3_left_ptr, (1.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, vector3_right_ptr, (0.0, 1.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, vector3_third_ptr, (0.0, 2.0, 0.0)).unwrap();
let probe = run_vector_math_call(
&mut loaded,
PpcImportDispatcherTarget::Q3Vector2DNormalize,
&[vector2_ptr, short_vector2_out],
);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..(PPC_Q3_VECTOR2D_SIZE - 1) {
assert_eq!(
loaded.memory.read_u8(short_vector2_out + offset),
Some(0xa2)
);
}
let vector3_output_targets = [
(
PpcImportDispatcherTarget::Q3Vector3DNormalize,
vec![vector3_left_ptr, short_vector3_out],
),
(
PpcImportDispatcherTarget::Q3Vector3DCross,
vec![vector3_left_ptr, vector3_right_ptr, short_vector3_out],
),
(
PpcImportDispatcherTarget::Q3Point3DCrossProductTri,
vec![
vector3_left_ptr,
vector3_right_ptr,
vector3_third_ptr,
short_vector3_out,
],
),
];
for (target, args) in vector3_output_targets {
for offset in 0..(PPC_Q3_VECTOR3D_SIZE - 1) {
loaded
.memory
.write_u8(short_vector3_out + offset, 0xa3)
.unwrap();
}
let probe = run_vector_math_call(&mut loaded, target, &args);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..(PPC_Q3_VECTOR3D_SIZE - 1) {
assert_eq!(
loaded.memory.read_u8(short_vector3_out + offset),
Some(0xa3)
);
}
}
}
#[test]
fn hle_import_runner_handles_q3_matrix_and_transform_math() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Matrix4x4_SetTranslate");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let translate_matrix_ptr = scratch_ptr;
let scale_matrix_ptr = scratch_ptr + 0x80;
let result_matrix_ptr = scratch_ptr + 0x100;
let inverse_matrix_ptr = scratch_ptr + 0x180;
let point_ptr = scratch_ptr + 0x200;
let vector_ptr = scratch_ptr + 0x220;
let result_ptr = scratch_ptr + 0x240;
let transform = PPC_Q3_OBJECT_BASE;
loaded.memory.add_region(scratch_ptr, vec![0; 0x300]);
loaded.cpu.gpr[3] = translate_matrix_ptr;
loaded.cpu.fpr[1] = 2.0f64.to_bits();
loaded.cpu.fpr[2] = 3.0f64.to_bits();
loaded.cpu.fpr[3] = 4.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], translate_matrix_ptr);
let matrix = ppc_read_q3_matrix4x4(&mut loaded.memory, translate_matrix_ptr).unwrap();
assert_eq!(matrix[0][0], 1.0);
assert_eq!(matrix[3][0], 2.0);
assert_eq!(matrix[3][1], 3.0);
assert_eq!(matrix[3][2], 4.0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Matrix4x4SetIdentity;
loaded.cpu.gpr[3] = result_matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], result_matrix_ptr);
let identity = ppc_read_q3_matrix4x4(&mut loaded.memory, result_matrix_ptr).unwrap();
assert_eq!(identity[0][0], 1.0);
assert_eq!(identity[1][1], 1.0);
assert_eq!(identity[2][2], 1.0);
assert_eq!(identity[3][3], 1.0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Matrix3x3SetTranslate;
loaded.cpu.gpr[3] = result_matrix_ptr;
loaded.cpu.fpr[1] = 5.0f64.to_bits();
loaded.cpu.fpr[2] = 6.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], result_matrix_ptr);
assert_eq!(
ppc_read_f32_be(&mut loaded.memory, result_matrix_ptr + 24),
Some(5.0)
);
assert_eq!(
ppc_read_f32_be(&mut loaded.memory, result_matrix_ptr + 28),
Some(6.0)
);
assert_eq!(
ppc_read_f32_be(&mut loaded.memory, result_matrix_ptr + 32),
Some(1.0)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Matrix4x4Transpose;
loaded.cpu.gpr[3] = translate_matrix_ptr;
loaded.cpu.gpr[4] = result_matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], result_matrix_ptr);
let transposed = ppc_read_q3_matrix4x4(&mut loaded.memory, result_matrix_ptr).unwrap();
assert_eq!(transposed[0][3], 2.0);
assert_eq!(transposed[1][3], 3.0);
assert_eq!(transposed[2][3], 4.0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Matrix4x4SetRotateZ;
loaded.cpu.gpr[3] = result_matrix_ptr;
loaded.cpu.fpr[1] = std::f64::consts::FRAC_PI_2.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], result_matrix_ptr);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Point3DTransform;
ppc_write_q3_vector3d(&mut loaded.memory, point_ptr, (1.0, 0.0, 0.0)).unwrap();
loaded.cpu.gpr[3] = point_ptr;
loaded.cpu.gpr[4] = result_matrix_ptr;
loaded.cpu.gpr[5] = result_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let (x, y, z) = ppc_read_q3_vector3d(&mut loaded.memory, result_ptr).unwrap();
assert!(x.abs() < 1e-6);
assert!((y - 1.0).abs() < 1e-6);
assert_eq!(z, 0.0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Point3DTransform;
ppc_write_q3_vector3d(&mut loaded.memory, point_ptr, (1.0, 1.0, 1.0)).unwrap();
loaded.cpu.gpr[3] = point_ptr;
loaded.cpu.gpr[4] = translate_matrix_ptr;
loaded.cpu.gpr[5] = result_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], result_ptr);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, result_ptr).unwrap(),
(3.0, 4.0, 5.0)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Vector3DTransform;
ppc_write_q3_vector3d(&mut loaded.memory, vector_ptr, (1.0, 1.0, 1.0)).unwrap();
loaded.cpu.gpr[3] = vector_ptr;
loaded.cpu.gpr[4] = translate_matrix_ptr;
loaded.cpu.gpr[5] = result_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], result_ptr);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, result_ptr).unwrap(),
(1.0, 1.0, 1.0)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Matrix4x4SetScale;
loaded.cpu.gpr[3] = scale_matrix_ptr;
loaded.cpu.fpr[1] = 2.0f64.to_bits();
loaded.cpu.fpr[2] = 3.0f64.to_bits();
loaded.cpu.fpr[3] = 4.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], scale_matrix_ptr);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Matrix4x4Multiply;
loaded.cpu.gpr[3] = scale_matrix_ptr;
loaded.cpu.gpr[4] = translate_matrix_ptr;
loaded.cpu.gpr[5] = result_matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], result_matrix_ptr);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Point3DTransform;
loaded.cpu.gpr[3] = point_ptr;
loaded.cpu.gpr[4] = result_matrix_ptr;
loaded.cpu.gpr[5] = result_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, result_ptr).unwrap(),
(4.0, 6.0, 8.0)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3Matrix4x4Invert;
loaded.cpu.gpr[3] = translate_matrix_ptr;
loaded.cpu.gpr[4] = inverse_matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], inverse_matrix_ptr);
let inverse = ppc_read_q3_matrix4x4(&mut loaded.memory, inverse_matrix_ptr).unwrap();
assert_eq!(inverse[3][0], -2.0);
assert_eq!(inverse[3][1], -3.0);
assert_eq!(inverse[3][2], -4.0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MatrixTransformNew;
loaded.cpu.gpr[3] = translate_matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], transform);
assert_eq!(
loaded.q3_objects,
vec![PpcQ3ObjectRecord {
object: transform,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TRANSFORM_TYPE_MATRIX,
source: PpcQ3ObjectSource::default(),
data_ptr: translate_matrix_ptr,
data_size: 64,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MatrixTransformSet;
loaded.cpu.gpr[3] = transform;
loaded.cpu.gpr[4] = scale_matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_objects[0].data_ptr, scale_matrix_ptr);
let non_transform = transform + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: non_transform,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: translate_matrix_ptr,
data_size: 64,
});
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = non_transform;
loaded.cpu.gpr[4] = translate_matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_objects[1].data_ptr, translate_matrix_ptr);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_error_state.last_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TransformGetMatrix;
loaded.cpu.gpr[3] = transform;
loaded.cpu.gpr[4] = result_matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let copied = ppc_read_q3_matrix4x4(&mut loaded.memory, result_matrix_ptr).unwrap();
assert_eq!(copied[0][0], 2.0);
assert_eq!(copied[1][1], 3.0);
assert_eq!(copied[2][2], 4.0);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = non_transform;
loaded.cpu.gpr[4] = result_matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
let preserved = ppc_read_q3_matrix4x4(&mut loaded.memory, result_matrix_ptr).unwrap();
assert_eq!(preserved[0][0], 2.0);
assert_eq!(preserved[1][1], 3.0);
assert_eq!(preserved[2][2], 4.0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_error_state.last_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_point_transform_arrays() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Point3D_To3DTransformArray");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let matrix_ptr = scratch_ptr;
let input_ptr = scratch_ptr + 0x80;
let output3d_ptr = scratch_ptr + 0x180;
let output4d_ptr = scratch_ptr + 0x280;
let input_stride = 20;
let output3d_stride = 16;
let output4d_stride = 24;
loaded.memory.add_region(scratch_ptr, vec![0xcc; 0x400]);
let mut matrix = ppc_q3_matrix4x4_identity();
matrix[3][0] = 2.0;
matrix[3][1] = 3.0;
matrix[3][2] = 4.0;
ppc_write_q3_matrix4x4(&mut loaded.memory, matrix_ptr, &matrix).unwrap();
let input_points = [(1.0, 1.0, 1.0), (-1.0, 2.0, 3.0), (0.0, 0.0, 0.0)];
for (index, point) in input_points.iter().copied().enumerate() {
ppc_write_q3_vector3d(
&mut loaded.memory,
input_ptr + (index as u32 * input_stride),
point,
)
.unwrap();
}
loaded.cpu.gpr[3] = input_ptr;
loaded.cpu.gpr[4] = matrix_ptr;
loaded.cpu.gpr[5] = output3d_ptr;
loaded.cpu.gpr[6] = input_points.len() as u32;
loaded.cpu.gpr[7] = input_stride;
loaded.cpu.gpr[8] = output3d_stride;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let expected3d = [(3.0, 4.0, 5.0), (1.0, 5.0, 7.0), (2.0, 3.0, 4.0)];
for (index, expected) in expected3d.iter().copied().enumerate() {
let point_ptr = output3d_ptr + (index as u32 * output3d_stride);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, point_ptr).unwrap(),
expected
);
assert_eq!(loaded.memory.read_u8(point_ptr + 12), Some(0xcc));
}
matrix[0][3] = 0.5;
ppc_write_q3_matrix4x4(&mut loaded.memory, matrix_ptr, &matrix).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3Point3DTo4DTransformArray;
loaded.cpu.gpr[3] = input_ptr;
loaded.cpu.gpr[4] = matrix_ptr;
loaded.cpu.gpr[5] = output4d_ptr;
loaded.cpu.gpr[6] = 2;
loaded.cpu.gpr[7] = input_stride;
loaded.cpu.gpr[8] = output4d_stride;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let expected4d = [(3.0, 4.0, 5.0, 1.5), (1.0, 5.0, 7.0, 0.5)];
for (index, expected) in expected4d.iter().copied().enumerate() {
let point_ptr = output4d_ptr + (index as u32 * output4d_stride);
let actual = (
ppc_read_f32_be(&mut loaded.memory, point_ptr).unwrap(),
ppc_read_f32_be(&mut loaded.memory, point_ptr + 4).unwrap(),
ppc_read_f32_be(&mut loaded.memory, point_ptr + 8).unwrap(),
ppc_read_f32_be(&mut loaded.memory, point_ptr + 12).unwrap(),
);
assert_eq!(actual.0, expected.0);
assert_eq!(actual.1, expected.1);
assert_eq!(actual.2, expected.2);
assert!((actual.3 - expected.3).abs() < 1e-6);
assert_eq!(loaded.memory.read_u8(point_ptr + 16), Some(0xcc));
}
ppc_write_q3_matrix4x4(&mut loaded.memory, matrix_ptr, &ppc_q3_matrix4x4_identity())
.unwrap();
for (index, point) in [(1.0, 2.0, 3.0), (4.0, 4.0, 3.0)].into_iter().enumerate() {
ppc_write_q3_vector3d(
&mut loaded.memory,
input_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
}
assert!(ppc_q3_point3d_transform_array(
&mut loaded.memory,
input_ptr,
matrix_ptr,
output4d_ptr,
2,
PPC_Q3_POINT3D_SIZE,
16,
true,
));
assert_eq!(
ppc_read_f32_be(&mut loaded.memory, output4d_ptr + 12),
Some(1.0)
);
}
#[test]
fn hle_import_runner_tracks_q3_file_storage_and_open_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_SetStorage");
let mut loaded = load_pef_application(&pef).unwrap();
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.extend([
test_q3_object(file, PPC_Q3_TYPE_FILE),
test_q3_object(storage, PPC_Q3_STORAGE_TYPE_MEMORY),
]);
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = storage;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_files.len(), 1);
assert_eq!(
loaded.q3_files[0],
PpcQ3FileRecord {
file,
storage,
is_open: false,
object_type: 0,
read_offset: 0,
read_object: 0,
}
);
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_OpenRead");
let mut loaded = load_pef_application(&pef).unwrap();
let object_type_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(object_type_out_ptr, vec![0xaa; 4]);
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: false,
object_type: 0x1234_5678,
read_offset: 99,
read_object: 0xdead_beef,
});
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = object_type_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_files[0].is_open);
assert_eq!(loaded.q3_files[0].read_offset, 0);
assert_eq!(loaded.q3_files[0].read_object, 0);
assert_eq!(loaded.memory.read_u32_be(object_type_out_ptr), Some(0));
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_Close");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 6,
read_object: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(!loaded.q3_files[0].is_open);
assert_eq!(loaded.q3_files[0].read_offset, 0);
assert_eq!(loaded.q3_files[0].read_object, 0);
}
#[test]
fn hle_import_runner_validates_q3_file_accessors() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_SetStorage");
let mut loaded = load_pef_application(&pef).unwrap();
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let retained_storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let output_ptr = PPC_DATA_BASE + 0x1000;
let original_record = PpcQ3FileRecord {
file,
storage: retained_storage,
is_open: true,
object_type: 0x1234_5678,
read_offset: 7,
read_object: 9,
};
loaded.memory.add_region(output_ptr, vec![0xcc; 4]);
loaded.q3_objects.extend([
test_q3_object(file, PPC_Q3_TEXTURE_TYPE_MIPMAP),
test_q3_object(storage, PPC_Q3_STORAGE_TYPE_MEMORY),
test_q3_object(retained_storage, PPC_Q3_STORAGE_TYPE_MEMORY),
]);
loaded.q3_files.push(original_record);
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = storage;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileSetStorage),
0
);
assert_eq!(loaded.q3_files[0], original_record);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, storage),
Some(1)
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.q3_objects[0].object_type = PPC_Q3_TYPE_FILE;
loaded.q3_objects[1].object_type = PPC_Q3_TEXTURE_TYPE_MIPMAP;
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = storage;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileSetStorage),
0
);
assert_eq!(loaded.q3_files[0], original_record);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.q3_objects[0].object_type = PPC_Q3_TEXTURE_TYPE_MIPMAP;
loaded.q3_objects[1].object_type = PPC_Q3_STORAGE_TYPE_MEMORY;
loaded.memory.write_u32_be(output_ptr, 0xcccc_cccc).unwrap();
loaded.cpu.gpr[3] = file;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileOpenRead),
0
);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(0xcccc_cccc));
assert_eq!(loaded.q3_files[0], original_record);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.q3_objects[0].object_type = PPC_Q3_TYPE_FILE;
loaded.q3_objects[1].object_type = PPC_Q3_STORAGE_TYPE_MEMORY;
loaded.q3_objects[2].object_type = PPC_Q3_TEXTURE_TYPE_MIPMAP;
let object_count = loaded.q3_objects.len();
loaded.cpu.gpr[3] = file;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileReadObject),
0
);
assert_eq!(loaded.q3_objects.len(), object_count);
assert_eq!(loaded.q3_files[0], original_record);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.gpr[3] = file;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileIsEndOfFile),
1
);
assert_eq!(loaded.q3_files[0], original_record);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.q3_objects[0].object_type = PPC_Q3_TEXTURE_TYPE_MIPMAP;
loaded.q3_objects[1].object_type = PPC_Q3_STORAGE_TYPE_MEMORY;
loaded.q3_objects[2].object_type = PPC_Q3_STORAGE_TYPE_MEMORY;
loaded.cpu.gpr[3] = file;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3FileClose),
0
);
assert_eq!(loaded.q3_files[0], original_record);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_reads_q3_file_objects_and_records_hierarchy() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_IsEndOfFile");
let mut loaded = load_pef_application(&pef).unwrap();
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&16u32.to_be_bytes());
storage_bytes.extend_from_slice(&[0; 16]);
storage_bytes.extend_from_slice(b"bgng");
storage_bytes.extend_from_slice(&8u32.to_be_bytes());
storage_bytes.extend_from_slice(b"dspg");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"bgng");
storage_bytes.extend_from_slice(&8u32.to_be_bytes());
storage_bytes.extend_from_slice(b"ogtg");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"tmsh");
storage_bytes.extend_from_slice(&4u32.to_be_bytes());
storage_bytes.extend_from_slice(&[0xde, 0xad, 0xbe, 0xef]);
storage_bytes.extend_from_slice(b"endg");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"endg");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileReadObject;
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
let read_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], read_object);
assert_eq!(loaded.q3_files[0].read_offset, 48);
assert_eq!(loaded.q3_files[0].read_object, read_object);
let display_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
assert_eq!(
loaded.q3_objects[2],
PpcQ3ObjectRecord {
object: read_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource {
file,
offset: 40,
parent_group_type: u32::from_be_bytes(*b"dspg"),
group_depth: 1,
},
data_ptr: storage_ptr + 40,
data_size: 8,
}
);
assert_eq!(
loaded.q3_objects[3],
PpcQ3ObjectRecord {
object: display_group,
kind: PpcQ3ObjectKind::Generic,
object_type: u32::from_be_bytes(*b"dspg"),
source: PpcQ3ObjectSource {
file,
offset: 24,
parent_group_type: PPC_Q3_TYPE_NONE,
group_depth: 1,
},
data_ptr: storage_ptr + 24,
data_size: 16,
}
);
assert_eq!(
loaded.q3_file_groups,
vec![PpcQ3FileGroupRecord {
file,
offset: 24,
group: display_group,
group_type: u32::from_be_bytes(*b"dspg"),
parent_group: 0,
group_depth: 1,
}]
);
assert_eq!(
loaded.q3_group_memberships,
vec![PpcQ3GroupMembershipRecord {
group: display_group,
object: read_object,
before: None,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileIsEndOfFile;
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileReadObject;
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let read_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let object_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
assert_eq!(loaded.cpu.gpr[3], read_object);
assert_eq!(loaded.q3_files[0].read_offset, 76);
assert_eq!(loaded.q3_files[0].read_object, read_object);
assert_eq!(
loaded.q3_objects[4],
PpcQ3ObjectRecord {
object: read_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource {
file,
offset: 64,
parent_group_type: u32::from_be_bytes(*b"ogtg"),
group_depth: 2,
},
data_ptr: storage_ptr + 64,
data_size: 12,
}
);
assert_eq!(
loaded.q3_objects[5],
PpcQ3ObjectRecord {
object: object_group,
kind: PpcQ3ObjectKind::Generic,
object_type: u32::from_be_bytes(*b"ogtg"),
source: PpcQ3ObjectSource {
file,
offset: 48,
parent_group_type: u32::from_be_bytes(*b"dspg"),
group_depth: 2,
},
data_ptr: storage_ptr + 48,
data_size: 16,
}
);
assert_eq!(
loaded.q3_file_groups,
vec![
PpcQ3FileGroupRecord {
file,
offset: 24,
group: display_group,
group_type: u32::from_be_bytes(*b"dspg"),
parent_group: 0,
group_depth: 1,
},
PpcQ3FileGroupRecord {
file,
offset: 48,
group: object_group,
group_type: u32::from_be_bytes(*b"ogtg"),
parent_group: display_group,
group_depth: 2,
},
]
);
assert_eq!(
loaded.q3_group_memberships,
vec![
PpcQ3GroupMembershipRecord {
group: display_group,
object: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2,
before: None,
},
PpcQ3GroupMembershipRecord {
group: display_group,
object: object_group,
before: None,
},
PpcQ3GroupMembershipRecord {
group: object_group,
object: read_object,
before: None,
},
]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileIsEndOfFile;
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FileReadObject;
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_files[0].read_offset, storage_bytes.len() as u32);
}
#[test]
fn hle_import_runner_reads_q3_file_trimesh_body_data() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let output_ptr = PPC_DATA_BASE + 0x2000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let trimesh_body: Vec<u8> = (0..PPC_Q3_TRIMESH_DATA_SIZE)
.map(|offset| 0x40u8.wrapping_add(offset as u8))
.collect();
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"tmsh");
storage_bytes.extend_from_slice(&PPC_Q3_TRIMESH_DATA_SIZE.to_be_bytes());
storage_bytes.extend_from_slice(&trimesh_body);
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded
.memory
.add_region(output_ptr, vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = trimesh;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], trimesh);
assert_eq!(loaded.q3_files[0].read_offset, storage_bytes.len() as u32);
assert_eq!(
loaded.q3_objects[2],
PpcQ3ObjectRecord {
object: trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource {
file,
offset: 8,
parent_group_type: PPC_Q3_TYPE_NONE,
group_depth: 0,
},
data_ptr: storage_ptr + 8,
data_size: PPC_Q3_TRIMESH_DATA_SIZE + 8,
}
);
assert_eq!(
loaded.q3_trimeshes,
vec![PpcQ3TriMeshRecord {
trimesh,
data: trimesh_body.clone(),
triangle_attribute_sets: Vec::new(),
get_data_copies: Vec::new(),
}]
);
loaded.memory.write_u8(storage_ptr + 16, 0).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshGetData;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
for offset in 0..PPC_Q3_TRIMESH_DATA_SIZE {
assert_eq!(
loaded.memory.read_u8(output_ptr + offset),
Some(trimesh_body[offset as usize])
);
}
}
#[test]
fn hle_import_runner_decodes_q3_file_3dmf_trimesh_body_data() {
fn append_attribute_array(
body: &mut Vec<u8>,
attribute_type: u32,
which_array: u32,
which_attr: u32,
data: &[u8],
) {
body.extend_from_slice(b"atar");
body.extend_from_slice(&(20u32 + data.len() as u32).to_be_bytes());
body.extend_from_slice(&attribute_type.to_be_bytes());
body.extend_from_slice(&0u32.to_be_bytes());
body.extend_from_slice(&which_array.to_be_bytes());
body.extend_from_slice(&which_attr.to_be_bytes());
body.extend_from_slice(&0u32.to_be_bytes());
body.extend_from_slice(data);
}
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let output_ptr = PPC_DATA_BASE + 0x2000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let mut trimesh_body = Vec::new();
trimesh_body.extend_from_slice(&1u32.to_be_bytes()); // triangles
trimesh_body.extend_from_slice(&1u32.to_be_bytes()); // triangle attribute types
trimesh_body.extend_from_slice(&1u32.to_be_bytes()); // edges
trimesh_body.extend_from_slice(&0u32.to_be_bytes()); // edge attribute types
trimesh_body.extend_from_slice(&3u32.to_be_bytes()); // points
trimesh_body.extend_from_slice(&2u32.to_be_bytes()); // vertex attribute types
trimesh_body.extend_from_slice(&[0, 1, 2]); // triangle point indices
trimesh_body.extend_from_slice(&[0, 2, 0, 0xff]); // edge point and triangle indices
let point_bytes_start = trimesh_body.len();
for point in [(1.0f32, 2.0f32, 3.0f32), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)] {
for value in [point.0, point.1, point.2] {
trimesh_body.extend_from_slice(&value.to_bits().to_be_bytes());
}
}
for value in [-1.0f32, -2.0, -3.0, 7.0, 8.0, 9.0] {
trimesh_body.extend_from_slice(&value.to_bits().to_be_bytes());
}
trimesh_body.extend_from_slice(&0u32.to_be_bytes());
let point_bytes = trimesh_body[point_bytes_start..point_bytes_start + 36].to_vec();
let mut triangle_normal_bytes = Vec::new();
for value in [0.0f32, 0.0, 1.0] {
triangle_normal_bytes.extend_from_slice(&value.to_bits().to_be_bytes());
}
let mut normal_bytes = Vec::new();
for normal in [(0.0f32, 0.0f32, 1.0f32), (0.0, 1.0, 0.0), (1.0, 0.0, 0.0)] {
for value in [normal.0, normal.1, normal.2] {
normal_bytes.extend_from_slice(&value.to_bits().to_be_bytes());
}
}
let mut uv_bytes = Vec::new();
for uv in [(0.0f32, 0.0f32), (1.0, 0.0), (0.5, 1.0)] {
for value in [uv.0, uv.1] {
uv_bytes.extend_from_slice(&value.to_bits().to_be_bytes());
}
}
let mut attribute_chunks = Vec::new();
append_attribute_array(
&mut attribute_chunks,
PPC_Q3_ATTRIBUTE_TYPE_NORMAL,
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_TRIANGLE,
0,
&triangle_normal_bytes,
);
append_attribute_array(
&mut attribute_chunks,
PPC_Q3_ATTRIBUTE_TYPE_NORMAL,
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_VERTEX,
0,
&normal_bytes,
);
append_attribute_array(
&mut attribute_chunks,
PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV,
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_VERTEX,
1,
&uv_bytes,
);
let container_body_size = 8u32
+ u32::try_from(trimesh_body.len()).unwrap()
+ u32::try_from(attribute_chunks.len()).unwrap();
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&container_body_size.to_be_bytes());
storage_bytes.extend_from_slice(b"tmsh");
storage_bytes.extend_from_slice(&(trimesh_body.len() as u32).to_be_bytes());
storage_bytes.extend_from_slice(&trimesh_body);
storage_bytes.extend_from_slice(&attribute_chunks);
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded
.memory
.add_region(output_ptr, vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = trimesh;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], trimesh);
let data = &loaded
.q3_trimeshes
.iter()
.find(|record| record.trimesh == trimesh)
.unwrap()
.data;
assert_eq!(
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET),
Some(1)
);
assert_eq!(
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET),
Some(1)
);
assert_eq!(
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET),
Some(1)
);
assert_eq!(
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET),
Some(0)
);
assert_eq!(
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_NUM_POINTS_OFFSET),
Some(3)
);
assert_eq!(
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET),
Some(2)
);
let triangles_ptr =
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_TRIANGLES_OFFSET).unwrap();
let triangle_attrs_ptr =
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET)
.unwrap();
let edges_ptr = ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_EDGES_OFFSET).unwrap();
let points_ptr = ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_POINTS_OFFSET).unwrap();
let vertex_attrs_ptr =
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET).unwrap();
assert_eq!(loaded.memory.read_u32_be(triangles_ptr), Some(0));
assert_eq!(loaded.memory.read_u32_be(triangles_ptr + 4), Some(1));
assert_eq!(loaded.memory.read_u32_be(triangles_ptr + 8), Some(2));
assert_eq!(loaded.memory.read_u32_be(edges_ptr), Some(0));
assert_eq!(loaded.memory.read_u32_be(edges_ptr + 4), Some(2));
assert_ne!(triangle_attrs_ptr, 0);
assert_eq!(
loaded.memory.read_u32_be(triangle_attrs_ptr),
Some(PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
);
let triangle_normals_ptr = loaded.memory.read_u32_be(triangle_attrs_ptr + 4).unwrap();
assert_eq!(loaded.memory.read_u32_be(triangle_attrs_ptr + 8), Some(0));
for (offset, byte) in point_bytes.iter().copied().enumerate() {
assert_eq!(
loaded
.memory
.read_u8(points_ptr + u32::try_from(offset).unwrap()),
Some(byte)
);
}
assert_ne!(vertex_attrs_ptr, 0);
assert_eq!(
loaded.memory.read_u32_be(vertex_attrs_ptr),
Some(PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
);
let normals_ptr = loaded.memory.read_u32_be(vertex_attrs_ptr + 4).unwrap();
assert_eq!(loaded.memory.read_u32_be(vertex_attrs_ptr + 8), Some(0));
assert_eq!(
loaded
.memory
.read_u32_be(vertex_attrs_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE),
Some(PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV)
);
let uvs_ptr = loaded
.memory
.read_u32_be(vertex_attrs_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE + 4)
.unwrap();
assert_eq!(
loaded
.memory
.read_u32_be(vertex_attrs_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE + 8),
Some(0)
);
for (offset, byte) in normal_bytes.iter().copied().enumerate() {
assert_eq!(
loaded
.memory
.read_u8(normals_ptr + u32::try_from(offset).unwrap()),
Some(byte)
);
}
for (offset, byte) in triangle_normal_bytes.iter().copied().enumerate() {
assert_eq!(
loaded
.memory
.read_u8(triangle_normals_ptr + u32::try_from(offset).unwrap()),
Some(byte)
);
}
for (offset, byte) in uv_bytes.iter().copied().enumerate() {
assert_eq!(
loaded
.memory
.read_u8(uvs_ptr + u32::try_from(offset).unwrap()),
Some(byte)
);
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshGetData;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded
.memory
.read_u32_be(output_ptr + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET),
Some(3)
);
}
#[test]
fn hle_import_runner_exposes_q3_file_container_root_trimesh_data() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let child_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let output_ptr = PPC_DATA_BASE + 0x2000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let mut trimesh_body = vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize];
trimesh_body[PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET as usize
..PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET as usize + 4]
.copy_from_slice(&1u32.to_be_bytes());
trimesh_body[PPC_Q3_TRIMESH_NUM_POINTS_OFFSET as usize
..PPC_Q3_TRIMESH_NUM_POINTS_OFFSET as usize + 4]
.copy_from_slice(&3u32.to_be_bytes());
let container_body_size = 8 + PPC_Q3_TRIMESH_DATA_SIZE;
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&container_body_size.to_be_bytes());
storage_bytes.extend_from_slice(b"tmsh");
storage_bytes.extend_from_slice(&PPC_Q3_TRIMESH_DATA_SIZE.to_be_bytes());
storage_bytes.extend_from_slice(&trimesh_body);
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded
.memory
.add_region(output_ptr, vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = container;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], container);
assert_eq!(
loaded.q3_objects[2],
PpcQ3ObjectRecord {
object: container,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource {
file,
offset: 8,
parent_group_type: PPC_Q3_TYPE_NONE,
group_depth: 0,
},
data_ptr: storage_ptr + 16,
data_size: PPC_Q3_TRIMESH_DATA_SIZE + 8,
}
);
assert_eq!(
loaded.q3_group_memberships,
vec![PpcQ3GroupMembershipRecord {
group: container,
object: child_trimesh,
before: None,
}]
);
assert_eq!(
loaded
.q3_trimeshes
.iter()
.find(|record| record.trimesh == container)
.map(|record| record.data.as_slice()),
Some(trimesh_body.as_slice())
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectIsType;
loaded.cpu.gpr[3] = container;
loaded.cpu.gpr[4] = PPC_Q3_TYPE_TRIMESH;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshGetData;
loaded.cpu.gpr[3] = container;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded
.memory
.read_u32_be(output_ptr + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET),
Some(3)
);
}
#[test]
fn hle_import_runner_keeps_grouped_q3_file_container_trimesh_wrapped() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let display_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let child_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let output_ptr = PPC_DATA_BASE + 0x2000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let mut trimesh_body = vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize];
trimesh_body[PPC_Q3_TRIMESH_NUM_POINTS_OFFSET as usize
..PPC_Q3_TRIMESH_NUM_POINTS_OFFSET as usize + 4]
.copy_from_slice(&3u32.to_be_bytes());
let container_body_size = 8 + PPC_Q3_TRIMESH_DATA_SIZE;
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"bgng");
storage_bytes.extend_from_slice(&8u32.to_be_bytes());
storage_bytes.extend_from_slice(b"dspg");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&container_body_size.to_be_bytes());
storage_bytes.extend_from_slice(b"tmsh");
storage_bytes.extend_from_slice(&PPC_Q3_TRIMESH_DATA_SIZE.to_be_bytes());
storage_bytes.extend_from_slice(&trimesh_body);
storage_bytes.extend_from_slice(b"endg");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded
.memory
.add_region(output_ptr, vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = container;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], container);
assert_eq!(
loaded.q3_objects[2],
PpcQ3ObjectRecord {
object: container,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource {
file,
offset: 24,
parent_group_type: u32::from_be_bytes(*b"dspg"),
group_depth: 1,
},
data_ptr: storage_ptr + 24,
data_size: container_body_size + 8,
}
);
assert_eq!(
loaded.q3_file_groups,
vec![PpcQ3FileGroupRecord {
file,
offset: 8,
group: display_group,
group_type: u32::from_be_bytes(*b"dspg"),
parent_group: 0,
group_depth: 1,
}]
);
assert_eq!(
loaded.q3_group_memberships,
vec![
PpcQ3GroupMembershipRecord {
group: display_group,
object: container,
before: None,
},
PpcQ3GroupMembershipRecord {
group: container,
object: child_trimesh,
before: None,
},
PpcQ3GroupMembershipRecord {
group: display_group,
object: child_trimesh,
before: None,
},
]
);
assert_eq!(
loaded
.q3_trimeshes
.iter()
.find(|record| record.trimesh == child_trimesh)
.map(|record| record.data.as_slice()),
Some(trimesh_body.as_slice())
);
assert!(loaded
.q3_trimeshes
.iter()
.all(|record| record.trimesh != container));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectIsType;
loaded.cpu.gpr[3] = container;
loaded.cpu.gpr[4] = PPC_Q3_TYPE_TRIMESH;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshGetData;
loaded.cpu.gpr[3] = container;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn front_window_uses_the_process_order_without_native_gworld_metadata() {
let pef = synthetic_pef_with_import(b"FrontWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let back = PPC_DATA_BASE + 0x1000;
let front = back + 0x200;
loaded.memory.add_region(back, vec![0; 0x400]);
loaded
.memory
.write_u8(back + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u8(front + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded.window_list.extend([front, back]);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], front);
loaded.window_list.swap(0, 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], back);
}
#[test]
fn close_window_removes_process_membership_without_native_gworld_metadata() {
let pef = synthetic_pef_with_import(b"CloseWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let window = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(window, vec![0; 0x200]);
loaded
.memory
.write_u8(window + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded.window_list.push(window);
loaded.cpu.gpr[3] = window;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert!(loaded.window_list.is_empty());
assert_eq!(loaded.memory.read_u32_be(0x09D6), Some(0));
}
#[test]
fn hle_import_runner_reads_q3_file_matrix_transform_body_data() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let transform = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let output_ptr = PPC_DATA_BASE + 0x2000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let mut matrix = ppc_q3_matrix4x4_identity();
matrix[3][0] = 7.0;
matrix[3][1] = 8.0;
matrix[3][2] = 9.0;
let mut matrix_body = Vec::with_capacity(64);
for row in matrix {
for value in row {
matrix_body.extend_from_slice(&value.to_bits().to_be_bytes());
}
}
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"mtrx");
storage_bytes.extend_from_slice(&64u32.to_be_bytes());
storage_bytes.extend_from_slice(&matrix_body);
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded.memory.add_region(output_ptr, vec![0; 64]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = transform;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], transform);
assert_eq!(
loaded.q3_objects[2],
PpcQ3ObjectRecord {
object: transform,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TRANSFORM_TYPE_MATRIX,
source: PpcQ3ObjectSource {
file,
offset: 8,
parent_group_type: PPC_Q3_TYPE_NONE,
group_depth: 0,
},
data_ptr: storage_ptr + 8,
data_size: 72,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TransformGetMatrix;
loaded.cpu.gpr[3] = transform;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_matrix4x4(&mut loaded.memory, output_ptr).unwrap(),
matrix
);
}
#[test]
fn hle_import_runner_reads_q3_file_style_chunks() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let fill_style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let interpolation_style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let backfacing_style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let style_chunk_size = 8u32 + 4;
let container_body_size = style_chunk_size * 3;
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&container_body_size.to_be_bytes());
storage_bytes.extend_from_slice(b"fist");
storage_bytes.extend_from_slice(&4u32.to_be_bytes());
storage_bytes.extend_from_slice(&PPC_Q3_FILL_STYLE_EDGES.to_be_bytes());
storage_bytes.extend_from_slice(b"intp");
storage_bytes.extend_from_slice(&4u32.to_be_bytes());
storage_bytes.extend_from_slice(&PPC_Q3_INTERPOLATION_STYLE_VERTEX.to_be_bytes());
storage_bytes.extend_from_slice(b"bckf");
storage_bytes.extend_from_slice(&4u32.to_be_bytes());
storage_bytes.extend_from_slice(&PPC_Q3_BACKFACING_STYLE_FLIP.to_be_bytes());
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = container;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], container);
assert_eq!(
loaded.q3_group_memberships,
vec![
PpcQ3GroupMembershipRecord {
group: container,
object: fill_style,
before: None,
},
PpcQ3GroupMembershipRecord {
group: container,
object: interpolation_style,
before: None,
},
PpcQ3GroupMembershipRecord {
group: container,
object: backfacing_style,
before: None,
},
]
);
assert_eq!(
loaded.q3_styles,
vec![
PpcQ3StyleRecord {
style: fill_style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
},
PpcQ3StyleRecord {
style: interpolation_style,
kind: PpcQ3StyleKind::Interpolation,
value: PPC_Q3_INTERPOLATION_STYLE_VERTEX,
},
PpcQ3StyleRecord {
style: backfacing_style,
kind: PpcQ3StyleKind::Backfacing,
value: PPC_Q3_BACKFACING_STYLE_FLIP,
},
PpcQ3StyleRecord {
style: container,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
},
]
);
}
#[test]
fn hle_import_runner_reads_q3_file_texture_shader_container_state() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let view = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let texture_out_ptr = PPC_DATA_BASE + 0x3000;
let mipmap_out_ptr = PPC_DATA_BASE + 0x3100;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let mipmap: Vec<u8> = (0..PPC_Q3_MIPMAP_COPY_SIZE + 12)
.map(|offset| 0x30u8.wrapping_add(offset as u8))
.collect();
let container_body_size = 8 + 8 + mipmap.len() as u32;
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&container_body_size.to_be_bytes());
storage_bytes.extend_from_slice(b"txsu");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"txmm");
storage_bytes.extend_from_slice(&(mipmap.len() as u32).to_be_bytes());
storage_bytes.extend_from_slice(&mipmap);
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded.memory.add_region(texture_out_ptr, vec![0; 4]);
loaded
.memory
.add_region(mipmap_out_ptr, vec![0; mipmap.len()]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = container;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], container);
assert_eq!(loaded.q3_files[0].read_offset, storage_bytes.len() as u32);
assert_eq!(
loaded.q3_objects[2],
PpcQ3ObjectRecord {
object: container,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
source: PpcQ3ObjectSource {
file,
offset: 8,
parent_group_type: PPC_Q3_TYPE_NONE,
group_depth: 0,
},
data_ptr: storage_ptr + 16,
data_size: 8,
}
);
assert_eq!(
loaded.q3_objects[3],
PpcQ3ObjectRecord {
object: shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
source: PpcQ3ObjectSource {
file,
offset: 16,
parent_group_type: PPC_Q3_TYPE_CONTAINER,
group_depth: 1,
},
data_ptr: storage_ptr + 16,
data_size: 8,
}
);
assert_eq!(
loaded.q3_objects[4],
PpcQ3ObjectRecord {
object: texture,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource {
file,
offset: 24,
parent_group_type: PPC_Q3_TYPE_CONTAINER,
group_depth: 1,
},
data_ptr: storage_ptr + 24,
data_size: mipmap.len() as u32 + 8,
}
);
assert_eq!(
loaded.q3_group_memberships,
vec![
PpcQ3GroupMembershipRecord {
group: container,
object: shader,
before: None,
},
PpcQ3GroupMembershipRecord {
group: container,
object: texture,
before: None,
},
]
);
assert_eq!(
loaded.q3_texture_shaders,
vec![
PpcQ3TextureShaderRecord { shader, texture },
PpcQ3TextureShaderRecord {
shader: container,
texture,
},
]
);
assert_eq!(
loaded.q3_mipmap_textures,
vec![PpcQ3MipmapTextureRecord {
texture,
mipmap: mipmap.clone(),
}]
);
loaded.memory.write_u8(storage_ptr + 32, 0xff).unwrap();
assert_eq!(loaded.q3_mipmap_textures[0].mipmap[0], mipmap[0]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TextureShaderGetTexture;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = texture_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(texture_out_ptr), Some(texture));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MipmapTextureGetMipmap;
loaded.cpu.gpr[3] = texture;
loaded.cpu.gpr[4] = mipmap_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u8(mipmap_out_ptr), Some(mipmap[0]));
assert_eq!(
loaded
.memory
.read_u8(mipmap_out_ptr + u32::try_from(mipmap.len()).unwrap() - 1),
Some(*mipmap.last().unwrap())
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderSubmit;
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submission_materials,
vec![PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::Shader,
primary: shader,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: Some(PpcQ3TextureShaderRecord { shader, texture }),
mipmap_texture: Some(PpcQ3MipmapTextureRecord {
texture,
mipmap: mipmap.clone(),
}),
}]
);
loaded.q3_mipmap_textures[0].mipmap[0] = 0xaa;
assert_eq!(
loaded.q3_submission_materials[0]
.mipmap_texture
.as_ref()
.map(|record| record.mipmap.as_slice()),
Some(mipmap.as_slice())
);
}
#[test]
fn hle_import_runner_reads_nested_q3_file_texture_shader_container_state() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let outer_container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let attribute = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let inner_container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let mipmap = vec![0x11, 0x22, 0x33, 0x44, 0x55];
let inner_body_size = 8 + 8 + mipmap.len() as u32;
let outer_body_size = 8 + 8 + inner_body_size;
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&outer_body_size.to_be_bytes());
storage_bytes.extend_from_slice(b"attr");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&inner_body_size.to_be_bytes());
storage_bytes.extend_from_slice(b"txsu");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"txmm");
storage_bytes.extend_from_slice(&(mipmap.len() as u32).to_be_bytes());
storage_bytes.extend_from_slice(&mipmap);
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = outer_container;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], outer_container);
assert_eq!(
loaded.q3_objects[3],
PpcQ3ObjectRecord {
object: attribute,
kind: PpcQ3ObjectKind::Generic,
object_type: u32::from_be_bytes(*b"attr"),
source: PpcQ3ObjectSource {
file,
offset: 16,
parent_group_type: PPC_Q3_TYPE_CONTAINER,
group_depth: 1,
},
data_ptr: storage_ptr + 16,
data_size: 8,
}
);
assert_eq!(
loaded.q3_group_memberships,
vec![
PpcQ3GroupMembershipRecord {
group: outer_container,
object: attribute,
before: None,
},
PpcQ3GroupMembershipRecord {
group: outer_container,
object: inner_container,
before: None,
},
PpcQ3GroupMembershipRecord {
group: inner_container,
object: shader,
before: None,
},
PpcQ3GroupMembershipRecord {
group: inner_container,
object: texture,
before: None,
},
]
);
assert_eq!(
loaded.q3_texture_shaders,
vec![PpcQ3TextureShaderRecord { shader, texture }]
);
assert_eq!(
loaded.q3_attributes,
vec![
PpcQ3AttributeRecord {
attribute_set: attribute,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER,
data: shader.to_be_bytes().to_vec(),
},
PpcQ3AttributeRecord {
attribute_set: outer_container,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER,
data: shader.to_be_bytes().to_vec(),
},
]
);
assert_eq!(
loaded.q3_mipmap_textures,
vec![PpcQ3MipmapTextureRecord { texture, mipmap }]
);
}
#[test]
fn hle_import_runner_reads_q3_file_attribute_material_state() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let attribute = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let diffuse_chunk = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let ambient_chunk = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let specular_color_chunk = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6;
let specular_control_chunk = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 7;
let transparency_chunk = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 8;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let output_ptr = PPC_DATA_BASE + 0x3000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let diffuse = vec![
0x3d, 0xcc, 0xcc, 0xcd, 0x3e, 0x4c, 0xcc, 0xcd, 0x3e, 0x99, 0x99, 0x9a,
];
let transparency = vec![
0x3e, 0xcc, 0xcc, 0xcd, 0x3f, 0x00, 0x00, 0x00, 0x3f, 0x19, 0x99, 0x9a,
];
let ambient_coefficient = 0.5f32.to_bits().to_be_bytes().to_vec();
let specular_color = vec![
0x3f, 0x00, 0x00, 0x00, 0x3f, 0x19, 0x99, 0x9a, 0x3f, 0x33, 0x33, 0x33,
];
let specular_control = 60.0f32.to_bits().to_be_bytes().to_vec();
let container_body_size = 8
+ 8
+ diffuse.len() as u32
+ 8
+ ambient_coefficient.len() as u32
+ 8
+ specular_color.len() as u32
+ 8
+ specular_control.len() as u32
+ 8
+ transparency.len() as u32;
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&container_body_size.to_be_bytes());
storage_bytes.extend_from_slice(b"attr");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"kdif");
storage_bytes.extend_from_slice(&(diffuse.len() as u32).to_be_bytes());
storage_bytes.extend_from_slice(&diffuse);
storage_bytes.extend_from_slice(b"camb");
storage_bytes.extend_from_slice(&(ambient_coefficient.len() as u32).to_be_bytes());
storage_bytes.extend_from_slice(&ambient_coefficient);
storage_bytes.extend_from_slice(b"kspc");
storage_bytes.extend_from_slice(&(specular_color.len() as u32).to_be_bytes());
storage_bytes.extend_from_slice(&specular_color);
storage_bytes.extend_from_slice(b"cspc");
storage_bytes.extend_from_slice(&(specular_control.len() as u32).to_be_bytes());
storage_bytes.extend_from_slice(&specular_control);
storage_bytes.extend_from_slice(b"kxpr");
storage_bytes.extend_from_slice(&(transparency.len() as u32).to_be_bytes());
storage_bytes.extend_from_slice(&transparency);
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded.memory.add_region(output_ptr, vec![0; 16]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = container;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], container);
assert_eq!(loaded.q3_files[0].read_offset, storage_bytes.len() as u32);
assert_eq!(
loaded.q3_objects[3],
PpcQ3ObjectRecord {
object: attribute,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_ATTRIBUTE_SET,
source: PpcQ3ObjectSource {
file,
offset: 16,
parent_group_type: PPC_Q3_TYPE_CONTAINER,
group_depth: 1,
},
data_ptr: storage_ptr + 16,
data_size: 8,
}
);
assert_eq!(
loaded.q3_objects[4],
PpcQ3ObjectRecord {
object: diffuse_chunk,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR_3DMF,
source: PpcQ3ObjectSource {
file,
offset: 24,
parent_group_type: PPC_Q3_TYPE_CONTAINER,
group_depth: 1,
},
data_ptr: storage_ptr + 24,
data_size: 20,
}
);
assert_eq!(
loaded.q3_objects[5],
PpcQ3ObjectRecord {
object: ambient_chunk,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT_3DMF,
source: PpcQ3ObjectSource {
file,
offset: 44,
parent_group_type: PPC_Q3_TYPE_CONTAINER,
group_depth: 1,
},
data_ptr: storage_ptr + 44,
data_size: 12,
}
);
assert_eq!(
loaded.q3_objects[6],
PpcQ3ObjectRecord {
object: specular_color_chunk,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR_3DMF,
source: PpcQ3ObjectSource {
file,
offset: 56,
parent_group_type: PPC_Q3_TYPE_CONTAINER,
group_depth: 1,
},
data_ptr: storage_ptr + 56,
data_size: 20,
}
);
assert_eq!(
loaded.q3_objects[7],
PpcQ3ObjectRecord {
object: specular_control_chunk,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL_3DMF,
source: PpcQ3ObjectSource {
file,
offset: 76,
parent_group_type: PPC_Q3_TYPE_CONTAINER,
group_depth: 1,
},
data_ptr: storage_ptr + 76,
data_size: 12,
}
);
assert_eq!(
loaded.q3_objects[8],
PpcQ3ObjectRecord {
object: transparency_chunk,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR_3DMF,
source: PpcQ3ObjectSource {
file,
offset: 88,
parent_group_type: PPC_Q3_TYPE_CONTAINER,
group_depth: 1,
},
data_ptr: storage_ptr + 88,
data_size: 20,
}
);
assert_eq!(
loaded.q3_attributes,
vec![
PpcQ3AttributeRecord {
attribute_set: attribute,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse.clone(),
},
PpcQ3AttributeRecord {
attribute_set: attribute,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT,
data: ambient_coefficient.clone(),
},
PpcQ3AttributeRecord {
attribute_set: attribute,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
data: specular_color.clone(),
},
PpcQ3AttributeRecord {
attribute_set: attribute,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
data: specular_control.clone(),
},
PpcQ3AttributeRecord {
attribute_set: attribute,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
data: transparency.clone(),
},
PpcQ3AttributeRecord {
attribute_set: container,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse.clone(),
},
PpcQ3AttributeRecord {
attribute_set: container,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT,
data: ambient_coefficient.clone(),
},
PpcQ3AttributeRecord {
attribute_set: container,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
data: specular_color.clone(),
},
PpcQ3AttributeRecord {
attribute_set: container,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
data: specular_control.clone(),
},
PpcQ3AttributeRecord {
attribute_set: container,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
data: transparency.clone(),
},
]
);
loaded.memory.write_u8(storage_ptr + 32, 0xff).unwrap();
assert_eq!(loaded.q3_attributes[0].data, diffuse);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetGet;
loaded.cpu.gpr[3] = attribute;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR;
loaded.cpu.gpr[5] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
for offset in 0..12 {
assert_eq!(
loaded.memory.read_u8(output_ptr + offset),
Some(diffuse[offset as usize])
);
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = attribute;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT;
loaded.cpu.gpr[5] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
for offset in 0..4 {
assert_eq!(
loaded.memory.read_u8(output_ptr + offset),
Some(ambient_coefficient[offset as usize])
);
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = attribute;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR;
loaded.cpu.gpr[5] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
for offset in 0..12 {
assert_eq!(
loaded.memory.read_u8(output_ptr + offset),
Some(specular_color[offset as usize])
);
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = attribute;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL;
loaded.cpu.gpr[5] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
for offset in 0..4 {
assert_eq!(
loaded.memory.read_u8(output_ptr + offset),
Some(specular_control[offset as usize])
);
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = attribute;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR;
loaded.cpu.gpr[5] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
for offset in 0..12 {
assert_eq!(
loaded.memory.read_u8(output_ptr + offset),
Some(transparency[offset as usize])
);
}
}
#[test]
fn hle_import_runner_resolves_q3_file_shared_attribute_references() {
let file = PPC_Q3_OBJECT_BASE;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let shared_container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let nested_container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let shared_attribute = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let geometry_container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6;
let child_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 7;
let storage_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3File_ReadObject");
let mut loaded = load_pef_application(&pef).unwrap();
let diffuse = [
1.0f32.to_bits().to_be_bytes(),
0.0f32.to_bits().to_be_bytes(),
0.0f32.to_bits().to_be_bytes(),
]
.concat();
let mut shared_attribute_body = Vec::new();
shared_attribute_body.extend_from_slice(b"attr");
shared_attribute_body.extend_from_slice(&0u32.to_be_bytes());
shared_attribute_body.extend_from_slice(b"kdif");
shared_attribute_body.extend_from_slice(&(diffuse.len() as u32).to_be_bytes());
shared_attribute_body.extend_from_slice(&diffuse);
let mut shared_container_body = Vec::new();
shared_container_body.extend_from_slice(b"cntr");
shared_container_body
.extend_from_slice(&(shared_attribute_body.len() as u32).to_be_bytes());
shared_container_body.extend_from_slice(&shared_attribute_body);
let mut storage_bytes = Vec::new();
storage_bytes.extend_from_slice(b"3DMF");
storage_bytes.extend_from_slice(&0u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&(shared_container_body.len() as u32).to_be_bytes());
let shared_attribute_offset = u32::try_from(storage_bytes.len()).unwrap();
storage_bytes.extend_from_slice(&shared_container_body);
let mut geometry_body = Vec::new();
geometry_body.extend_from_slice(b"tmsh");
geometry_body.extend_from_slice(&PPC_Q3_TRIMESH_DATA_SIZE.to_be_bytes());
geometry_body.extend_from_slice(&vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize]);
geometry_body.extend_from_slice(b"rfrn");
geometry_body.extend_from_slice(&4u32.to_be_bytes());
geometry_body.extend_from_slice(&1u32.to_be_bytes());
storage_bytes.extend_from_slice(b"cntr");
storage_bytes.extend_from_slice(&(geometry_body.len() as u32).to_be_bytes());
storage_bytes.extend_from_slice(&geometry_body);
storage_bytes.extend_from_slice(b"toc ");
storage_bytes.extend_from_slice(&44u32.to_be_bytes());
storage_bytes.extend_from_slice(&0u64.to_be_bytes());
storage_bytes.extend_from_slice(&2u32.to_be_bytes());
storage_bytes.extend_from_slice(&u32::MAX.to_be_bytes());
storage_bytes.extend_from_slice(&1u32.to_be_bytes());
storage_bytes.extend_from_slice(&16u32.to_be_bytes());
storage_bytes.extend_from_slice(&1u32.to_be_bytes());
storage_bytes.extend_from_slice(&1u32.to_be_bytes());
storage_bytes.extend_from_slice(&(u64::from(shared_attribute_offset)).to_be_bytes());
storage_bytes.extend_from_slice(&PPC_Q3_TYPE_ATTRIBUTE_SET.to_be_bytes());
loaded.memory.add_region(storage_ptr, storage_bytes.clone());
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: storage,
kind: PpcQ3ObjectKind::MemoryStorage,
object_type: PPC_Q3_STORAGE_TYPE_MEMORY,
source: PpcQ3ObjectSource::default(),
data_ptr: storage_ptr,
data_size: storage_bytes.len() as u32,
});
loaded
.q3_objects
.push(test_q3_object(file, PPC_Q3_TYPE_FILE));
loaded.next_q3_object = shared_container;
loaded.q3_files.push(PpcQ3FileRecord {
file,
storage,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: 0,
});
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], shared_container);
assert_eq!(
ppc_q3_object_type_for_handle(&loaded.q3_objects, nested_container),
PPC_Q3_TYPE_CONTAINER
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = file;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], geometry_container);
assert_eq!(
loaded
.q3_trimeshes
.iter()
.find(|record| record.trimesh == child_trimesh)
.and_then(|record| ppc_q3_trimesh_header_u32(
&record.data,
PPC_Q3_TRIMESH_ATTRIBUTE_SET_OFFSET,
)),
Some(shared_attribute)
);
assert!(loaded.q3_attributes.iter().any(|record| {
record.attribute_set == shared_attribute
&& record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR
&& record.data == diffuse
}));
}
#[test]
fn hle_import_runner_tracks_q3_group_membership() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Group_AddObject");
let mut loaded = load_pef_application(&pef).unwrap();
let group = PPC_Q3_OBJECT_BASE;
let first_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let second_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let before_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let rejected_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
loaded.q3_objects.extend([
PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: first_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: second_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: before_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: rejected_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
]);
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = first_object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3GroupAddObject),
1
);
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = second_object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3GroupAddObject),
2
);
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = before_object;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3GroupAddObjectBefore
),
2
);
assert_eq!(
loaded.q3_group_memberships,
vec![
PpcQ3GroupMembershipRecord {
group,
object: first_object,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: before_object,
before: Some(2),
},
PpcQ3GroupMembershipRecord {
group,
object: second_object,
before: None,
},
]
);
for object in [first_object, second_object, before_object] {
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, object),
Some(2)
);
}
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = 99;
loaded.cpu.gpr[5] = rejected_object;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3GroupAddObjectBefore
),
0
);
assert_eq!(loaded.q3_group_memberships.len(), 3);
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
rejected_object
),
Some(1)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_handles_q3_light_group_object_state() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3LightGroup_New");
let mut loaded = load_pef_application(&pef).unwrap();
let light_group = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3LightGroupNew);
assert_eq!(light_group, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_GROUP_TYPE_LIGHT);
assert_eq!(loaded.q3_objects[0].data_size, 0);
loaded.cpu.gpr[3] = light_group;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectGetType),
PPC_Q3_GROUP_TYPE_LIGHT
);
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let non_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let object_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(object_out_ptr, vec![0xaa; 4]);
loaded.q3_lights.push(PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.5,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Ambient,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: ambient_light,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_LIGHT_DATA_SIZE,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: non_light,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
let view = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: view,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_VIEW,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = light_group;
loaded.cpu.gpr[4] = ambient_light;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3GroupAddObject),
1
);
assert_eq!(
loaded.q3_group_memberships,
vec![PpcQ3GroupMembershipRecord {
group: light_group,
object: ambient_light,
before: None,
}]
);
loaded.cpu.gpr[3] = light_group;
loaded.cpu.gpr[4] = non_light;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3GroupAddObject),
0
);
assert_eq!(loaded.q3_group_memberships.len(), 1);
loaded
.memory
.write_u32_be(object_out_ptr, 0xeeee_eeee)
.unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.q3_group_memberships[0].object = non_light;
loaded.cpu.gpr[3] = light_group;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = object_out_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3GroupGetPositionObject
),
0
);
assert_eq!(loaded.memory.read_u32_be(object_out_ptr), Some(0xeeee_eeee));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, non_light),
Some(1)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_group_memberships[0].object = ambient_light;
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = light_group;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetLightGroup),
1
);
assert_eq!(loaded.q3_views[0].light_group, light_group);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = non_light;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetLightGroup),
0
);
assert_eq!(loaded.q3_views[0].light_group, light_group);
}
#[test]
fn hle_import_runner_retains_q3_view_light_group_until_view_dispose() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_SetLightGroup");
let mut loaded = load_pef_application(&pef).unwrap();
let view = PPC_Q3_OBJECT_BASE;
let light_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: view,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_VIEW,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: light_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_LIGHT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = light_group;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetLightGroup),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, light_group),
Some(2)
);
loaded.cpu.gpr[3] = light_group;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(ppc_q3_object_exists(&loaded.q3_objects, light_group));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, light_group),
Some(1)
);
assert_eq!(loaded.q3_views[0].light_group, light_group);
loaded.cpu.gpr[3] = view;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(loaded.q3_objects.is_empty());
assert!(loaded.q3_object_refs.is_empty());
assert!(loaded.q3_views.is_empty());
}
#[test]
fn hle_import_runner_retains_q3_view_owned_slots_until_view_dispose() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_SetRenderer");
let mut loaded = load_pef_application(&pef).unwrap();
let view = PPC_Q3_OBJECT_BASE;
let renderer = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let draw_context = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let camera = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let replacement_renderer = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let light_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
loaded.q3_objects.extend([
PpcQ3ObjectRecord {
object: view,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_VIEW,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: renderer,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_RENDERER_TYPE_INTERACTIVE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: draw_context,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_PIXMAP_DRAW_CONTEXT_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: camera,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_VIEW_ANGLE_ASPECT_CAMERA_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: replacement_renderer,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_RENDERER_TYPE_INTERACTIVE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: light_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_LIGHT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
]);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetRenderer),
1
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = draw_context;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetDrawContext),
1
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = camera;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetCamera),
1
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = light_group;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetLightGroup),
1
);
assert_eq!(loaded.q3_views[0].renderer, renderer);
assert_eq!(loaded.q3_views[0].draw_context, draw_context);
assert_eq!(loaded.q3_views[0].camera, camera);
assert_eq!(loaded.q3_views[0].light_group, light_group);
for object in [renderer, draw_context, camera, light_group] {
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, object),
Some(2)
);
}
let renderer_out_ptr = PPC_DATA_BASE + 0x1000;
let draw_context_out_ptr = renderer_out_ptr + 4;
let camera_out_ptr = renderer_out_ptr + 8;
let light_group_out_ptr = renderer_out_ptr + 12;
loaded.memory.add_region(renderer_out_ptr, vec![0; 16]);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer_out_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewGetRenderer),
1
);
assert_eq!(loaded.memory.read_u32_be(renderer_out_ptr), Some(renderer));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, renderer),
Some(3)
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = draw_context_out_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewGetDrawContext),
1
);
assert_eq!(
loaded.memory.read_u32_be(draw_context_out_ptr),
Some(draw_context)
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, draw_context),
Some(3)
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = camera_out_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewGetCamera),
1
);
assert_eq!(loaded.memory.read_u32_be(camera_out_ptr), Some(camera));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, camera),
Some(3)
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = light_group_out_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewGetLightGroup),
1
);
assert_eq!(
loaded.memory.read_u32_be(light_group_out_ptr),
Some(light_group)
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, light_group),
Some(3)
);
loaded.cpu.gpr[3] = renderer;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, renderer),
Some(2)
);
for object in [draw_context, camera, light_group] {
loaded.cpu.gpr[3] = object;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, object),
Some(2)
);
}
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = camera;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetRenderer),
0
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetDrawContext),
0
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = draw_context;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetCamera),
0
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetLightGroup),
0
);
assert_eq!(loaded.q3_views[0].renderer, renderer);
assert_eq!(loaded.q3_views[0].draw_context, draw_context);
assert_eq!(loaded.q3_views[0].camera, camera);
assert_eq!(loaded.q3_views[0].light_group, light_group);
loaded
.memory
.write_u32_be(renderer_out_ptr, 0xeeee_eeee)
.unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.q3_views[0].renderer = camera;
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer_out_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewGetRenderer),
0
);
assert_eq!(
loaded.memory.read_u32_be(renderer_out_ptr),
Some(0xeeee_eeee)
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, camera),
Some(2)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_views[0].renderer = renderer;
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = replacement_renderer;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetRenderer),
1
);
assert_eq!(loaded.q3_views[0].renderer, replacement_renderer);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, renderer),
Some(1)
);
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
replacement_renderer
),
Some(2)
);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ViewSetRenderer),
1
);
assert_eq!(loaded.q3_views[0].renderer, renderer);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, renderer),
Some(2)
);
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
replacement_renderer
),
Some(1)
);
loaded.cpu.gpr[3] = renderer;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(ppc_q3_object_exists(&loaded.q3_objects, renderer));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, renderer),
Some(1)
);
assert_eq!(loaded.q3_views[0].renderer, renderer);
loaded.cpu.gpr[3] = view;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(!ppc_q3_object_exists(&loaded.q3_objects, view));
assert!(!ppc_q3_object_exists(&loaded.q3_objects, renderer));
assert!(ppc_q3_object_exists(&loaded.q3_objects, draw_context));
assert!(ppc_q3_object_exists(&loaded.q3_objects, camera));
assert!(ppc_q3_object_exists(&loaded.q3_objects, light_group));
assert!(loaded.q3_views.is_empty());
assert!(loaded.q3_object_refs.is_empty());
}
#[test]
fn hle_import_runner_retains_q3_light_group_members_until_group_dispose() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Group_AddObject");
let mut loaded = load_pef_application(&pef).unwrap();
let light_group = PPC_Q3_OBJECT_BASE;
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: light_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_LIGHT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: ambient_light,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_LIGHT_DATA_SIZE,
});
loaded.q3_lights.push(PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.5,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Ambient,
});
loaded.cpu.gpr[3] = light_group;
loaded.cpu.gpr[4] = ambient_light;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3GroupAddObject),
1
);
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
ambient_light
),
Some(2)
);
loaded.cpu.gpr[3] = ambient_light;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(ppc_q3_object_exists(&loaded.q3_objects, ambient_light));
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
ambient_light
),
Some(1)
);
assert_eq!(loaded.q3_group_memberships.len(), 1);
loaded.cpu.gpr[3] = light_group;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(loaded.q3_objects.is_empty());
assert!(loaded.q3_object_refs.is_empty());
assert!(loaded.q3_group_memberships.is_empty());
assert!(loaded.q3_lights.is_empty());
}
#[test]
fn hle_import_runner_releases_q3_group_member_on_position_remove() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Group_AddObject");
let mut loaded = load_pef_application(&pef).unwrap();
let light_group = PPC_Q3_OBJECT_BASE;
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: light_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_LIGHT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: ambient_light,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_LIGHT_DATA_SIZE,
});
loaded.q3_lights.push(PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.5,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Ambient,
});
loaded.cpu.gpr[3] = light_group;
loaded.cpu.gpr[4] = ambient_light;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3GroupAddObject),
1
);
loaded.cpu.gpr[3] = ambient_light;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
loaded.cpu.gpr[3] = light_group;
loaded.cpu.gpr[4] = 1;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3GroupRemovePosition
),
1
);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].object, light_group);
assert!(loaded.q3_object_refs.is_empty());
assert!(loaded.q3_group_memberships.is_empty());
assert!(loaded.q3_lights.is_empty());
}
#[test]
fn hle_import_runner_handles_q3_group_position_queries() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Group_CountObjects");
let mut loaded = load_pef_application(&pef).unwrap();
let group = PPC_Q3_OBJECT_BASE;
let container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let count_out_ptr = scratch_ptr;
let position_out_ptr = scratch_ptr + 4;
let object_out_ptr = scratch_ptr + 8;
loaded.memory.add_region(scratch_ptr, vec![0xaa; 12]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: container,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: container,
before: None,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: trimesh,
before: None,
});
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = count_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(count_out_ptr), Some(2));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupGetFirstPosition;
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = position_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(position_out_ptr), Some(1));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupGetPositionObject;
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = object_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(object_out_ptr), Some(container));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, container),
Some(2)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupGetNextPosition;
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = position_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(position_out_ptr), Some(2));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3GroupGetFirstPositionOfType;
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = PPC_Q3_TYPE_TRIMESH;
loaded.cpu.gpr[5] = position_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(position_out_ptr), Some(2));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3GroupGetFirstPositionOfType;
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = PPC_Q3_SHAPE_TYPE_GEOMETRY;
loaded.cpu.gpr[5] = position_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(position_out_ptr), Some(2));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupGetPositionObject;
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = object_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(object_out_ptr), Some(trimesh));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, trimesh),
Some(2)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupRemovePosition;
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_group_memberships,
vec![PpcQ3GroupMembershipRecord {
group,
object: container,
before: None,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupCountObjects;
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = count_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(count_out_ptr), Some(1));
loaded
.memory
.write_u32_be(object_out_ptr, 0xeeee_eeee)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupGetPositionObject;
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = 99;
loaded.cpu.gpr[5] = object_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(object_out_ptr), Some(0xeeee_eeee));
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_uses_group_local_q3_positions() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Group_GetFirstPosition");
let mut loaded = load_pef_application(&pef).unwrap();
let parent_group = PPC_Q3_OBJECT_BASE;
let other_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let other_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let first_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let second_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let position_out_ptr = PPC_DATA_BASE + 0x1000;
let object_out_ptr = PPC_DATA_BASE + 0x1004;
loaded.memory.add_region(position_out_ptr, vec![0xaa; 8]);
loaded.q3_objects.extend([
PpcQ3ObjectRecord {
object: parent_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: other_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: other_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: first_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: second_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
]);
loaded.q3_group_memberships.extend([
PpcQ3GroupMembershipRecord {
group: other_group,
object: other_object,
before: None,
},
PpcQ3GroupMembershipRecord {
group: parent_group,
object: first_object,
before: None,
},
PpcQ3GroupMembershipRecord {
group: parent_group,
object: second_object,
before: None,
},
]);
loaded.cpu.gpr[3] = parent_group;
loaded.cpu.gpr[4] = position_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(position_out_ptr), Some(1));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupGetNextPosition;
loaded.cpu.gpr[3] = parent_group;
loaded.cpu.gpr[4] = position_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(position_out_ptr), Some(2));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupRemovePosition;
loaded.cpu.gpr[3] = other_group;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3GroupGetPositionObject;
loaded.cpu.gpr[3] = parent_group;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = object_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(object_out_ptr),
Some(second_object)
);
}
#[test]
fn q3_file_container_geometry_is_mirrored_into_parent_group() {
let group = PPC_Q3_OBJECT_BASE;
let matrix = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let nested_container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let nested_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let mut q3_group_memberships = vec![
PpcQ3GroupMembershipRecord {
group,
object: matrix,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: container,
before: None,
},
PpcQ3GroupMembershipRecord {
group: container,
object: trimesh,
before: None,
},
PpcQ3GroupMembershipRecord {
group: container,
object: nested_container,
before: None,
},
PpcQ3GroupMembershipRecord {
group: nested_container,
object: nested_trimesh,
before: None,
},
];
let q3_objects = vec![
PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: matrix,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TRANSFORM_TYPE_MATRIX,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: container,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: nested_container,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: nested_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
];
assert_eq!(
ppc_q3_group_visible_objects(&q3_group_memberships, &q3_objects, group),
vec![matrix, container, trimesh, nested_trimesh]
);
ppc_q3_file_mirror_container_geometry_into_group(
&mut q3_group_memberships,
&q3_objects,
group,
container,
);
assert_eq!(
q3_group_memberships
.iter()
.filter(|record| record.group == group)
.map(|record| record.object)
.collect::<Vec<_>>(),
vec![matrix, container, trimesh, nested_trimesh]
);
ppc_q3_file_mirror_container_geometry_into_group(
&mut q3_group_memberships,
&q3_objects,
group,
container,
);
assert_eq!(
q3_group_memberships
.iter()
.filter(|record| record.group == group)
.map(|record| record.object)
.collect::<Vec<_>>(),
vec![matrix, container, trimesh, nested_trimesh]
);
assert_eq!(
ppc_q3_group_visible_objects(&q3_group_memberships, &q3_objects, group),
vec![matrix, container, trimesh, nested_trimesh]
);
}
#[test]
fn q3_group_positions_for_loaded_object_lists_stay_direct() {
let group = PPC_Q3_OBJECT_BASE;
let first_container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let first_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let second_container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let second_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let third_container = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let third_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6;
let q3_group_memberships = vec![
PpcQ3GroupMembershipRecord {
group,
object: first_container,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: second_container,
before: None,
},
PpcQ3GroupMembershipRecord {
group: first_container,
object: first_trimesh,
before: None,
},
PpcQ3GroupMembershipRecord {
group: second_container,
object: second_trimesh,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: third_container,
before: None,
},
PpcQ3GroupMembershipRecord {
group: third_container,
object: third_trimesh,
before: None,
},
];
let file_source = PpcQ3ObjectSource {
file: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 7,
offset: 0,
parent_group_type: PPC_Q3_TYPE_NONE,
group_depth: 1,
};
let q3_objects = vec![
PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: first_container,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: file_source,
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: first_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: file_source,
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: second_container,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: file_source,
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: second_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: file_source,
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: third_container,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: file_source,
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: third_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: file_source,
data_ptr: 0,
data_size: 0,
},
];
assert_eq!(
ppc_q3_group_position_objects(&q3_group_memberships, &q3_objects, &[], group),
vec![first_container, second_container, third_container]
);
assert_eq!(
ppc_q3_group_visible_object_for_position(
&q3_group_memberships,
&q3_objects,
&[],
group,
1
),
Some(first_container)
);
assert_eq!(
ppc_q3_group_visible_object_for_position(
&q3_group_memberships,
&q3_objects,
&[],
group,
2
),
Some(second_container)
);
assert_eq!(
ppc_q3_group_visible_object_for_position(
&q3_group_memberships,
&q3_objects,
&[],
group,
3
),
Some(third_container)
);
assert_eq!(
ppc_q3_group_visible_objects(&q3_group_memberships, &q3_objects, group),
vec![
first_container,
first_trimesh,
second_container,
second_trimesh,
third_container,
third_trimesh
]
);
}
#[test]
fn q3_group_positions_for_grouped_3dmf_model_lists_use_top_level_groups() {
let group = PPC_Q3_OBJECT_BASE;
let first_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let first_a = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let first_b = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let second_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let second_a = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let second_b = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6;
let third_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 7;
let third_a = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 8;
let third_b = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 9;
let file = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 10;
let file_group_source = |offset| PpcQ3ObjectSource {
file,
offset,
parent_group_type: PPC_Q3_GROUP_TYPE_DISPLAY,
group_depth: 2,
};
let file_child_source = |offset| PpcQ3ObjectSource {
file,
offset,
parent_group_type: PPC_Q3_GROUP_TYPE_DISPLAY,
group_depth: 2,
};
let q3_group_memberships = vec![
PpcQ3GroupMembershipRecord {
group,
object: first_a,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: first_b,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: second_a,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: second_b,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: third_a,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: third_b,
before: None,
},
PpcQ3GroupMembershipRecord {
group: first_group,
object: first_a,
before: None,
},
PpcQ3GroupMembershipRecord {
group: first_group,
object: first_b,
before: None,
},
PpcQ3GroupMembershipRecord {
group: second_group,
object: second_a,
before: None,
},
PpcQ3GroupMembershipRecord {
group: second_group,
object: second_b,
before: None,
},
PpcQ3GroupMembershipRecord {
group: third_group,
object: third_a,
before: None,
},
PpcQ3GroupMembershipRecord {
group: third_group,
object: third_b,
before: None,
},
];
let q3_file_groups = vec![
PpcQ3FileGroupRecord {
file,
offset: 0x100,
group: first_group,
group_type: PPC_Q3_GROUP_TYPE_DISPLAY,
parent_group: 0,
group_depth: 2,
},
PpcQ3FileGroupRecord {
file,
offset: 0x500,
group: second_group,
group_type: PPC_Q3_GROUP_TYPE_DISPLAY,
parent_group: 0,
group_depth: 2,
},
PpcQ3FileGroupRecord {
file,
offset: 0x900,
group: third_group,
group_type: PPC_Q3_GROUP_TYPE_DISPLAY,
parent_group: 0,
group_depth: 2,
},
];
let q3_objects = vec![
PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: first_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: file_group_source(0x100),
data_ptr: 0,
data_size: 16,
},
PpcQ3ObjectRecord {
object: second_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: file_group_source(0x500),
data_ptr: 0,
data_size: 16,
},
PpcQ3ObjectRecord {
object: third_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: file_group_source(0x900),
data_ptr: 0,
data_size: 16,
},
PpcQ3ObjectRecord {
object: first_a,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: file_child_source(0x140),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: first_b,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: file_child_source(0x300),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: second_a,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: file_child_source(0x540),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: second_b,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: file_child_source(0x700),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: third_a,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: file_child_source(0x940),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: third_b,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: file_child_source(0xb00),
data_ptr: 0,
data_size: 0,
},
];
assert_eq!(
ppc_q3_group_position_objects(
&q3_group_memberships,
&q3_objects,
&q3_file_groups,
group
),
vec![first_group, second_group, third_group]
);
assert_eq!(
ppc_q3_group_visible_object_for_position(
&q3_group_memberships,
&q3_objects,
&q3_file_groups,
group,
3
),
Some(third_group)
);
assert_eq!(
ppc_q3_group_visible_objects(&q3_group_memberships, &q3_objects, group),
vec![first_a, first_b, second_a, second_b, third_a, third_b]
);
}
#[test]
fn q3_group_positions_preserve_top_level_objects_before_nested_3dmf_groups() {
let group = PPC_Q3_OBJECT_BASE;
let root_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let nested_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let nested_a = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let nested_b = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let file = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let source = |offset, group_depth| PpcQ3ObjectSource {
file,
offset,
parent_group_type: PPC_Q3_GROUP_TYPE_DISPLAY,
group_depth,
};
let q3_group_memberships = vec![
PpcQ3GroupMembershipRecord {
group,
object: root_object,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: nested_a,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: nested_b,
before: None,
},
];
let q3_file_groups = vec![PpcQ3FileGroupRecord {
file,
offset: 0x200,
group: nested_group,
group_type: PPC_Q3_GROUP_TYPE_DISPLAY,
parent_group: 0,
group_depth: 2,
}];
let q3_objects = vec![
test_q3_object(group, PPC_Q3_GROUP_TYPE_DISPLAY),
PpcQ3ObjectRecord {
source: source(0x100, 1),
..test_q3_object(root_object, PPC_Q3_TYPE_CONTAINER)
},
PpcQ3ObjectRecord {
source: source(0x200, 2),
data_size: 16,
..test_q3_object(nested_group, PPC_Q3_GROUP_TYPE_DISPLAY)
},
PpcQ3ObjectRecord {
source: source(0x220, 2),
..test_q3_object(nested_a, PPC_Q3_TYPE_CONTAINER)
},
PpcQ3ObjectRecord {
source: source(0x240, 2),
..test_q3_object(nested_b, PPC_Q3_TYPE_CONTAINER)
},
];
assert_eq!(
ppc_q3_group_position_objects(
&q3_group_memberships,
&q3_objects,
&q3_file_groups,
group,
),
vec![root_object, nested_group]
);
}
#[test]
fn hle_import_runner_tracks_q3_view_slots_and_render_state() {
let view = PPC_Q3_OBJECT_BASE;
let renderer = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_SetRenderer");
let mut loaded = load_pef_application(&pef).unwrap();
let renderer_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(renderer_out_ptr, vec![0; 4]);
loaded.q3_objects.extend([
test_q3_object(view, PPC_Q3_TYPE_VIEW),
test_q3_object(renderer, PPC_Q3_RENDERER_TYPE_GENERIC),
]);
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_views.len(), 1);
assert_eq!(loaded.q3_views[0].renderer, renderer);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ViewGetRenderer;
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = renderer_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(renderer_out_ptr), Some(renderer));
let unknown_renderer = renderer + PPC_Q3_OBJECT_STRIDE;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ViewSetRenderer;
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = unknown_renderer;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_views[0].renderer, renderer);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_StartRendering");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_views[0].rendering_depth, 1);
assert!(!loaded.q3_views[0].cancelled);
let unknown_view = view + PPC_Q3_OBJECT_STRIDE;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = unknown_view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_views.len(), 1);
assert_eq!(loaded.q3_views[0].rendering_depth, 1);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_Cancel");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_views.push(PpcQ3ViewStateRecord {
view,
renderer,
light_group: 0,
draw_context: 0,
camera: 0,
rendering_depth: 1,
bounding_box_depth: 1,
cancelled: false,
});
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_views[0].cancelled);
assert_eq!(loaded.q3_views[0].rendering_depth, 0);
assert_eq!(loaded.q3_views[0].bounding_box_depth, 0);
}
#[test]
fn hle_import_runner_tracks_q3_view_bounding_box_depth() {
fn run_view_call(
loaded: &mut PpcLoadedApp,
target: PpcImportDispatcherTarget,
view: u32,
arg4: u32,
) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = arg4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let view = PPC_Q3_OBJECT_BASE;
let bounding_box_out_ptr = PPC_DATA_BASE + 0x1000;
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_StartBoundingBox");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(
bounding_box_out_ptr,
vec![0xaa; PPC_Q3_BOUNDING_BOX_SIZE as usize],
);
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
assert_eq!(
run_view_call(
&mut loaded,
PpcImportDispatcherTarget::Q3ViewStartBoundingBox,
view,
0,
),
1
);
assert_eq!(loaded.q3_views[0].bounding_box_depth, 1);
assert_eq!(
run_view_call(
&mut loaded,
PpcImportDispatcherTarget::Q3ViewStartBoundingBox,
view,
0,
),
1
);
assert_eq!(loaded.q3_views[0].bounding_box_depth, 2);
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
secondary: 0,
});
assert_eq!(
run_view_call(
&mut loaded,
PpcImportDispatcherTarget::Q3ViewEndBoundingBox,
view,
bounding_box_out_ptr,
),
PPC_Q3_VIEW_STATUS_DONE
);
assert_eq!(loaded.q3_views[0].bounding_box_depth, 1);
assert_eq!(loaded.q3_submissions.len(), 1);
assert_eq!(
run_view_call(
&mut loaded,
PpcImportDispatcherTarget::Q3ViewEndBoundingBox,
view,
bounding_box_out_ptr,
),
PPC_Q3_VIEW_STATUS_DONE
);
assert_eq!(loaded.q3_views[0].bounding_box_depth, 0);
assert!(loaded.q3_submissions.is_empty());
assert_eq!(
ppc_read_f32_be(&mut loaded.memory, bounding_box_out_ptr),
Some(-1.0)
);
assert_eq!(
ppc_read_f32_be(
&mut loaded.memory,
bounding_box_out_ptr + PPC_Q3_BOUNDING_BOX_MAX_OFFSET
),
Some(1.0)
);
assert_eq!(
loaded
.memory
.read_u32_be(bounding_box_out_ptr + PPC_Q3_BOUNDING_BOX_IS_EMPTY_OFFSET),
Some(0)
);
assert_eq!(
run_view_call(
&mut loaded,
PpcImportDispatcherTarget::Q3ViewEndBoundingBox,
view,
bounding_box_out_ptr,
),
PPC_Q3_VIEW_STATUS_DONE
);
assert_eq!(loaded.q3_views[0].bounding_box_depth, 0);
assert_eq!(
run_view_call(
&mut loaded,
PpcImportDispatcherTarget::Q3ViewStartBoundingBox,
0,
0,
),
0
);
assert_eq!(loaded.q3_views.len(), 1);
assert_eq!(loaded.q3_views[0].bounding_box_depth, 0);
let unknown_view = view + PPC_Q3_OBJECT_STRIDE * 2;
assert_eq!(
run_view_call(
&mut loaded,
PpcImportDispatcherTarget::Q3ViewStartBoundingBox,
unknown_view,
0,
),
0
);
assert_eq!(loaded.q3_views.len(), 1);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_queues_completed_q3_frames_at_render_boundaries() {
let view = PPC_Q3_OBJECT_BASE;
let stale_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_StartRendering");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: stale_trimesh,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: stale_trimesh,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: stale_trimesh,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: stale_trimesh,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_views[0].rendering_depth, 1);
assert!(loaded.q3_submissions.is_empty());
assert!(loaded.q3_submission_transforms.is_empty());
assert!(loaded.q3_submission_materials.is_empty());
assert!(loaded.q3_submission_lights.is_empty());
assert!(loaded.q3_completed_frames.is_empty());
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshSubmit;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ViewEndRendering;
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_VIEW_STATUS_DONE);
assert_eq!(loaded.q3_views[0].rendering_depth, 0);
assert!(loaded.q3_submissions.is_empty());
assert!(loaded.q3_submission_transforms.is_empty());
assert!(loaded.q3_submission_materials.is_empty());
assert!(loaded.q3_submission_lights.is_empty());
assert_eq!(loaded.q3_completed_frames.len(), 1);
assert_eq!(
loaded.q3_completed_frames[0].submissions,
vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
}]
);
assert_eq!(loaded.q3_completed_frames[0].submission_transforms.len(), 1);
assert_eq!(loaded.q3_completed_frames[0].submission_materials.len(), 1);
assert_eq!(loaded.q3_completed_frames[0].submission_lights.len(), 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ViewStartRendering;
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_views[0].rendering_depth, 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshSubmit;
loaded.cpu.gpr[3] = stale_trimesh;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_submissions.len(), 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ViewCancel;
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_views[0].cancelled);
assert_eq!(loaded.q3_views[0].rendering_depth, 0);
assert!(loaded.q3_submissions.is_empty());
assert!(loaded.q3_submission_transforms.is_empty());
assert!(loaded.q3_submission_materials.is_empty());
assert!(loaded.q3_submission_lights.is_empty());
assert_eq!(loaded.q3_completed_frames.len(), 1);
}
#[test]
fn q3_completed_frame_fast_render_counts_state_only_frames_without_replay() {
let view = PPC_Q3_OBJECT_BASE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_StartRendering");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.q3_completed_frames = (0..3)
.map(|_| PpcQ3CompletedFrameRecord {
view,
submissions: vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
}],
submission_transforms: Vec::new(),
submission_materials: Vec::new(),
submission_lights: Vec::new(),
retained_trimeshes: Vec::new(),
})
.collect();
let stats = loaded.render_completed_q3_frames_to_front_buffer_fast();
assert!(loaded.q3_completed_frames.is_empty());
assert_eq!(stats.frames, 3);
assert_eq!(stats.commands, 0);
assert_eq!(stats.vertices, 0);
assert_eq!(stats.triangles, 0);
assert_eq!(stats.pixels, 0);
let front_buffer = loaded.current_front_buffer().unwrap();
assert_eq!(stats.target_base, Some(front_buffer.base_addr));
assert_eq!(stats.target_row_bytes, Some(front_buffer.row_bytes));
assert_eq!(stats.target_width, Some(front_buffer.width));
assert_eq!(stats.target_height, Some(front_buffer.height));
assert_eq!(stats.target_depth, Some(front_buffer.depth));
assert_eq!(stats.target_source, Some("current_gworld"));
assert_eq!(stats.target_draw_context, None);
assert_eq!(stats.target_gworld, Some(*loaded.current_gworld));
assert!(stats.target_consistent);
}
#[test]
fn q3_completed_frame_fast_render_records_state_only_target_metadata() {
let view = PPC_Q3_OBJECT_BASE;
let draw_context = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let front_base = PPC_HEAP_BASE + 0x1000;
let back_base = PPC_HEAP_BASE + 0x2000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_StartRendering");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.memory.add_region(back_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![
PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
},
PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_DSP_BACK_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: back_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
},
];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: draw_context,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE,
});
let mut draw_context_data = vec![0; PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE as usize];
draw_context_data[PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET as usize
..PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET as usize + 4]
.copy_from_slice(&PPC_DSP_BACK_GWORLD.to_be_bytes());
loaded.q3_draw_contexts.push(PpcQ3DrawContextRecord {
draw_context,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
data: draw_context_data,
});
loaded.q3_views.push(PpcQ3ViewStateRecord {
view,
renderer: 0,
light_group: 0,
draw_context,
camera: 0,
rendering_depth: 0,
bounding_box_depth: 0,
cancelled: false,
});
loaded.q3_completed_frames.push(PpcQ3CompletedFrameRecord {
view,
submissions: vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
}],
submission_transforms: Vec::new(),
submission_materials: Vec::new(),
submission_lights: Vec::new(),
retained_trimeshes: Vec::new(),
});
let stats = loaded.render_completed_q3_frames_to_front_buffer_fast();
assert!(loaded.q3_completed_frames.is_empty());
assert_eq!(stats.frames, 1);
assert_eq!(stats.commands, 0);
assert_eq!(stats.vertices, 0);
assert_eq!(stats.triangles, 0);
assert_eq!(stats.pixels, 0);
assert_eq!(stats.target_base, Some(back_base));
assert_eq!(stats.target_row_bytes, Some(16));
assert_eq!(stats.target_width, Some(8));
assert_eq!(stats.target_height, Some(8));
assert_eq!(stats.target_depth, Some(16));
assert_eq!(stats.target_source, Some("mac_draw_context"));
assert_eq!(stats.target_draw_context, Some(draw_context));
assert_eq!(stats.target_gworld, Some(PPC_DSP_BACK_GWORLD));
assert!(stats.target_consistent);
}
#[test]
fn q3_end_rendering_aggregates_state_only_completed_frames() {
let view = PPC_Q3_OBJECT_BASE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_StartRendering");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_views.push(PpcQ3ViewStateRecord {
view,
renderer: 0,
light_group: 0,
draw_context: 0,
camera: 0,
rendering_depth: 1,
bounding_box_depth: 0,
cancelled: false,
});
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
loaded.cpu.gpr[3] = view;
let result = ppc_q3_view_end_rendering(
&loaded.cpu,
&mut loaded.q3_views,
&loaded.q3_objects,
&mut loaded.q3_submissions,
&mut loaded.q3_submission_transforms,
&mut loaded.q3_submission_materials,
&mut loaded.q3_submission_lights,
&mut loaded.q3_completed_frames,
&mut loaded.q3_retained_frames,
&mut loaded.q3_state_only_completed_frame_batches,
&loaded.q3_draw_contexts,
&loaded.gworlds,
*loaded.current_gworld,
&mut loaded.q3_error_state,
);
assert_eq!(result, PPC_Q3_VIEW_STATUS_DONE);
assert_eq!(loaded.q3_views[0].rendering_depth, 0);
assert!(loaded.q3_submissions.is_empty());
assert!(loaded.q3_submission_transforms.is_empty());
assert!(loaded.q3_submission_materials.is_empty());
assert!(loaded.q3_submission_lights.is_empty());
assert!(loaded.q3_completed_frames.is_empty());
assert_eq!(loaded.q3_state_only_completed_frame_batches.len(), 1);
assert_eq!(loaded.q3_state_only_completed_frame_batches[0].frames, 1);
let front_buffer = loaded.current_front_buffer().unwrap();
assert_eq!(
loaded.q3_state_only_completed_frame_batches[0]
.target
.map(|target| target.front_buffer),
Some(front_buffer)
);
let stats = loaded.render_completed_q3_frames_to_front_buffer_fast();
assert_eq!(stats.frames, 1);
assert_eq!(stats.commands, 0);
assert_eq!(stats.pixels, 0);
assert_eq!(stats.target_base, Some(front_buffer.base_addr));
assert_eq!(stats.target_source, Some("current_gworld"));
assert!(stats.target_consistent);
assert!(loaded.q3_state_only_completed_frame_batches.is_empty());
}
#[test]
fn q3_end_rendering_reuses_retained_bounding_geometry_for_state_only_frames() {
let view = PPC_Q3_OBJECT_BASE;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_StartRendering");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_views.push(PpcQ3ViewStateRecord {
view,
renderer: 0,
light_group: 0,
draw_context: 0,
camera: 0,
rendering_depth: 0,
bounding_box_depth: 1,
cancelled: false,
});
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
});
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(
loaded.cpu.gpr[4],
vec![0; PPC_Q3_BOUNDING_BOX_SIZE as usize],
);
let result = ppc_q3_view_end_bounding_box(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.q3_views,
&loaded.q3_objects,
&mut loaded.q3_submissions,
&mut loaded.q3_submission_transforms,
&mut loaded.q3_submission_materials,
&mut loaded.q3_submission_lights,
&mut loaded.q3_retained_frames,
&loaded.q3_trimeshes,
&mut loaded.q3_error_state,
);
assert_eq!(result, PPC_Q3_VIEW_STATUS_DONE);
assert!(loaded.q3_submissions.is_empty());
assert_eq!(loaded.q3_retained_frames.len(), 1);
assert_eq!(
loaded.q3_retained_frames[0].frame.submissions,
vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
}]
);
loaded.q3_views[0].rendering_depth = 1;
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
});
loaded.cpu.gpr[3] = view;
let result = ppc_q3_view_end_rendering(
&loaded.cpu,
&mut loaded.q3_views,
&loaded.q3_objects,
&mut loaded.q3_submissions,
&mut loaded.q3_submission_transforms,
&mut loaded.q3_submission_materials,
&mut loaded.q3_submission_lights,
&mut loaded.q3_completed_frames,
&mut loaded.q3_retained_frames,
&mut loaded.q3_state_only_completed_frame_batches,
&loaded.q3_draw_contexts,
&loaded.gworlds,
*loaded.current_gworld,
&mut loaded.q3_error_state,
);
assert_eq!(result, PPC_Q3_VIEW_STATUS_DONE);
assert!(loaded.q3_submissions.is_empty());
assert_eq!(loaded.q3_completed_frames.len(), 1);
assert_eq!(
loaded.q3_completed_frames[0].submissions[0].kind,
PpcQ3SubmissionKind::TriMesh
);
assert!(loaded.q3_state_only_completed_frame_batches.is_empty());
}
#[test]
fn hle_import_runner_fast_paths_idle_q3_state_only_render_boundaries() {
let view = PPC_Q3_OBJECT_BASE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_StartRendering");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_views.push(PpcQ3ViewStateRecord {
view,
renderer: 0,
light_group: 0,
draw_context: 0,
camera: 0,
rendering_depth: 0,
bounding_box_depth: 0,
cancelled: false,
});
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_views[0].rendering_depth, 1);
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
});
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ViewEndRendering;
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_VIEW_STATUS_DONE);
assert_eq!(loaded.q3_views[0].rendering_depth, 0);
assert!(loaded.q3_submissions.is_empty());
assert!(loaded.q3_completed_frames.is_empty());
assert_eq!(loaded.q3_state_only_completed_frame_batches.len(), 1);
assert_eq!(loaded.q3_state_only_completed_frame_batches[0].frames, 1);
loaded.q3_views[0].rendering_depth = 1;
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
});
loaded.q3_retained_frames.push(PpcQ3RetainedFrameRecord {
view,
frame: PpcQ3CompletedFrameRecord {
view,
submissions: vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: style + PPC_Q3_OBJECT_STRIDE,
secondary: 0,
}],
submission_transforms: Vec::new(),
submission_materials: Vec::new(),
submission_lights: Vec::new(),
retained_trimeshes: Vec::new(),
},
});
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(
matches!(
probe.result,
PpcRunResult::Halted {
cycles,
..
} | PpcRunResult::CycleLimit {
cycles,
..
} if cycles >= PPC_Q3_IDLE_STATE_ONLY_FRAME_EXTRA_CYCLES
),
"{:?}",
probe.result
);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_VIEW_STATUS_DONE);
assert!(loaded.q3_submissions.is_empty());
assert_eq!(loaded.q3_completed_frames.len(), 1);
assert!(loaded.q3_retained_frames.is_empty());
loaded.q3_views[0].rendering_depth = 1;
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
});
loaded.set_input_snapshot(PpcInputSnapshot {
key_map: {
let mut key_map = [0; 16];
key_map[(PPC_KEY_SPACE / 8) as usize] |= 1u8 << (PPC_KEY_SPACE % 8);
key_map
},
..PpcInputSnapshot::default()
});
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(
matches!(
probe.result,
PpcRunResult::Halted {
cycles,
..
} | PpcRunResult::CycleLimit {
cycles,
..
} if cycles < PPC_Q3_IDLE_STATE_ONLY_FRAME_EXTRA_CYCLES
),
"{:?}",
probe.result
);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_VIEW_STATUS_DONE);
assert_eq!(loaded.q3_state_only_completed_frame_batches.len(), 1);
assert_eq!(loaded.q3_state_only_completed_frame_batches[0].frames, 2);
}
#[test]
fn q3_hot_import_cost_keeps_reference_frames_within_a_guest_vbl() {
const REFERENCE_Q3_CALLS_PER_FRAME: u64 = 250;
const REFERENCE_CYCLES_PER_VBL: u64 = 416_000;
assert!(
REFERENCE_Q3_CALLS_PER_FRAME * PPC_Q3_HOT_IMPORT_EXTRA_CYCLES
<= REFERENCE_CYCLES_PER_VBL,
"synthetic QD3D costs must leave part of the frame for interpreted game code"
);
}
#[test]
fn q3_trimesh_get_data_cache_restores_guest_arrays_in_place() {
let source_points_ptr = PPC_DATA_BASE + 0x1000;
let cached_points_ptr = PPC_DATA_BASE + 0x1040;
let mut memory = PpcSectionMem::new();
memory.add_region(source_points_ptr, vec![0; 0x80]);
let mut source = vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize];
let mut cached = source.clone();
ppc_q3_trimesh_header_put_u32(&mut source, PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 2).unwrap();
ppc_q3_trimesh_header_put_u32(&mut source, PPC_Q3_TRIMESH_POINTS_OFFSET, source_points_ptr)
.unwrap();
ppc_q3_trimesh_header_put_u32(&mut cached, PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 2).unwrap();
ppc_q3_trimesh_header_put_u32(&mut cached, PPC_Q3_TRIMESH_POINTS_OFFSET, cached_points_ptr)
.unwrap();
let point_bytes: Vec<u8> = [1.0f32, 2.0, 3.0, -4.0, -5.0, -6.0]
.into_iter()
.flat_map(|value| value.to_bits().to_be_bytes())
.collect();
for (offset, byte) in point_bytes.iter().copied().enumerate() {
memory
.write_u8(source_points_ptr + u32::try_from(offset).unwrap(), byte)
.unwrap();
memory
.write_u8(cached_points_ptr + u32::try_from(offset).unwrap(), 0xff)
.unwrap();
}
let refreshed =
ppc_q3_trimesh_refresh_get_data_arrays(&mut memory, &source, &cached).unwrap();
assert_eq!(
ppc_q3_trimesh_header_u32(&refreshed, PPC_Q3_TRIMESH_POINTS_OFFSET),
Some(cached_points_ptr)
);
for (offset, byte) in point_bytes.iter().copied().enumerate() {
assert_eq!(
memory.read_u8(cached_points_ptr + u32::try_from(offset).unwrap()),
Some(byte)
);
}
}
#[test]
fn hle_import_runner_q3_trimesh_get_data_always_returns_independent_arrays() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_New");
let mut loaded = load_pef_application(&pef).unwrap();
let data_ptr = PPC_DATA_BASE + 0x1000;
let source_points_ptr = data_ptr + 0x80;
let output_ptr = data_ptr + 0xc0;
loaded.memory.add_region(data_ptr, vec![0; 0x180]);
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 2)
.unwrap();
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_TRIMESH_POINTS_OFFSET, source_points_ptr)
.unwrap();
let point_bytes: Vec<u8> = [1.0f32, 2.0, 3.0, -4.0, -5.0, -6.0]
.into_iter()
.flat_map(|value| value.to_bits().to_be_bytes())
.collect();
loaded
.memory
.write_bytes(source_points_ptr, &point_bytes)
.unwrap();
loaded.cpu.gpr[3] = data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let trimesh = loaded.cpu.gpr[3];
let stored_points_ptr =
ppc_q3_trimesh_header_u32(&loaded.q3_trimeshes[0].data, PPC_Q3_TRIMESH_POINTS_OFFSET)
.unwrap();
assert_ne!(stored_points_ptr, source_points_ptr);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshGetData;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let output_points_ptr = loaded
.memory
.read_u32_be(output_ptr + PPC_Q3_TRIMESH_POINTS_OFFSET)
.unwrap();
assert_ne!(output_points_ptr, stored_points_ptr);
assert_eq!(
ppc_q3_read_bytes(&mut loaded.memory, output_points_ptr, 24),
Some(point_bytes.clone())
);
loaded.memory.write_u8(output_points_ptr, 0xff).unwrap();
assert_eq!(
loaded.memory.read_u8(stored_points_ptr),
Some(point_bytes[0])
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshEmptyData;
loaded.cpu.gpr[3] = output_ptr;
let heap_cursor_before_reuse = loaded.heap_cursor();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded
.memory
.read_u32_be(output_ptr + PPC_Q3_TRIMESH_POINTS_OFFSET),
Some(0)
);
loaded.memory.write_u8(stored_points_ptr, 0x7f).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshGetData;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.heap_cursor(), heap_cursor_before_reuse);
assert_eq!(
loaded
.memory
.read_u32_be(output_ptr + PPC_Q3_TRIMESH_POINTS_OFFSET),
Some(output_points_ptr)
);
assert_eq!(loaded.memory.read_u8(output_points_ptr), Some(0x7f));
}
#[test]
fn hle_import_runner_handles_q3_trimesh_data_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let data1_ptr = scratch_ptr;
let data2_ptr = scratch_ptr + 0x80;
let output_ptr = scratch_ptr + 0x100;
loaded.memory.add_region(scratch_ptr, vec![0; 0x300]);
let data1: Vec<u8> = (0..PPC_Q3_TRIMESH_DATA_SIZE)
.map(|offset| (offset as u8).wrapping_add(1))
.collect();
let data2: Vec<u8> = (0..PPC_Q3_TRIMESH_DATA_SIZE)
.map(|offset| 0x80u8.wrapping_add(offset as u8))
.collect();
for offset in 0..PPC_Q3_TRIMESH_DATA_SIZE {
loaded
.memory
.write_u8(data1_ptr + offset, data1[offset as usize])
.unwrap();
loaded
.memory
.write_u8(data2_ptr + offset, data2[offset as usize])
.unwrap();
}
loaded.cpu.gpr[3] = data1_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let trimesh = loaded.cpu.gpr[3];
assert_eq!(trimesh, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_TYPE_TRIMESH);
assert_eq!(loaded.q3_objects[0].data_ptr, 0);
assert_eq!(loaded.q3_objects[0].data_size, PPC_Q3_TRIMESH_DATA_SIZE);
assert_eq!(
loaded.q3_trimeshes,
vec![PpcQ3TriMeshRecord {
trimesh,
data: data1.clone(),
triangle_attribute_sets: Vec::new(),
get_data_copies: Vec::new(),
}]
);
loaded.memory.write_u8(data1_ptr, 0).unwrap();
assert_eq!(loaded.q3_trimeshes[0].data, data1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectIsDrawable;
loaded.cpu.gpr[3] = trimesh;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshSetData;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = data2_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_objects[0].data_ptr, 0);
assert_eq!(loaded.q3_objects[0].data_size, PPC_Q3_TRIMESH_DATA_SIZE);
assert_eq!(
loaded.q3_trimeshes,
vec![PpcQ3TriMeshRecord {
trimesh,
data: data2.clone(),
triangle_attribute_sets: Vec::new(),
get_data_copies: Vec::new(),
}]
);
loaded.memory.write_u8(data2_ptr, 0).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshGetData;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
for offset in 0..PPC_Q3_TRIMESH_DATA_SIZE {
assert_eq!(
loaded.memory.read_u8(output_ptr + offset),
Some(data2[offset as usize])
);
}
let wrong_class = trimesh + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: wrong_class,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MIPMAP_COPY_SIZE,
});
let before_trimeshes = loaded.q3_trimeshes.clone();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshSetData;
loaded.cpu.gpr[3] = wrong_class;
loaded.cpu.gpr[4] = data1_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded
.q3_objects
.iter()
.find(|record| record.object == wrong_class)
.map(|record| record.object_type),
Some(PPC_Q3_TEXTURE_TYPE_MIPMAP)
);
assert_eq!(loaded.q3_trimeshes, before_trimeshes);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
for offset in 0..PPC_Q3_TRIMESH_DATA_SIZE {
loaded.memory.write_u8(output_ptr + offset, 0xdd).unwrap();
}
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshGetData;
loaded.cpu.gpr[3] = wrong_class;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..PPC_Q3_TRIMESH_DATA_SIZE {
assert_eq!(loaded.memory.read_u8(output_ptr + offset), Some(0xdd));
}
assert_eq!(loaded.q3_trimeshes, before_trimeshes);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_retains_q3_trimesh_triangle_attribute_sets() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let shader_ptr = scratch_ptr;
let triangle_ptr = scratch_ptr + 0x20;
let trimesh_data_ptr = scratch_ptr + 0x40;
let attribute_values_ptr = scratch_ptr + 0x90;
let attribute_table_ptr = scratch_ptr + 0xa0;
let output_ptr = scratch_ptr + 0xc0;
loaded.memory.add_region(scratch_ptr, vec![0; 0x120]);
let attribute_set = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetNew);
loaded.cpu.gpr[3] = 0x1234_0000;
let shader = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3TextureShaderNew);
loaded.memory.write_u32_be(shader_ptr, shader).unwrap();
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
loaded.cpu.gpr[5] = shader_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetAdd),
1
);
loaded.memory.write_u32_be(triangle_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangle_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangle_ptr + 8, 2).unwrap();
loaded
.memory
.write_u32_be(attribute_values_ptr, attribute_set)
.unwrap();
loaded
.memory
.write_u32_be(attribute_table_ptr, PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER)
.unwrap();
loaded
.memory
.write_u32_be(attribute_table_ptr + 4, attribute_values_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_SET_OFFSET,
attribute_set,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data_ptr + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data_ptr + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangle_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data_ptr + PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data_ptr + PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
attribute_table_ptr,
)
.unwrap();
loaded.cpu.gpr[3] = trimesh_data_ptr;
let trimesh = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3TriMeshNew);
assert_eq!(loaded.q3_trimeshes.len(), 1);
assert_eq!(loaded.q3_trimeshes[0].trimesh, trimesh);
assert_eq!(
loaded.q3_trimeshes[0].triangle_attribute_sets,
vec![attribute_set]
);
let retained_data = &loaded.q3_trimeshes[0].data;
assert_eq!(
ppc_q3_trimesh_header_u32(retained_data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET),
Some(1)
);
assert_ne!(
ppc_q3_trimesh_header_u32(retained_data, PPC_Q3_TRIMESH_TRIANGLES_OFFSET),
Some(triangle_ptr)
);
assert_ne!(
ppc_q3_trimesh_header_u32(
retained_data,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET
),
Some(attribute_table_ptr)
);
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
attribute_set,
),
Some(2)
);
loaded.cpu.gpr[3] = attribute_set;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
attribute_set,
),
Some(1)
);
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
loaded.cpu.gpr[5] = output_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetGet),
1
);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(shader));
loaded.cpu.gpr[3] = trimesh;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(!ppc_q3_object_exists(&loaded.q3_objects, attribute_set));
}
#[test]
fn hle_import_runner_handles_q3_trimesh_empty_data() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_EmptyData");
let mut loaded = load_pef_application(&pef).unwrap();
let data_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(data_ptr, vec![0xaa; PPC_Q3_TRIMESH_DATA_SIZE as usize]);
for offset in [
PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_EDGES_OFFSET,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_POINTS_OFFSET,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
] {
loaded
.memory
.write_u32_be(data_ptr + offset, 0x1234_0000 + offset)
.unwrap();
}
loaded
.memory
.write_u32_be(data_ptr + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 7)
.unwrap();
loaded.cpu.gpr[3] = data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded
.memory
.read_u32_be(data_ptr + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET),
Some(7)
);
for offset in [
PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_EDGES_OFFSET,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_POINTS_OFFSET,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
] {
assert_eq!(loaded.memory.read_u32_be(data_ptr + offset), Some(0));
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn hle_import_runner_handles_q3_attribute_set_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3AttributeSet_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let uv_ptr = scratch_ptr;
let color_ptr = scratch_ptr + 0x20;
let output_ptr = scratch_ptr + 0x40;
let type_ptr = scratch_ptr + 0x60;
loaded.memory.add_region(scratch_ptr, vec![0; 0x80]);
ppc_write_f32_be(&mut loaded.memory, uv_ptr, 0.25).unwrap();
ppc_write_f32_be(&mut loaded.memory, uv_ptr + 4, 0.5).unwrap();
ppc_write_f32_be(&mut loaded.memory, color_ptr, 0.1).unwrap();
ppc_write_f32_be(&mut loaded.memory, color_ptr + 4, 0.2).unwrap();
ppc_write_f32_be(&mut loaded.memory, color_ptr + 8, 0.3).unwrap();
loaded.cpu.gpr[3] = 0xdead_beef;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let attribute_set = loaded.cpu.gpr[3];
assert_eq!(attribute_set, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects.len(), 1);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_TYPE_ATTRIBUTE_SET);
assert_eq!(loaded.q3_objects[0].data_ptr, 0);
assert_eq!(loaded.q3_objects[0].data_size, 0);
assert!(loaded.q3_attributes.is_empty());
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetAdd;
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV;
loaded.cpu.gpr[5] = uv_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_attributes.len(), 1);
assert_eq!(loaded.q3_attributes[0].attribute_set, attribute_set);
assert_eq!(
loaded.q3_attributes[0].attribute_type,
PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV
);
assert_eq!(loaded.q3_attributes[0].data.len(), 8);
ppc_write_f32_be(&mut loaded.memory, uv_ptr, 0.75).unwrap();
ppc_write_f32_be(&mut loaded.memory, uv_ptr + 4, 1.0).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetGet;
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV;
loaded.cpu.gpr[5] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(ppc_read_f32_be(&mut loaded.memory, output_ptr), Some(0.25));
assert_eq!(
ppc_read_f32_be(&mut loaded.memory, output_ptr + 4),
Some(0.5)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetAdd;
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR;
loaded.cpu.gpr[5] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_attributes.len(), 2);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetContains;
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3AttributeSetGetNextAttributeType;
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = type_ptr;
loaded
.memory
.write_u32_be(type_ptr, PPC_Q3_ATTRIBUTE_TYPE_NONE)
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(type_ptr),
Some(PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = type_ptr;
loaded
.memory
.write_u32_be(type_ptr, PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV)
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(type_ptr),
Some(PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetClear;
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_attributes.len(), 1);
assert_eq!(
loaded.q3_attributes[0].attribute_type,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectDispose;
loaded.cpu.gpr[3] = attribute_set;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_objects.is_empty());
assert!(loaded.q3_attributes.is_empty());
let wrong_class = attribute_set + PPC_Q3_OBJECT_STRIDE;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: wrong_class,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TEXTURE_TYPE_MIPMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MIPMAP_COPY_SIZE,
});
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetAdd;
loaded.cpu.gpr[3] = wrong_class;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR;
loaded.cpu.gpr[5] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert!(loaded.q3_attributes.is_empty());
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_attributes.push(PpcQ3AttributeRecord {
attribute_set: wrong_class,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV,
data: vec![0x77; 8],
});
for offset in 0..8 {
loaded.memory.write_u8(output_ptr + offset, 0xdd).unwrap();
}
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetGet;
loaded.cpu.gpr[3] = wrong_class;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV;
loaded.cpu.gpr[5] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..8 {
assert_eq!(loaded.memory.read_u8(output_ptr + offset), Some(0xdd));
}
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetContains;
loaded.cpu.gpr[3] = wrong_class;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded
.memory
.write_u32_be(type_ptr, PPC_Q3_ATTRIBUTE_TYPE_NONE)
.unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3AttributeSetGetNextAttributeType;
loaded.cpu.gpr[3] = wrong_class;
loaded.cpu.gpr[4] = type_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(type_ptr),
Some(PPC_Q3_ATTRIBUTE_TYPE_NONE)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AttributeSetClear;
loaded.cpu.gpr[3] = wrong_class;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_attributes.len(), 1);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_retains_q3_attribute_surface_shader_until_clear_or_dispose() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3AttributeSet_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let shader_ptr = scratch_ptr;
let output_ptr = scratch_ptr + 0x10;
loaded.memory.add_region(scratch_ptr, vec![0; 0x40]);
let attribute_set = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetNew);
loaded.cpu.gpr[3] = 0x1111_0000;
let shader_a = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3TextureShaderNew);
loaded.cpu.gpr[3] = 0x2222_0000;
let shader_b = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3TextureShaderNew);
loaded.memory.write_u32_be(shader_ptr, shader_a).unwrap();
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
loaded.cpu.gpr[5] = shader_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetAdd),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, shader_a),
Some(2)
);
loaded.memory.write_u32_be(shader_ptr, shader_a).unwrap();
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
loaded.cpu.gpr[5] = shader_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetAdd),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, shader_a),
Some(2)
);
loaded.cpu.gpr[3] = shader_a;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, shader_a),
Some(1)
);
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
loaded.cpu.gpr[5] = output_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetGet),
1
);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(shader_a));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, shader_a),
Some(2)
);
loaded.cpu.gpr[3] = shader_a;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, shader_a),
Some(1)
);
let wrong_surface_shader = shader_b + PPC_Q3_OBJECT_STRIDE * 8;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: wrong_surface_shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_STYLE_TYPE_FILL,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 4,
});
loaded
.q3_attributes
.iter_mut()
.find(|record| {
record.attribute_set == attribute_set
&& record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER
})
.unwrap()
.data = wrong_surface_shader.to_be_bytes().to_vec();
loaded.memory.write_u32_be(output_ptr, 0xeeee_eeee).unwrap();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
loaded.cpu.gpr[5] = output_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetGet),
0
);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(0xeeee_eeee));
assert_eq!(
ppc_q3_object_reference_count(
&loaded.q3_objects,
&loaded.q3_object_refs,
wrong_surface_shader,
),
Some(1)
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded
.q3_attributes
.iter_mut()
.find(|record| {
record.attribute_set == attribute_set
&& record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER
})
.unwrap()
.data = shader_a.to_be_bytes().to_vec();
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded
.memory
.write_u32_be(shader_ptr, attribute_set)
.unwrap();
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
loaded.cpu.gpr[5] = shader_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetAdd),
0
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
assert_eq!(
ppc_q3_attributes_surface_shader(&loaded.q3_attributes),
Some(shader_a)
);
loaded.memory.write_u32_be(shader_ptr, shader_b).unwrap();
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
loaded.cpu.gpr[5] = shader_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetAdd),
1
);
assert!(!ppc_q3_object_exists(&loaded.q3_objects, shader_a));
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, shader_b),
Some(2)
);
assert_eq!(
ppc_q3_attributes_surface_shader(&loaded.q3_attributes),
Some(shader_b)
);
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetClear),
1
);
assert!(loaded.q3_attributes.is_empty());
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, shader_b),
Some(1)
);
loaded.memory.write_u32_be(shader_ptr, shader_b).unwrap();
loaded.cpu.gpr[3] = attribute_set;
loaded.cpu.gpr[4] = PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER;
loaded.cpu.gpr[5] = shader_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3AttributeSetAdd),
1
);
loaded.cpu.gpr[3] = shader_b;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert_eq!(
ppc_q3_object_reference_count(&loaded.q3_objects, &loaded.q3_object_refs, shader_b),
Some(1)
);
loaded.cpu.gpr[3] = attribute_set;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3ObjectDispose),
1
);
assert!(!ppc_q3_object_exists(&loaded.q3_objects, attribute_set));
assert!(!ppc_q3_object_exists(&loaded.q3_objects, shader_b));
assert!(loaded.q3_attributes.is_empty());
assert!(loaded.q3_object_refs.is_empty());
}
#[test]
fn hle_import_runner_handles_q3_shader_uv_transform_state() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Shader_SetUVTransform");
let mut loaded = load_pef_application(&pef).unwrap();
let shader = PPC_Q3_OBJECT_BASE;
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let matrix_ptr = scratch_ptr;
let output_ptr = scratch_ptr + 0x40;
loaded.memory.add_region(scratch_ptr, vec![0; 0x100]);
loaded
.q3_objects
.push(test_q3_object(shader, PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE));
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderGetUVTransform;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_matrix3x3(&mut loaded.memory, output_ptr),
Some(ppc_q3_matrix3x3_identity())
);
let first_matrix = [[1.0, 0.0, 0.25], [0.0, 2.0, 0.5], [0.0, 0.0, 1.0]];
ppc_write_q3_matrix3x3(&mut loaded.memory, matrix_ptr, &first_matrix).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderSetUVTransform;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_shader_uv_transforms,
vec![PpcQ3ShaderUvTransformRecord {
shader,
matrix: first_matrix,
}]
);
let mutated_source = [[9.0, 9.0, 9.0], [9.0, 9.0, 9.0], [9.0, 9.0, 9.0]];
ppc_write_q3_matrix3x3(&mut loaded.memory, matrix_ptr, &mutated_source).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderGetUVTransform;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_matrix3x3(&mut loaded.memory, output_ptr),
Some(first_matrix)
);
let second_matrix = [[0.5, 0.0, 0.0], [0.0, 0.5, 0.0], [0.125, 0.25, 1.0]];
ppc_write_q3_matrix3x3(&mut loaded.memory, matrix_ptr, &second_matrix).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderSetUVTransform;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_shader_uv_transforms.len(), 1);
assert_eq!(loaded.q3_shader_uv_transforms[0].matrix, second_matrix);
let rejected_matrix = [[3.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 1.0]];
ppc_write_q3_matrix3x3(&mut loaded.memory, matrix_ptr, &rejected_matrix).unwrap();
loaded.q3_objects[0].object_type = PPC_Q3_STYLE_TYPE_FILL;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderSetUVTransform;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = matrix_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(loaded.q3_shader_uv_transforms.len(), 1);
assert_eq!(loaded.q3_shader_uv_transforms[0].matrix, second_matrix);
loaded.q3_objects[0].object_type = PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE;
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectDispose;
loaded.cpu.gpr[3] = shader;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_objects.is_empty());
assert!(loaded.q3_shader_uv_transforms.is_empty());
}
#[test]
fn hle_import_runner_handles_q3_shader_boundary_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Shader_SetUBoundary");
let mut loaded = load_pef_application(&pef).unwrap();
let shader = PPC_Q3_OBJECT_BASE;
let output_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(output_ptr, vec![0; 8]);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderGetUBoundary;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(output_ptr),
Some(PPC_Q3_SHADER_UV_BOUNDARY_WRAP)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderSetUBoundary;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = PPC_Q3_SHADER_UV_BOUNDARY_CLAMP;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_shader_boundaries,
vec![PpcQ3ShaderBoundaryRecord {
shader,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderSetVBoundary;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = PPC_Q3_SHADER_UV_BOUNDARY_CLAMP;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_shader_boundaries.len(), 1);
assert_eq!(
loaded.q3_shader_boundaries[0],
PpcQ3ShaderBoundaryRecord {
shader,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderGetVBoundary;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = output_ptr + 4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(output_ptr + 4),
Some(PPC_Q3_SHADER_UV_BOUNDARY_CLAMP)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderSetUBoundary;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_shader_boundaries[0].u_boundary,
PPC_Q3_SHADER_UV_BOUNDARY_CLAMP
);
loaded.q3_objects[0].object_type = PPC_Q3_STYLE_TYPE_FILL;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderSetUBoundary;
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = PPC_Q3_SHADER_UV_BOUNDARY_WRAP;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_shader_boundaries[0].u_boundary,
PPC_Q3_SHADER_UV_BOUNDARY_CLAMP
);
loaded.q3_objects[0].object_type = PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE;
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectDispose;
loaded.cpu.gpr[3] = shader;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_objects.is_empty());
assert!(loaded.q3_shader_boundaries.is_empty());
}
#[test]
fn hle_import_runner_handles_q3_style_object_state() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3FillStyle_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let output_ptr = scratch_ptr;
loaded.memory.add_region(scratch_ptr, vec![0; 0x20]);
loaded.cpu.gpr[3] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let fill_style = loaded.cpu.gpr[3];
assert_eq!(fill_style, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_STYLE_TYPE_FILL);
assert_eq!(
loaded.q3_styles,
vec![PpcQ3StyleRecord {
style: fill_style,
kind: PpcQ3StyleKind::Fill,
value: 2,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FillStyleGet;
loaded.cpu.gpr[3] = fill_style;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(2));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FillStyleSet;
loaded.cpu.gpr[3] = fill_style;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_styles[0].value, 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = fill_style;
loaded.cpu.gpr[4] = 99;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_styles[0].value, 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3InterpolationStyleNew;
loaded.cpu.gpr[3] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let interpolation_style = loaded.cpu.gpr[3];
assert_eq!(
interpolation_style,
PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE
);
assert_eq!(
loaded.q3_objects[1].object_type,
PPC_Q3_STYLE_TYPE_INTERPOLATION
);
assert_eq!(
loaded.q3_styles[1],
PpcQ3StyleRecord {
style: interpolation_style,
kind: PpcQ3StyleKind::Interpolation,
value: 1,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3BackfacingStyleNew;
loaded.cpu.gpr[3] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let backfacing_style = loaded.cpu.gpr[3];
assert_eq!(
backfacing_style,
PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2
);
assert_eq!(
loaded.q3_objects[2].object_type,
PPC_Q3_STYLE_TYPE_BACKFACING
);
assert_eq!(
loaded.q3_styles[2],
PpcQ3StyleRecord {
style: backfacing_style,
kind: PpcQ3StyleKind::Backfacing,
value: 2,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 99;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_styles.len(), 3);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3OrientationStyleNew;
loaded.cpu.gpr[3] = PPC_Q3_ORIENTATION_STYLE_CLOCKWISE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let orientation_style = loaded.cpu.gpr[3];
assert_eq!(
orientation_style,
PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3
);
assert_eq!(
loaded.q3_objects[3].object_type,
PPC_Q3_STYLE_TYPE_ORIENTATION
);
assert_eq!(
loaded.q3_styles[3],
PpcQ3StyleRecord {
style: orientation_style,
kind: PpcQ3StyleKind::Orientation,
value: PPC_Q3_ORIENTATION_STYLE_CLOCKWISE,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3OrientationStyleGet;
loaded.cpu.gpr[3] = orientation_style;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(output_ptr),
Some(PPC_Q3_ORIENTATION_STYLE_CLOCKWISE)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3OrientationStyleSet;
loaded.cpu.gpr[3] = orientation_style;
loaded.cpu.gpr[4] = PPC_Q3_ORIENTATION_STYLE_COUNTER_CLOCKWISE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_styles[3].value,
PPC_Q3_ORIENTATION_STYLE_COUNTER_CLOCKWISE
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FillStyleSet;
loaded.cpu.gpr[3] = orientation_style;
loaded.cpu.gpr[4] = PPC_Q3_FILL_STYLE_POINTS;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(
loaded.q3_styles[3].value,
PPC_Q3_ORIENTATION_STYLE_COUNTER_CLOCKWISE
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FillStyleGet;
loaded.cpu.gpr[3] = orientation_style;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3OrientationStyleSet;
loaded.cpu.gpr[3] = orientation_style;
loaded.cpu.gpr[4] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_styles[3].value,
PPC_Q3_ORIENTATION_STYLE_COUNTER_CLOCKWISE
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectDispose;
loaded.cpu.gpr[3] = fill_style;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_styles.len(), 3);
assert!(loaded
.q3_styles
.iter()
.all(|record| record.style != fill_style));
}
#[test]
fn hle_import_runner_handles_q3_view_angle_aspect_camera_state() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3ViewAngleAspectCamera_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let camera_data_ptr = scratch_ptr;
let placement_ptr = scratch_ptr + 0x80;
let output_ptr = scratch_ptr + 0xc0;
loaded.memory.add_region(scratch_ptr, vec![0; 0x200]);
let initial_placement = PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 0.0),
point_of_interest: (0.0, 0.0, -1.0),
up_vector: (0.0, 1.0, 0.0),
};
ppc_write_q3_camera_placement(&mut loaded.memory, camera_data_ptr, initial_placement)
.unwrap();
ppc_write_f32_be(&mut loaded.memory, camera_data_ptr + 36, 0.1).unwrap();
ppc_write_f32_be(&mut loaded.memory, camera_data_ptr + 40, 100.0).unwrap();
ppc_write_q3_vector2d(&mut loaded.memory, camera_data_ptr + 44, (-1.0, -1.0)).unwrap();
ppc_write_f32_be(&mut loaded.memory, camera_data_ptr + 52, 2.0).unwrap();
ppc_write_f32_be(&mut loaded.memory, camera_data_ptr + 56, 2.0).unwrap();
ppc_write_f32_be(
&mut loaded.memory,
camera_data_ptr + 60,
std::f32::consts::FRAC_PI_2,
)
.unwrap();
ppc_write_f32_be(&mut loaded.memory, camera_data_ptr + 64, 4.0 / 3.0).unwrap();
loaded.cpu.gpr[3] = camera_data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let camera = loaded.cpu.gpr[3];
assert_eq!(camera, PPC_Q3_OBJECT_BASE);
assert_eq!(
loaded.q3_objects[0].object_type,
PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT
);
assert_eq!(
loaded.q3_objects[0].data_size,
PPC_Q3_VIEW_ANGLE_ASPECT_CAMERA_DATA_SIZE
);
assert_eq!(loaded.q3_cameras.len(), 1);
assert_eq!(loaded.q3_cameras[0].camera, camera);
assert_eq!(loaded.q3_cameras[0].placement, initial_placement);
assert_eq!(
loaded.q3_cameras[0].projection,
PpcQ3CameraProjection::ViewAngleAspect {
fov: std::f32::consts::FRAC_PI_2,
aspect_ratio_x_to_y: 4.0 / 3.0,
}
);
let mutated_source_placement = PpcQ3CameraPlacement {
camera_location: (9.0, 9.0, 9.0),
point_of_interest: (9.0, 9.0, 8.0),
up_vector: (0.0, 1.0, 0.0),
};
ppc_write_q3_camera_placement(
&mut loaded.memory,
camera_data_ptr,
mutated_source_placement,
)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraGetPlacement;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_camera_placement(&mut loaded.memory, output_ptr),
Some(initial_placement)
);
let updated_placement = PpcQ3CameraPlacement {
camera_location: (1.0, 2.0, 3.0),
point_of_interest: (1.0, 2.0, 2.0),
up_vector: (0.0, 1.0, 0.0),
};
ppc_write_q3_camera_placement(&mut loaded.memory, placement_ptr, updated_placement)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraSetPlacement;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = placement_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_cameras[0].placement, updated_placement);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraGetRange;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_camera_range(&mut loaded.memory, output_ptr),
Some((0.1, 100.0))
);
ppc_write_q3_camera_range(&mut loaded.memory, placement_ptr, 0.25, 250.0).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraSetRange;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = placement_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_cameras[0].range_hither, 0.25);
assert_eq!(loaded.q3_cameras[0].range_yon, 250.0);
ppc_write_q3_camera_range(&mut loaded.memory, placement_ptr, 10.0, 5.0).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = placement_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_cameras[0].range_hither, 0.25);
assert_eq!(loaded.q3_cameras[0].range_yon, 250.0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraGetViewPort;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_camera_viewport(&mut loaded.memory, output_ptr),
Some(((-1.0, -1.0), 2.0, 2.0))
);
ppc_write_q3_camera_viewport(&mut loaded.memory, placement_ptr, (0.25, -0.5), 1.5, 1.25)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraSetViewPort;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = placement_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_cameras[0].viewport_origin, (0.25, -0.5));
assert_eq!(loaded.q3_cameras[0].viewport_width, 1.5);
assert_eq!(loaded.q3_cameras[0].viewport_height, 1.25);
ppc_write_q3_camera_viewport(&mut loaded.memory, placement_ptr, (0.0, 0.0), 0.0, 1.0)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = placement_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_cameras[0].viewport_origin, (0.25, -0.5));
assert_eq!(loaded.q3_cameras[0].viewport_width, 1.5);
assert_eq!(loaded.q3_cameras[0].viewport_height, 1.25);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraGetWorldToView;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_matrix4x4(&mut loaded.memory, output_ptr),
Some([
[1.0, 0.0, -0.0, 0.0],
[-0.0, 1.0, -0.0, 0.0],
[0.0, 0.0, 1.0, 0.0],
[-1.0, -2.0, -3.0, 1.0],
])
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraGetViewToFrustum;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let frustum = ppc_read_q3_matrix4x4(&mut loaded.memory, output_ptr).unwrap();
assert!((frustum[0][0] - 0.75).abs() < 0.0001);
assert!((frustum[1][1] - 1.0).abs() < 0.0001);
assert!((frustum[2][2] - 250.0 / 249.75).abs() < 0.0001);
assert!((frustum[3][2] - 62.5 / 249.75).abs() < 0.0001);
assert_eq!(frustum[2][3], -1.0);
assert_eq!(frustum[3][3], 0.0);
for offset in 0..PPC_Q3_CAMERA_PLACEMENT_SIZE {
loaded.memory.write_u8(output_ptr + offset, 0xa6).unwrap();
}
loaded.q3_objects[0].object_type = PPC_Q3_STYLE_TYPE_FILL;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraGetPlacement;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
for offset in 0..PPC_Q3_CAMERA_PLACEMENT_SIZE {
assert_eq!(loaded.memory.read_u8(output_ptr + offset), Some(0xa6));
}
assert_eq!(loaded.q3_cameras[0].placement, updated_placement);
loaded.q3_error_state = PpcQ3ErrorState::default();
ppc_write_q3_camera_range(&mut loaded.memory, placement_ptr, 0.5, 500.0).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraSetRange;
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = placement_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(loaded.q3_cameras[0].range_hither, 0.25);
assert_eq!(loaded.q3_cameras[0].range_yon, 250.0);
loaded.q3_objects[0].object_type = PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT;
loaded.q3_error_state = PpcQ3ErrorState::default();
let invalid_getters = [
(
PpcImportDispatcherTarget::Q3CameraGetPlacement,
PPC_Q3_CAMERA_PLACEMENT_SIZE,
0xa1u8,
),
(
PpcImportDispatcherTarget::Q3CameraGetRange,
PPC_Q3_CAMERA_RANGE_SIZE,
0xa2u8,
),
(
PpcImportDispatcherTarget::Q3CameraGetViewPort,
PPC_Q3_CAMERA_VIEWPORT_SIZE,
0xa3u8,
),
(
PpcImportDispatcherTarget::Q3CameraGetWorldToView,
PPC_Q3_MATRIX4X4_SIZE,
0xa4u8,
),
(
PpcImportDispatcherTarget::Q3CameraGetViewToFrustum,
PPC_Q3_MATRIX4X4_SIZE,
0xa5u8,
),
];
for (index, (target, size, sentinel)) in invalid_getters.iter().enumerate() {
let invalid_output_ptr = PPC_DATA_BASE + 0x1400 + (index as u32) * 0x100;
loaded
.memory
.add_region(invalid_output_ptr, vec![*sentinel; (*size - 1) as usize]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target.clone();
loaded.cpu.gpr[3] = camera;
loaded.cpu.gpr[4] = invalid_output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..(*size - 1) {
assert_eq!(
loaded.memory.read_u8(invalid_output_ptr + offset),
Some(*sentinel)
);
}
}
}
#[test]
fn hle_import_runner_handles_q3_orthographic_and_view_plane_camera_state() {
fn write_common_camera_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
placement: PpcQ3CameraPlacement,
) {
ppc_write_q3_camera_placement(memory, data_ptr, placement).unwrap();
ppc_write_f32_be(memory, data_ptr + 36, 0.5).unwrap();
ppc_write_f32_be(memory, data_ptr + 40, 10.0).unwrap();
ppc_write_q3_vector2d(memory, data_ptr + 44, (-1.0, -1.0)).unwrap();
ppc_write_f32_be(memory, data_ptr + 52, 2.0).unwrap();
ppc_write_f32_be(memory, data_ptr + 56, 2.0).unwrap();
}
fn assert_f32_close(actual: f32, expected: f32) {
assert!(
(actual - expected).abs() < 0.0001,
"expected {expected}, got {actual}"
);
}
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3OrthographicCamera_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let ortho_data_ptr = scratch_ptr;
let view_plane_data_ptr = scratch_ptr + 0x80;
let output_ptr = scratch_ptr + 0x120;
loaded.memory.add_region(scratch_ptr, vec![0; 0x300]);
let placement = PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 0.0),
point_of_interest: (0.0, 0.0, -1.0),
up_vector: (0.0, 1.0, 0.0),
};
write_common_camera_data(&mut loaded.memory, ortho_data_ptr, placement);
ppc_write_f32_be(
&mut loaded.memory,
ortho_data_ptr + PPC_Q3_CAMERA_DATA_SIZE,
-2.0,
)
.unwrap();
ppc_write_f32_be(
&mut loaded.memory,
ortho_data_ptr + PPC_Q3_CAMERA_DATA_SIZE + 4,
1.0,
)
.unwrap();
ppc_write_f32_be(
&mut loaded.memory,
ortho_data_ptr + PPC_Q3_CAMERA_DATA_SIZE + 8,
2.0,
)
.unwrap();
ppc_write_f32_be(
&mut loaded.memory,
ortho_data_ptr + PPC_Q3_CAMERA_DATA_SIZE + 12,
-1.0,
)
.unwrap();
loaded.cpu.gpr[3] = ortho_data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let orthographic_camera = loaded.cpu.gpr[3];
assert_eq!(orthographic_camera, PPC_Q3_OBJECT_BASE);
assert_eq!(
loaded.q3_objects[0].object_type,
PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC
);
assert_eq!(
loaded.q3_objects[0].data_size,
PPC_Q3_ORTHOGRAPHIC_CAMERA_DATA_SIZE
);
assert_eq!(
loaded.q3_cameras[0].projection,
PpcQ3CameraProjection::Orthographic {
left: -2.0,
top: 1.0,
right: 2.0,
bottom: -1.0,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectIsType;
loaded.cpu.gpr[3] = orthographic_camera;
loaded.cpu.gpr[4] = PPC_Q3_SHAPE_TYPE_CAMERA;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraGetViewToFrustum;
loaded.cpu.gpr[3] = orthographic_camera;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let frustum = ppc_read_q3_matrix4x4(&mut loaded.memory, output_ptr).unwrap();
assert_f32_close(frustum[0][0], 0.5);
assert_f32_close(frustum[1][1], 1.0);
assert_f32_close(frustum[2][2], 1.0 / 9.5);
assert_f32_close(frustum[3][2], 0.5 / 9.5);
assert_eq!(frustum[2][3], 0.0);
assert_eq!(frustum[3][3], 1.0);
write_common_camera_data(&mut loaded.memory, view_plane_data_ptr, placement);
ppc_write_f32_be(
&mut loaded.memory,
view_plane_data_ptr + PPC_Q3_CAMERA_DATA_SIZE,
2.0,
)
.unwrap();
ppc_write_f32_be(
&mut loaded.memory,
view_plane_data_ptr + PPC_Q3_CAMERA_DATA_SIZE + 4,
2.0,
)
.unwrap();
ppc_write_f32_be(
&mut loaded.memory,
view_plane_data_ptr + PPC_Q3_CAMERA_DATA_SIZE + 8,
1.0,
)
.unwrap();
ppc_write_f32_be(
&mut loaded.memory,
view_plane_data_ptr + PPC_Q3_CAMERA_DATA_SIZE + 12,
0.5,
)
.unwrap();
ppc_write_f32_be(
&mut loaded.memory,
view_plane_data_ptr + PPC_Q3_CAMERA_DATA_SIZE + 16,
-0.25,
)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ViewPlaneCameraNew;
loaded.cpu.gpr[3] = view_plane_data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let view_plane_camera = loaded.cpu.gpr[3];
assert_eq!(view_plane_camera, PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE);
assert_eq!(
loaded.q3_objects[1].object_type,
PPC_Q3_CAMERA_TYPE_VIEW_PLANE
);
assert_eq!(
loaded.q3_objects[1].data_size,
PPC_Q3_VIEW_PLANE_CAMERA_DATA_SIZE
);
assert_eq!(
loaded.q3_cameras[1].projection,
PpcQ3CameraProjection::ViewPlane {
view_plane: 2.0,
half_width_at_view_plane: 2.0,
half_height_at_view_plane: 1.0,
center_x_on_view_plane: 0.5,
center_y_on_view_plane: -0.25,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectIsType;
loaded.cpu.gpr[3] = view_plane_camera;
loaded.cpu.gpr[4] = PPC_Q3_SHARED_TYPE_SHAPE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3CameraGetViewToFrustum;
loaded.cpu.gpr[3] = view_plane_camera;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let frustum = ppc_read_q3_matrix4x4(&mut loaded.memory, output_ptr).unwrap();
assert_f32_close(frustum[0][0], 1.0);
assert_f32_close(frustum[1][1], 2.0);
assert_f32_close(frustum[2][0], 0.25);
assert_f32_close(frustum[2][1], -0.25);
assert_f32_close(frustum[2][2], 10.0 / 9.5);
assert_f32_close(frustum[3][2], 5.0 / 9.5);
assert_eq!(frustum[2][3], -1.0);
assert_eq!(frustum[3][3], 0.0);
}
#[test]
fn hle_import_runner_handles_q3_ambient_and_directional_light_state() {
fn assert_q3_light_getter_short_output_preserved(
loaded: &mut PpcLoadedApp,
target: PpcImportDispatcherTarget,
light: u32,
invalid_output_ptr: u32,
size: u32,
sentinel: u8,
) {
let short_size = size - 1;
loaded
.memory
.add_region(invalid_output_ptr, vec![sentinel; short_size as usize]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
loaded.cpu.gpr[3] = light;
loaded.cpu.gpr[4] = invalid_output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..short_size {
assert_eq!(
loaded.memory.read_u8(invalid_output_ptr + offset),
Some(sentinel)
);
}
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3AmbientLight_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let ambient_data_ptr = scratch_ptr;
let directional_data_ptr = scratch_ptr + 0x40;
let output_ptr = scratch_ptr + 0x90;
let color_ptr = scratch_ptr + 0xc0;
let direction_ptr = scratch_ptr + 0xd0;
loaded.memory.add_region(scratch_ptr, vec![0; 0x200]);
let ambient_data = PpcQ3LightData {
is_on: 1,
brightness: 0.25,
color: (0.1, 0.2, 0.3),
};
ppc_write_q3_light_data(&mut loaded.memory, ambient_data_ptr, ambient_data).unwrap();
loaded.cpu.gpr[3] = ambient_data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let ambient_light = loaded.cpu.gpr[3];
assert_eq!(ambient_light, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_LIGHT_TYPE_AMBIENT);
assert_eq!(loaded.q3_objects[0].data_size, PPC_Q3_LIGHT_DATA_SIZE);
assert_eq!(loaded.q3_lights.len(), 1);
assert_eq!(loaded.q3_lights[0].data, ambient_data);
assert_eq!(loaded.q3_lights[0].kind, PpcQ3LightKind::Ambient);
let mutated_ambient_data = PpcQ3LightData {
is_on: 0,
brightness: 0.9,
color: (0.9, 0.8, 0.7),
};
ppc_write_q3_light_data(&mut loaded.memory, ambient_data_ptr, mutated_ambient_data)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightGetType;
loaded.cpu.gpr[3] = ambient_light;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_Q3_LIGHT_TYPE_AMBIENT);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightGetState;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(1));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightSetState;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_lights[0].data.is_on, 0);
loaded.q3_objects[0].object_type = PPC_Q3_STYLE_TYPE_FILL;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightSetState;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(loaded.q3_lights[0].data.is_on, 0);
loaded.q3_objects[0].object_type = PPC_Q3_LIGHT_TYPE_AMBIENT;
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightSetBrightness;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.fpr[1] = 0.75f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_lights[0].data.brightness, 0.75);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightGetBrightness;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(ppc_read_f32_be(&mut loaded.memory, output_ptr), Some(0.75));
ppc_write_q3_color_rgb(&mut loaded.memory, color_ptr, (0.4, 0.5, 0.6)).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightSetColor;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_lights[0].data.color, (0.4, 0.5, 0.6));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightGetColor;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_color_rgb(&mut loaded.memory, output_ptr),
Some((0.4, 0.5, 0.6))
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightSetData;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = ambient_data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_lights[0].data, mutated_ambient_data);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightGetData;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_light_data(&mut loaded.memory, output_ptr),
Some(mutated_ambient_data)
);
let typed_ambient_data = PpcQ3LightData {
is_on: 1,
brightness: 0.6,
color: (0.2, 0.4, 0.6),
};
ppc_write_q3_light_data(&mut loaded.memory, ambient_data_ptr, typed_ambient_data).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AmbientLightSetData;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = ambient_data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_lights[0].data, typed_ambient_data);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3AmbientLightGetData;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_light_data(&mut loaded.memory, output_ptr),
Some(typed_ambient_data)
);
let directional_data = PpcQ3LightData {
is_on: 1,
brightness: 0.5,
color: (0.7, 0.8, 0.9),
};
ppc_write_q3_light_data(&mut loaded.memory, directional_data_ptr, directional_data)
.unwrap();
loaded
.memory
.write_u32_be(directional_data_ptr + 20, 0)
.unwrap();
ppc_write_q3_vector3d(
&mut loaded.memory,
directional_data_ptr + 24,
(1.0, 2.0, 3.0),
)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3DirectionalLightNew;
loaded.cpu.gpr[3] = directional_data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let directional_light = loaded.cpu.gpr[3];
assert_eq!(directional_light, PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE);
assert_eq!(
loaded.q3_objects[1].object_type,
PPC_Q3_LIGHT_TYPE_DIRECTIONAL
);
assert_eq!(
loaded.q3_objects[1].data_size,
PPC_Q3_DIRECTIONAL_LIGHT_DATA_SIZE
);
assert_eq!(
loaded.q3_lights[1],
PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: directional_data,
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (1.0, 2.0, 3.0),
},
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3DirectionalLightSetCastShadowsState;
loaded.cpu.gpr[3] = ambient_light;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert_eq!(loaded.q3_lights[0].kind, PpcQ3LightKind::Ambient);
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3DirectionalLightGetCastShadowsState;
loaded.cpu.gpr[3] = directional_light;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3DirectionalLightSetCastShadowsState;
loaded.cpu.gpr[3] = directional_light;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(matches!(
loaded.q3_lights[1].kind,
PpcQ3LightKind::Directional {
casts_shadows: 1,
..
}
));
ppc_write_q3_vector3d(&mut loaded.memory, direction_ptr, (0.0, -1.0, 0.0)).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3DirectionalLightSetDirection;
loaded.cpu.gpr[3] = directional_light;
loaded.cpu.gpr[4] = direction_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(matches!(
loaded.q3_lights[1].kind,
PpcQ3LightKind::Directional {
direction: (0.0, -1.0, 0.0),
..
}
));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::Q3DirectionalLightGetDirection;
loaded.cpu.gpr[3] = directional_light;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, output_ptr),
Some((0.0, -1.0, 0.0))
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3DirectionalLightGetData;
loaded.cpu.gpr[3] = directional_light;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_directional_light_data(&mut loaded.memory, output_ptr),
Some((directional_data, 1, (0.0, -1.0, 0.0)))
);
let typed_directional_data = PpcQ3LightData {
is_on: 0,
brightness: 0.35,
color: (0.3, 0.2, 0.1),
};
ppc_write_q3_light_data(
&mut loaded.memory,
directional_data_ptr,
typed_directional_data,
)
.unwrap();
loaded
.memory
.write_u32_be(directional_data_ptr + 20, 0)
.unwrap();
ppc_write_q3_vector3d(
&mut loaded.memory,
directional_data_ptr + 24,
(0.0, 1.0, 0.0),
)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3DirectionalLightSetData;
loaded.cpu.gpr[3] = directional_light;
loaded.cpu.gpr[4] = directional_data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_lights[1],
PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: typed_directional_data,
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 1.0, 0.0),
},
}
);
let generic_directional_data = PpcQ3LightData {
is_on: 1,
brightness: 0.65,
color: (0.1, 0.3, 0.5),
};
ppc_write_q3_light_data(
&mut loaded.memory,
directional_data_ptr,
generic_directional_data,
)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3LightSetData;
loaded.cpu.gpr[3] = directional_light;
loaded.cpu.gpr[4] = directional_data_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_lights[1].data, generic_directional_data);
assert!(matches!(
loaded.q3_lights[1].kind,
PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 1.0, 0.0),
}
));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3DirectionalLightGetData;
loaded.cpu.gpr[3] = directional_light;
loaded.cpu.gpr[4] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
ppc_read_q3_directional_light_data(&mut loaded.memory, output_ptr),
Some((generic_directional_data, 0, (0.0, 1.0, 0.0)))
);
let invalid_getters = [
(
PpcImportDispatcherTarget::Q3LightGetState,
ambient_light,
4,
0xb1u8,
),
(
PpcImportDispatcherTarget::Q3LightGetBrightness,
ambient_light,
4,
0xb2u8,
),
(
PpcImportDispatcherTarget::Q3LightGetColor,
ambient_light,
PPC_Q3_VECTOR3D_SIZE,
0xb3u8,
),
(
PpcImportDispatcherTarget::Q3LightGetData,
ambient_light,
PPC_Q3_LIGHT_DATA_SIZE,
0xb4u8,
),
(
PpcImportDispatcherTarget::Q3AmbientLightGetData,
ambient_light,
PPC_Q3_LIGHT_DATA_SIZE,
0xb5u8,
),
(
PpcImportDispatcherTarget::Q3DirectionalLightGetCastShadowsState,
directional_light,
4,
0xb6u8,
),
(
PpcImportDispatcherTarget::Q3DirectionalLightGetDirection,
directional_light,
PPC_Q3_VECTOR3D_SIZE,
0xb7u8,
),
(
PpcImportDispatcherTarget::Q3DirectionalLightGetData,
directional_light,
PPC_Q3_DIRECTIONAL_LIGHT_DATA_SIZE,
0xb8u8,
),
];
for (index, (target, light, size, sentinel)) in invalid_getters.iter().enumerate() {
assert_q3_light_getter_short_output_preserved(
&mut loaded,
target.clone(),
*light,
PPC_DATA_BASE + 0x1400 + (index as u32) * 0x100,
*size,
*sentinel,
);
}
}
#[test]
fn hle_import_runner_handles_q3_point_and_spot_light_state() {
fn run_q3_call(loaded: &mut PpcLoadedApp, target: PpcImportDispatcherTarget) -> u32 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.gpr[3]
}
fn assert_q3_light_getter_short_output_preserved(
loaded: &mut PpcLoadedApp,
target: PpcImportDispatcherTarget,
light: u32,
invalid_output_ptr: u32,
size: u32,
sentinel: u8,
) {
let short_size = size - 1;
loaded
.memory
.add_region(invalid_output_ptr, vec![sentinel; short_size as usize]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
loaded.cpu.gpr[3] = light;
loaded.cpu.gpr[4] = invalid_output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for offset in 0..short_size {
assert_eq!(
loaded.memory.read_u8(invalid_output_ptr + offset),
Some(sentinel)
);
}
}
fn write_point_light_data(
memory: &mut PpcSectionMem,
ptr: u32,
data: PpcQ3LightData,
casts_shadows: u32,
attenuation: u32,
location: (f32, f32, f32),
) {
ppc_write_q3_light_data(memory, ptr, data).unwrap();
memory.write_u32_be(ptr + 20, casts_shadows).unwrap();
memory.write_u32_be(ptr + 24, attenuation).unwrap();
ppc_write_q3_vector3d(memory, ptr + 28, location).unwrap();
}
fn write_spot_light_data(
memory: &mut PpcSectionMem,
ptr: u32,
data: PpcQ3LightData,
casts_shadows: u32,
attenuation: u32,
location: (f32, f32, f32),
direction: (f32, f32, f32),
hot_angle: f32,
outer_angle: f32,
fall_off: u32,
) {
ppc_write_q3_light_data(memory, ptr, data).unwrap();
memory.write_u32_be(ptr + 20, casts_shadows).unwrap();
memory.write_u32_be(ptr + 24, attenuation).unwrap();
ppc_write_q3_vector3d(memory, ptr + 28, location).unwrap();
ppc_write_q3_vector3d(memory, ptr + 40, direction).unwrap();
ppc_write_f32_be(memory, ptr + 52, hot_angle).unwrap();
ppc_write_f32_be(memory, ptr + 56, outer_angle).unwrap();
memory.write_u32_be(ptr + 60, fall_off).unwrap();
}
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3PointLight_New");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch_ptr = PPC_DATA_BASE + 0x1000;
let point_data_ptr = scratch_ptr;
let spot_data_ptr = scratch_ptr + 0x80;
let output_ptr = scratch_ptr + 0x100;
let vector_ptr = scratch_ptr + 0x140;
loaded.memory.add_region(scratch_ptr, vec![0; 0x200]);
let point_data = PpcQ3LightData {
is_on: 1,
brightness: 0.8,
color: (0.9, 0.7, 0.5),
};
write_point_light_data(
&mut loaded.memory,
point_data_ptr,
point_data,
1,
1,
(-2.0, 3.0, 4.0),
);
loaded.cpu.gpr[3] = point_data_ptr;
let point_light = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3PointLightNew);
assert_eq!(point_light, PPC_Q3_OBJECT_BASE);
assert_eq!(loaded.q3_objects[0].object_type, PPC_Q3_LIGHT_TYPE_POINT);
assert_eq!(loaded.q3_objects[0].data_size, PPC_Q3_POINT_LIGHT_DATA_SIZE);
assert_eq!(
loaded.q3_lights[0],
PpcQ3LightRecord {
light: point_light,
light_type: PPC_Q3_LIGHT_TYPE_POINT,
data: point_data,
kind: PpcQ3LightKind::Point {
casts_shadows: 1,
attenuation: 1,
location: (-2.0, 3.0, 4.0),
},
}
);
loaded.cpu.gpr[3] = point_light;
loaded.cpu.gpr[4] = 0;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3PointLightSetCastShadowsState,
),
1
);
assert!(matches!(
loaded.q3_lights[0].kind,
PpcQ3LightKind::Point {
casts_shadows: 0,
..
}
));
loaded.cpu.gpr[3] = point_light;
loaded.cpu.gpr[4] = 2;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3PointLightSetAttenuation,
),
1
);
loaded.cpu.gpr[3] = point_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3PointLightGetAttenuation,
),
1
);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(2));
ppc_write_q3_vector3d(&mut loaded.memory, vector_ptr, (5.0, 6.0, 7.0)).unwrap();
loaded.cpu.gpr[3] = point_light;
loaded.cpu.gpr[4] = vector_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3PointLightSetLocation,
),
1
);
loaded.cpu.gpr[3] = point_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3PointLightGetLocation,
),
1
);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, output_ptr),
Some((5.0, 6.0, 7.0))
);
let updated_point_data = PpcQ3LightData {
is_on: 0,
brightness: 0.25,
color: (0.2, 0.4, 0.6),
};
write_point_light_data(
&mut loaded.memory,
point_data_ptr,
updated_point_data,
1,
0,
(1.0, 2.0, 3.0),
);
loaded.cpu.gpr[3] = point_light;
loaded.cpu.gpr[4] = point_data_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3PointLightSetData),
1
);
loaded.cpu.gpr[3] = point_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3PointLightGetData),
1
);
assert_eq!(
ppc_read_q3_point_light_data(&mut loaded.memory, output_ptr),
Some((updated_point_data, 1, 0, (1.0, 2.0, 3.0)))
);
write_point_light_data(
&mut loaded.memory,
point_data_ptr,
updated_point_data,
1,
9,
(9.0, 9.0, 9.0),
);
loaded.cpu.gpr[3] = point_light;
loaded.cpu.gpr[4] = point_data_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3PointLightSetData),
0
);
assert_eq!(
loaded.q3_lights[0],
PpcQ3LightRecord {
light: point_light,
light_type: PPC_Q3_LIGHT_TYPE_POINT,
data: updated_point_data,
kind: PpcQ3LightKind::Point {
casts_shadows: 1,
attenuation: 0,
location: (1.0, 2.0, 3.0),
},
}
);
loaded.q3_objects[0].object_type = PPC_Q3_LIGHT_TYPE_SPOT;
loaded.cpu.gpr[3] = point_light;
loaded.cpu.gpr[4] = 2;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3PointLightSetAttenuation,
),
0
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert!(matches!(
loaded.q3_lights[0].kind,
PpcQ3LightKind::Point { attenuation: 0, .. }
));
loaded.q3_objects[0].object_type = PPC_Q3_LIGHT_TYPE_POINT;
loaded.q3_error_state = PpcQ3ErrorState::default();
let spot_data = PpcQ3LightData {
is_on: 1,
brightness: 0.6,
color: (0.3, 0.5, 0.7),
};
write_spot_light_data(
&mut loaded.memory,
spot_data_ptr,
spot_data,
0,
2,
(2.0, 3.0, 4.0),
(0.0, -2.0, 0.0),
0.2,
0.6,
3,
);
loaded.cpu.gpr[3] = spot_data_ptr;
let spot_light = run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3SpotLightNew);
assert_eq!(spot_light, PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE);
assert_eq!(loaded.q3_objects[1].object_type, PPC_Q3_LIGHT_TYPE_SPOT);
assert_eq!(loaded.q3_objects[1].data_size, PPC_Q3_SPOT_LIGHT_DATA_SIZE);
assert_eq!(
loaded.q3_lights[1],
PpcQ3LightRecord {
light: spot_light,
light_type: PPC_Q3_LIGHT_TYPE_SPOT,
data: spot_data,
kind: PpcQ3LightKind::Spot {
casts_shadows: 0,
attenuation: 2,
location: (2.0, 3.0, 4.0),
direction: (0.0, -2.0, 0.0),
hot_angle: 0.2,
outer_angle: 0.6,
fall_off: 3,
},
}
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = 1;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightSetCastShadowsState,
),
1
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = 1;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightSetAttenuation,
),
1
);
ppc_write_q3_vector3d(&mut loaded.memory, vector_ptr, (8.0, 9.0, 10.0)).unwrap();
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = vector_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightSetLocation,
),
1
);
ppc_write_q3_vector3d(&mut loaded.memory, vector_ptr, (1.0, 0.0, 0.0)).unwrap();
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = vector_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightSetDirection,
),
1
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.fpr[1] = (0.3f64).to_bits();
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightSetHotAngle
),
1
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.fpr[1] = (0.7f64).to_bits();
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightSetOuterAngle,
),
1
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = 2;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightSetFallOff
),
1
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightGetCastShadowsState,
),
1
);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(1));
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightGetAttenuation,
),
1
);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(1));
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightGetLocation,
),
1
);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, output_ptr),
Some((8.0, 9.0, 10.0))
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightGetDirection,
),
1
);
assert_eq!(
ppc_read_q3_vector3d(&mut loaded.memory, output_ptr),
Some((1.0, 0.0, 0.0))
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightGetHotAngle
),
1
);
assert_eq!(ppc_read_f32_be(&mut loaded.memory, output_ptr), Some(0.3));
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightGetOuterAngle,
),
1
);
assert_eq!(ppc_read_f32_be(&mut loaded.memory, output_ptr), Some(0.7));
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightGetFallOff
),
1
);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(2));
let updated_spot_data = PpcQ3LightData {
is_on: 0,
brightness: 0.4,
color: (0.8, 0.6, 0.4),
};
write_spot_light_data(
&mut loaded.memory,
spot_data_ptr,
updated_spot_data,
1,
0,
(-1.0, -2.0, -3.0),
(0.0, 1.0, 1.0),
0.1,
0.5,
1,
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = spot_data_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3SpotLightSetData),
1
);
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = output_ptr;
assert_eq!(
run_q3_call(&mut loaded, PpcImportDispatcherTarget::Q3SpotLightGetData),
1
);
assert_eq!(
ppc_read_q3_spot_light_data(&mut loaded.memory, output_ptr),
Some((
updated_spot_data,
1,
0,
(-1.0, -2.0, -3.0),
(0.0, 1.0, 1.0),
0.1,
0.5,
1,
))
);
loaded.q3_objects[1].object_type = PPC_Q3_LIGHT_TYPE_POINT;
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.gpr[4] = 3;
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightSetFallOff
),
0
);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
assert!(matches!(
loaded.q3_lights[1].kind,
PpcQ3LightKind::Spot { fall_off: 1, .. }
));
loaded.q3_objects[1].object_type = PPC_Q3_LIGHT_TYPE_SPOT;
loaded.q3_error_state = PpcQ3ErrorState::default();
let invalid_getters = [
(
PpcImportDispatcherTarget::Q3PointLightGetCastShadowsState,
point_light,
4,
0xc1u8,
),
(
PpcImportDispatcherTarget::Q3PointLightGetAttenuation,
point_light,
4,
0xc2u8,
),
(
PpcImportDispatcherTarget::Q3PointLightGetLocation,
point_light,
PPC_Q3_VECTOR3D_SIZE,
0xc3u8,
),
(
PpcImportDispatcherTarget::Q3PointLightGetData,
point_light,
PPC_Q3_POINT_LIGHT_DATA_SIZE,
0xc4u8,
),
(
PpcImportDispatcherTarget::Q3SpotLightGetCastShadowsState,
spot_light,
4,
0xc5u8,
),
(
PpcImportDispatcherTarget::Q3SpotLightGetAttenuation,
spot_light,
4,
0xc6u8,
),
(
PpcImportDispatcherTarget::Q3SpotLightGetLocation,
spot_light,
PPC_Q3_VECTOR3D_SIZE,
0xc7u8,
),
(
PpcImportDispatcherTarget::Q3SpotLightGetDirection,
spot_light,
PPC_Q3_VECTOR3D_SIZE,
0xc8u8,
),
(
PpcImportDispatcherTarget::Q3SpotLightGetHotAngle,
spot_light,
4,
0xc9u8,
),
(
PpcImportDispatcherTarget::Q3SpotLightGetOuterAngle,
spot_light,
4,
0xcau8,
),
(
PpcImportDispatcherTarget::Q3SpotLightGetFallOff,
spot_light,
4,
0xcbu8,
),
(
PpcImportDispatcherTarget::Q3SpotLightGetData,
spot_light,
PPC_Q3_SPOT_LIGHT_DATA_SIZE,
0xccu8,
),
];
for (index, (target, light, size, sentinel)) in invalid_getters.iter().enumerate() {
assert_q3_light_getter_short_output_preserved(
&mut loaded,
target.clone(),
*light,
PPC_DATA_BASE + 0x1400 + (index as u32) * 0x100,
*size,
*sentinel,
);
}
loaded.cpu.gpr[3] = spot_light;
loaded.cpu.fpr[1] = (0.05f64).to_bits();
assert_eq!(
run_q3_call(
&mut loaded,
PpcImportDispatcherTarget::Q3SpotLightSetOuterAngle,
),
0
);
assert!(matches!(
loaded.q3_lights[1].kind,
PpcQ3LightKind::Spot {
outer_angle: 0.5,
..
}
));
}
#[test]
fn hle_import_runner_records_q3_submit_command_order() {
let view = PPC_Q3_OBJECT_BASE;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Shader_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded
.q3_objects
.push(test_q3_object(shader, PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE));
loaded
.q3_objects
.push(test_q3_object(object, PPC_Q3_TYPE_CONTAINER));
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_views[0].view, view);
assert_eq!(
loaded.q3_submissions,
vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Shader,
primary: shader,
secondary: 0,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = object;
loaded.cpu.gpr[4] = view;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ObjectSubmit;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Shader,
primary: shader,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: object,
secondary: 0,
},
]
);
let submission_count = loaded.q3_submissions.len();
for (target, primary) in [
(
PpcImportDispatcherTarget::Q3ShaderSubmit,
view + PPC_Q3_OBJECT_STRIDE * 10,
),
(
PpcImportDispatcherTarget::Q3StyleSubmit,
view + PPC_Q3_OBJECT_STRIDE * 11,
),
(PpcImportDispatcherTarget::Q3ObjectSubmit, view),
] {
loaded.q3_error_state = PpcQ3ErrorState::default();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
loaded.cpu.gpr[3] = primary;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_submissions.len(), submission_count);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
}
#[test]
fn hle_import_runner_expands_direct_q3_object_trimesh_submission() {
let view = PPC_Q3_OBJECT_BASE;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded
.q3_objects
.push(test_q3_object(trimesh, PPC_Q3_TYPE_TRIMESH));
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: trimesh,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
},
]
);
assert_eq!(loaded.q3_submission_transforms.len(), 2);
assert_eq!(loaded.q3_submission_materials.len(), 2);
assert_eq!(loaded.q3_submission_lights.len(), 2);
}
#[test]
fn hle_import_runner_submits_illumination_shader_without_replacing_texture_shader() {
let view = PPC_Q3_OBJECT_BASE;
let texture_shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let null_shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Shader_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: texture_shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: null_shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_ILLUMINATION_TYPE_NULL,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.cpu.gpr[3] = texture_shader;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_view_materials[0].shader, texture_shader);
assert_eq!(
loaded.q3_view_materials[0].illumination_type,
PPC_Q3_ILLUMINATION_TYPE_PHONG
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = null_shader;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_view_materials[0].shader, texture_shader);
assert_eq!(
loaded.q3_view_materials[0].illumination_type,
PPC_Q3_ILLUMINATION_TYPE_NULL
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshSubmit;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_submission_materials[2].shader, texture_shader);
assert_eq!(
loaded.q3_submission_materials[2].illumination_type,
PPC_Q3_ILLUMINATION_TYPE_NULL
);
}
#[test]
fn hle_import_runner_snapshots_q3_light_group_for_submissions() {
let view = PPC_Q3_OBJECT_BASE;
let light_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let non_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3View_SetLightGroup");
let mut loaded = load_pef_application(&pef).unwrap();
let ambient = PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.4,
color: (0.2, 0.3, 0.4),
},
kind: PpcQ3LightKind::Ambient,
};
let directional = PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.8,
color: (0.9, 0.8, 0.7),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 1,
direction: (0.0, -1.0, 0.0),
},
};
loaded.q3_lights.push(ambient);
loaded.q3_lights.push(directional);
loaded.q3_objects.extend([
PpcQ3ObjectRecord {
object: view,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_VIEW,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: light_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_LIGHT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: ambient_light,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_LIGHT_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: non_light,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: directional_light,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_LIGHT_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
]);
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group: light_group,
object: non_light,
before: None,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group: light_group,
object: ambient_light,
before: None,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group: light_group,
object: directional_light,
before: None,
});
loaded.cpu.gpr[3] = view;
loaded.cpu.gpr[4] = light_group;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_views[0].light_group, light_group);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshSubmit;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submission_lights,
vec![PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
light_group,
lights: vec![ambient, directional],
}]
);
loaded.q3_lights[0].data.brightness = 1.0;
assert_eq!(
loaded.q3_submission_lights[0].lights[0].data.brightness,
0.4
);
}
#[test]
fn hle_import_runner_snapshots_q3_material_state_for_submissions() {
let view = PPC_Q3_OBJECT_BASE;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let fog_data_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Shader_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mipmap: Vec<u8> = (0..PPC_Q3_MIPMAP_COPY_SIZE)
.map(|offset| 0x20u8.wrapping_add(offset as u8))
.collect();
let fill_style = PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: 2,
};
let fog_style = PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_LINEAR,
fog_start: 12.0,
fog_end: 96.0,
density: 0.75,
color: (1.0, 0.2, 0.3, 0.4),
};
let texture_shader = PpcQ3TextureShaderRecord { shader, texture };
let mipmap_texture = PpcQ3MipmapTextureRecord {
texture,
mipmap: mipmap.clone(),
};
let shader_boundary = PpcQ3ShaderBoundaryRecord {
shader,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
};
let shader_uv_transform = PpcQ3ShaderUvTransformRecord {
shader,
matrix: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.25, 0.5, 1.0]],
};
loaded.q3_shader_boundaries.push(shader_boundary);
loaded.q3_shader_uv_transforms.push(shader_uv_transform);
loaded.q3_texture_shaders.push(texture_shader);
loaded.q3_mipmap_textures.push(mipmap_texture.clone());
loaded.q3_styles.push(fill_style);
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded
.q3_objects
.push(test_q3_object(shader, PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE));
loaded
.q3_objects
.push(test_q3_object(style, PPC_Q3_STYLE_TYPE_FILL));
loaded
.memory
.add_region(fog_data_ptr, vec![0; PPC_Q3_FOG_STYLE_DATA_SIZE as usize]);
loaded
.memory
.write_u32_be(fog_data_ptr, fog_style.state)
.unwrap();
loaded
.memory
.write_u32_be(fog_data_ptr + 4, fog_style.mode)
.unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 8, fog_style.fog_start).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 12, fog_style.fog_end).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 16, fog_style.density).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 20, fog_style.color.0).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 24, fog_style.color.1).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 28, fog_style.color.2).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 32, fog_style.color.3).unwrap();
loaded.cpu.gpr[3] = shader;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_view_materials,
vec![PpcQ3ViewMaterialRecord {
view,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
}]
);
assert_eq!(
loaded.q3_submission_materials,
vec![PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::Shader,
primary: shader,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: Some(shader_uv_transform),
shader_boundary: Some(shader_boundary),
texture_shader: Some(texture_shader),
mipmap_texture: Some(mipmap_texture.clone()),
}]
);
loaded.q3_mipmap_textures[0].mipmap[0] = 0xff;
assert_eq!(
loaded.q3_submission_materials[0]
.mipmap_texture
.as_ref()
.map(|record| record.mipmap.as_slice()),
Some(mipmap.as_slice())
);
loaded.q3_shader_uv_transforms[0].matrix[2][0] = 9.0;
assert_eq!(
loaded.q3_submission_materials[0]
.shader_uv_transform
.map(|record| record.matrix),
Some(shader_uv_transform.matrix)
);
loaded.q3_shader_uv_transforms[0] = shader_uv_transform;
loaded.q3_mipmap_textures[0] = mipmap_texture.clone();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3StyleSubmit;
loaded.cpu.gpr[3] = style;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_view_materials[0],
PpcQ3ViewMaterialRecord {
view,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![fill_style],
fog_style: None,
attributes: Vec::new(),
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FogStyleSubmit;
loaded.cpu.gpr[3] = fog_data_ptr;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_view_materials[0].fog_style, Some(fog_style));
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 8, 999.0).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshSubmit;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submission_materials[3],
PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![fill_style],
fog_style: Some(fog_style),
attributes: Vec::new(),
shader_uv_transform: Some(shader_uv_transform),
shader_boundary: Some(shader_boundary),
texture_shader: Some(texture_shader),
mipmap_texture: Some(mipmap_texture),
}
);
}
#[test]
fn hle_import_runner_snapshots_q3_object_group_attributes_for_child_trimeshes() {
let view = PPC_Q3_OBJECT_BASE;
let group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let diffuse = vec![
0x3d, 0xcc, 0xcc, 0xcd, 0x3e, 0x4c, 0xcc, 0xcd, 0x3e, 0x99, 0x99, 0x9a,
];
let surface_shader = shader.to_be_bytes().to_vec();
let mipmap = vec![0x10, 0x20, 0x30, 0x40];
let texture_shader = PpcQ3TextureShaderRecord { shader, texture };
let mipmap_texture = PpcQ3MipmapTextureRecord {
texture,
mipmap: mipmap.clone(),
};
let shader_boundary = PpcQ3ShaderBoundaryRecord {
shader,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
};
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: attribute_set,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_ATTRIBUTE_SET,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: attribute_set,
before: None,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: trimesh,
before: None,
});
loaded.q3_attributes.push(PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse.clone(),
});
loaded.q3_attributes.push(PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER,
data: surface_shader.clone(),
});
loaded.q3_shader_boundaries.push(shader_boundary);
loaded.q3_texture_shaders.push(texture_shader);
loaded.q3_mipmap_textures.push(mipmap_texture.clone());
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: group,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
},
]
);
assert_eq!(
loaded.q3_submission_materials[1],
PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse.clone(),
},
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER,
data: surface_shader,
},
],
shader_uv_transform: None,
shader_boundary: Some(shader_boundary),
texture_shader: Some(texture_shader),
mipmap_texture: Some(mipmap_texture),
}
);
loaded.q3_attributes[0].data[0] = 0xff;
loaded.q3_shader_boundaries[0].v_boundary = PPC_Q3_SHADER_UV_BOUNDARY_WRAP;
loaded.q3_mipmap_textures[0].mipmap[0] = 0xff;
assert_eq!(
loaded.q3_submission_materials[1].attributes[0].data,
diffuse
);
assert_eq!(
loaded.q3_submission_materials[1]
.shader_boundary
.map(|record| record.v_boundary),
Some(PPC_Q3_SHADER_UV_BOUNDARY_CLAMP)
);
assert_eq!(
loaded.q3_submission_materials[1]
.mipmap_texture
.as_ref()
.map(|record| record.mipmap.as_slice()),
Some(mipmap.as_slice())
);
}
#[test]
fn hle_import_runner_merges_q3_trimesh_attributes_with_group_material() {
let view = PPC_Q3_OBJECT_BASE;
let group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let group_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let mesh_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let transparency = vec![
0x3f, 0x40, 0x00, 0x00, 0x3f, 0x40, 0x00, 0x00, 0x3f, 0x40, 0x00, 0x00,
];
let surface_shader = shader.to_be_bytes().to_vec();
let mipmap = vec![0x44, 0x55, 0x66, 0x77];
let texture_shader = PpcQ3TextureShaderRecord { shader, texture };
let mipmap_texture = PpcQ3MipmapTextureRecord {
texture,
mipmap: mipmap.clone(),
};
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: group_attribute_set,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_ATTRIBUTE_SET,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: mesh_attribute_set,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_ATTRIBUTE_SET,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: group_attribute_set,
before: None,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: trimesh,
before: None,
});
loaded.q3_attributes.push(PpcQ3AttributeRecord {
attribute_set: group_attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
data: transparency.clone(),
});
loaded.q3_attributes.push(PpcQ3AttributeRecord {
attribute_set: mesh_attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER,
data: surface_shader.clone(),
});
loaded.q3_trimeshes.push(PpcQ3TriMeshRecord {
trimesh,
data: vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize],
triangle_attribute_sets: vec![mesh_attribute_set],
get_data_copies: Vec::new(),
});
loaded.q3_texture_shaders.push(texture_shader);
loaded.q3_mipmap_textures.push(mipmap_texture.clone());
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submission_materials[1],
PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
PpcQ3AttributeRecord {
attribute_set: group_attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
data: transparency,
},
PpcQ3AttributeRecord {
attribute_set: mesh_attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER,
data: surface_shader,
},
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: Some(texture_shader),
mipmap_texture: Some(mipmap_texture),
}
);
}
#[test]
fn hle_import_runner_submits_q3_trimesh_before_stale_retained_memberships() {
let view = PPC_Q3_OBJECT_BASE;
let group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let stale_nested_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.q3_objects.extend([
test_q3_object(view, PPC_Q3_TYPE_VIEW),
test_q3_object(group, PPC_Q3_TYPE_CONTAINER),
test_q3_object(trimesh, PPC_Q3_TYPE_TRIMESH),
test_q3_object(stale_nested_trimesh, PPC_Q3_TYPE_TRIMESH),
]);
loaded.q3_group_memberships.extend([
PpcQ3GroupMembershipRecord {
group,
object: trimesh,
before: None,
},
PpcQ3GroupMembershipRecord {
group: trimesh,
object: stale_nested_trimesh,
before: None,
},
]);
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: group,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
},
]
);
}
#[test]
fn hle_import_runner_snapshots_q3_object_group_styles_for_child_trimeshes() {
let view = PPC_Q3_OBJECT_BASE;
let group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let fill_style = PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
};
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: style,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_STYLE_TYPE_FILL,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 4,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: style,
before: None,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: trimesh,
before: None,
});
loaded.q3_styles.push(fill_style);
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: group,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
},
]
);
assert_eq!(
loaded.q3_submission_materials[1],
PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![fill_style],
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
}
);
loaded.q3_styles[0].value = PPC_Q3_FILL_STYLE_POINTS;
assert_eq!(loaded.q3_submission_materials[1].styles, vec![fill_style]);
}
#[test]
fn hle_import_runner_snapshots_q3_object_group_transforms_for_child_trimeshes() {
let view = PPC_Q3_OBJECT_BASE;
let group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let transform = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let matrix_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut matrix = ppc_q3_matrix4x4_identity();
matrix[3][0] = 5.0;
matrix[3][1] = 6.0;
matrix[3][2] = 7.0;
loaded.memory.add_region(matrix_ptr, vec![0; 64]);
ppc_write_q3_matrix4x4(&mut loaded.memory, matrix_ptr, &matrix).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: transform,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TRANSFORM_TYPE_MATRIX,
source: PpcQ3ObjectSource::default(),
data_ptr: matrix_ptr,
data_size: 64,
});
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: transform,
before: None,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group,
object: trimesh,
before: None,
});
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submission_transforms,
vec![
PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: group,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
},
PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
local_to_world: matrix,
},
]
);
}
#[test]
fn hle_import_runner_propagates_nested_q3_object_group_state_to_parent_siblings() {
let view = PPC_Q3_OBJECT_BASE;
let group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let child_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let transform = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let nested_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let sibling_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6;
let matrix_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut matrix = ppc_q3_matrix4x4_identity();
matrix[3][0] = 9.0;
matrix[3][1] = 10.0;
matrix[3][2] = 11.0;
let fill_style = PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
};
loaded.memory.add_region(matrix_ptr, vec![0; 64]);
ppc_write_q3_matrix4x4(&mut loaded.memory, matrix_ptr, &matrix).unwrap();
loaded.q3_objects.extend([
test_q3_object(view, PPC_Q3_TYPE_VIEW),
PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: child_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_CONTAINER,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: transform,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TRANSFORM_TYPE_MATRIX,
source: PpcQ3ObjectSource::default(),
data_ptr: matrix_ptr,
data_size: 64,
},
PpcQ3ObjectRecord {
object: style,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_STYLE_TYPE_FILL,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 4,
},
PpcQ3ObjectRecord {
object: nested_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: sibling_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
]);
loaded.q3_group_memberships.extend([
PpcQ3GroupMembershipRecord {
group,
object: child_group,
before: None,
},
PpcQ3GroupMembershipRecord {
group: child_group,
object: transform,
before: None,
},
PpcQ3GroupMembershipRecord {
group: child_group,
object: style,
before: None,
},
PpcQ3GroupMembershipRecord {
group: child_group,
object: nested_trimesh,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: sibling_trimesh,
before: None,
},
]);
loaded.q3_styles.push(fill_style);
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: group,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: nested_trimesh,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: sibling_trimesh,
secondary: 0,
},
]
);
assert_eq!(
loaded.q3_submission_transforms,
vec![
PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: group,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
},
PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: nested_trimesh,
secondary: 0,
local_to_world: matrix,
},
PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: sibling_trimesh,
secondary: 0,
local_to_world: matrix,
},
]
);
assert_eq!(loaded.q3_submission_materials[1].styles, vec![fill_style]);
assert_eq!(loaded.q3_submission_materials[2].styles, vec![fill_style]);
}
#[test]
fn hle_import_runner_sorts_q3_ordered_display_group_children_for_submission() {
let view = PPC_Q3_OBJECT_BASE;
let group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let child_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let transform = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6;
let root_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 7;
let child_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 8;
let matrix_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut matrix = ppc_q3_matrix4x4_identity();
matrix[3][0] = 2.0;
matrix[3][1] = 3.0;
matrix[3][2] = 4.0;
let fill_style = PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
};
let diffuse = vec![
0x3f, 0x00, 0x00, 0x00, 0x3e, 0x80, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00,
];
loaded.memory.add_region(matrix_ptr, vec![0; 64]);
ppc_write_q3_matrix4x4(&mut loaded.memory, matrix_ptr, &matrix).unwrap();
loaded.q3_objects.extend([
test_q3_object(view, PPC_Q3_TYPE_VIEW),
PpcQ3ObjectRecord {
object: group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_ORDERED_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: child_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: transform,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TRANSFORM_TYPE_MATRIX,
source: PpcQ3ObjectSource::default(),
data_ptr: matrix_ptr,
data_size: 64,
},
PpcQ3ObjectRecord {
object: style,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_STYLE_TYPE_FILL,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 4,
},
PpcQ3ObjectRecord {
object: attribute_set,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_ATTRIBUTE_SET,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: shader,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: root_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: child_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
]);
loaded.q3_group_memberships.extend([
PpcQ3GroupMembershipRecord {
group,
object: child_group,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: root_trimesh,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: shader,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: attribute_set,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: style,
before: None,
},
PpcQ3GroupMembershipRecord {
group,
object: transform,
before: None,
},
PpcQ3GroupMembershipRecord {
group: child_group,
object: child_trimesh,
before: None,
},
]);
loaded.q3_styles.push(fill_style);
loaded.q3_attributes.push(PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse.clone(),
});
loaded.cpu.gpr[3] = group;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: group,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: root_trimesh,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: child_trimesh,
secondary: 0,
},
]
);
assert_eq!(loaded.q3_submission_transforms[1].local_to_world, matrix);
assert_eq!(loaded.q3_submission_transforms[2].local_to_world, matrix);
for material in &loaded.q3_submission_materials[1..=2] {
assert_eq!(material.shader, shader);
assert_eq!(material.styles, vec![fill_style]);
assert_eq!(
material.attributes,
vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse.clone(),
}]
);
}
}
#[test]
fn hle_import_runner_uses_first_q3_io_proxy_display_group_representation() {
let view = PPC_Q3_OBJECT_BASE;
let proxy_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let preferred_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let preferred_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let fallback_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let unsupported_object = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.q3_objects.extend([
test_q3_object(view, PPC_Q3_TYPE_VIEW),
PpcQ3ObjectRecord {
object: proxy_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_IO_PROXY_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: preferred_group,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_GROUP_TYPE_DISPLAY,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
PpcQ3ObjectRecord {
object: preferred_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: fallback_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
},
PpcQ3ObjectRecord {
object: unsupported_object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_NONE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
},
]);
loaded.q3_group_memberships.extend([
PpcQ3GroupMembershipRecord {
group: proxy_group,
object: unsupported_object,
before: None,
},
PpcQ3GroupMembershipRecord {
group: proxy_group,
object: preferred_group,
before: None,
},
PpcQ3GroupMembershipRecord {
group: proxy_group,
object: fallback_trimesh,
before: None,
},
PpcQ3GroupMembershipRecord {
group: preferred_group,
object: preferred_trimesh,
before: None,
},
]);
loaded.cpu.gpr[3] = proxy_group;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Object,
primary: proxy_group,
secondary: 0,
},
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: preferred_trimesh,
secondary: 0,
},
]
);
assert!(loaded
.q3_submissions
.iter()
.all(|submission| submission.primary != fallback_trimesh));
}
#[test]
fn hle_import_runner_records_q3_direct_style_submissions() {
let view = PPC_Q3_OBJECT_BASE;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3FillStyle_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.cpu.gpr[3] = PPC_Q3_FILL_STYLE_EDGES;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let fill_style = PpcQ3StyleRecord {
style: 0,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
};
assert_eq!(
loaded.q3_view_materials,
vec![PpcQ3ViewMaterialRecord {
view,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![fill_style],
fog_style: None,
attributes: Vec::new(),
}]
);
assert_eq!(
loaded.q3_submissions,
vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: PPC_Q3_FILL_STYLE_EDGES,
secondary: PPC_Q3_STYLE_TYPE_FILL,
}]
);
assert_eq!(
loaded.q3_submission_transforms,
vec![PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: PPC_Q3_FILL_STYLE_EDGES,
secondary: PPC_Q3_STYLE_TYPE_FILL,
local_to_world: ppc_q3_matrix4x4_identity(),
}]
);
assert_eq!(
loaded.q3_submission_materials,
vec![PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: PPC_Q3_FILL_STYLE_EDGES,
secondary: PPC_Q3_STYLE_TYPE_FILL,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![fill_style],
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
}]
);
assert_eq!(
loaded.q3_submission_lights,
vec![PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: PPC_Q3_FILL_STYLE_EDGES,
secondary: PPC_Q3_STYLE_TYPE_FILL,
light_group: 0,
lights: Vec::new(),
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3OrientationStyleSubmit;
loaded.cpu.gpr[3] = 2;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_submissions.len(), 1);
assert_eq!(loaded.q3_view_materials[0].styles, vec![fill_style]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = PPC_Q3_ORIENTATION_STYLE_CLOCKWISE;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let orientation_style = PpcQ3StyleRecord {
style: 0,
kind: PpcQ3StyleKind::Orientation,
value: PPC_Q3_ORIENTATION_STYLE_CLOCKWISE,
};
assert_eq!(
loaded.q3_view_materials[0].styles,
vec![fill_style, orientation_style]
);
assert_eq!(
loaded.q3_submissions[1],
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: PPC_Q3_ORIENTATION_STYLE_CLOCKWISE,
secondary: PPC_Q3_STYLE_TYPE_ORIENTATION,
}
);
assert_eq!(
loaded.q3_submission_materials[1].styles,
vec![fill_style, orientation_style]
);
let submission_count = loaded.q3_submissions.len();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3FillStyleSubmit;
loaded.cpu.gpr[3] = PPC_Q3_FILL_STYLE_POINTS;
loaded.cpu.gpr[4] = view + PPC_Q3_OBJECT_STRIDE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_submissions.len(), submission_count);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_records_q3_view_only_submissions() {
let view = PPC_Q3_OBJECT_BASE;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Push_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Push,
primary: 0,
secondary: 0,
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = view;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ResetTransformSubmit;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions[1],
PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::ResetTransform,
primary: 0,
secondary: 0,
}
);
let submission_count = loaded.q3_submissions.len();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = view + PPC_Q3_OBJECT_STRIDE;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3PushSubmit;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_submissions.len(), submission_count);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_tracks_q3_transform_stack_for_submissions() {
let view = PPC_Q3_OBJECT_BASE;
let trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let matrix_ptr = PPC_DATA_BASE + 0x1000;
let second_matrix_ptr = PPC_DATA_BASE + 0x1040;
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3MatrixTransform_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(matrix_ptr, vec![0; 0x100]);
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
let mut translate_x = ppc_q3_matrix4x4_identity();
translate_x[3][0] = 2.0;
let mut translate_y = ppc_q3_matrix4x4_identity();
translate_y[3][1] = 3.0;
ppc_write_q3_matrix4x4(&mut loaded.memory, matrix_ptr, &translate_x).unwrap();
ppc_write_q3_matrix4x4(&mut loaded.memory, second_matrix_ptr, &translate_y).unwrap();
loaded.cpu.gpr[3] = matrix_ptr;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::MatrixTransform,
primary: matrix_ptr,
secondary: 0,
}]
);
assert_eq!(
loaded.q3_view_transforms,
vec![PpcQ3ViewTransformRecord {
view,
stack: vec![translate_x],
local_to_world: translate_x,
}]
);
assert_eq!(
loaded.q3_submission_transforms,
vec![PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::MatrixTransform,
primary: matrix_ptr,
secondary: 0,
local_to_world: translate_x,
}]
);
ppc_write_q3_matrix4x4(&mut loaded.memory, matrix_ptr, &ppc_q3_matrix4x4_identity())
.unwrap();
assert_eq!(loaded.q3_view_transforms[0].stack[0], translate_x);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3TriMeshSubmit;
loaded.cpu.gpr[3] = trimesh;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submission_transforms[1],
PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh,
secondary: 0,
local_to_world: translate_x,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MatrixTransformSubmit;
loaded.cpu.gpr[3] = second_matrix_ptr;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
let combined = ppc_q3_matrix4x4_multiply_values(translate_x, translate_y);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_view_transforms[0].stack,
vec![translate_x, translate_y]
);
assert_eq!(loaded.q3_view_transforms[0].local_to_world, combined);
assert_eq!(
loaded.q3_submission_transforms[2],
PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::MatrixTransform,
primary: second_matrix_ptr,
secondary: 0,
local_to_world: combined,
}
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ResetTransformSubmit;
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_view_transforms[0].stack.is_empty());
assert_eq!(
loaded.q3_view_transforms[0].local_to_world,
ppc_q3_matrix4x4_identity()
);
assert_eq!(
loaded.q3_submission_transforms[3],
PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::ResetTransform,
primary: 0,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
}
);
}
#[test]
fn hle_import_runner_restores_q3_view_state_for_push_pop() {
let view = PPC_Q3_OBJECT_BASE;
let initial_shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let inner_shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let matrix_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Push_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(matrix_ptr, vec![0; 0x40]);
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_objects.push(test_q3_object(
inner_shader,
PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
));
let mut initial_transform = ppc_q3_matrix4x4_identity();
initial_transform[3][0] = 2.0;
let mut inner_transform = ppc_q3_matrix4x4_identity();
inner_transform[3][1] = 5.0;
ppc_write_q3_matrix4x4(&mut loaded.memory, matrix_ptr, &inner_transform).unwrap();
loaded.q3_view_transforms.push(PpcQ3ViewTransformRecord {
view,
stack: vec![initial_transform],
local_to_world: initial_transform,
});
loaded.q3_view_materials.push(PpcQ3ViewMaterialRecord {
view,
shader: initial_shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
});
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_view_state_stack,
vec![PpcQ3ViewStateSnapshotRecord {
view,
transform: Some(PpcQ3ViewTransformRecord {
view,
stack: vec![initial_transform],
local_to_world: initial_transform,
}),
material: Some(PpcQ3ViewMaterialRecord {
view,
shader: initial_shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
}),
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3MatrixTransformSubmit;
loaded.cpu.gpr[3] = matrix_ptr;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let combined = ppc_q3_matrix4x4_multiply_values(initial_transform, inner_transform);
assert_eq!(loaded.q3_view_transforms[0].local_to_world, combined);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3ShaderSubmit;
loaded.cpu.gpr[3] = inner_shader;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.q3_view_materials[0].shader, inner_shader);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::Q3PopSubmit;
loaded.cpu.gpr[3] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_view_state_stack.is_empty());
assert_eq!(
loaded.q3_view_transforms,
vec![PpcQ3ViewTransformRecord {
view,
stack: vec![initial_transform],
local_to_world: initial_transform,
}]
);
assert_eq!(loaded.q3_view_materials[0].shader, initial_shader);
assert_eq!(
loaded
.q3_submissions
.iter()
.map(|record| record.kind)
.collect::<Vec<_>>(),
vec![
PpcQ3SubmissionKind::Push,
PpcQ3SubmissionKind::MatrixTransform,
PpcQ3SubmissionKind::Shader,
PpcQ3SubmissionKind::Pop,
]
);
assert_eq!(
loaded.q3_submission_transforms[3].local_to_world,
initial_transform
);
assert_eq!(loaded.q3_submission_materials[3].shader, initial_shader);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = view;
let submission_count = loaded.q3_submissions.len();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_submissions.len(), submission_count);
}
#[test]
fn hle_import_runner_records_q3_data_submissions() {
let view = PPC_Q3_OBJECT_BASE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.cpu.gpr[3] = trimesh_data;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
}]
);
}
#[test]
fn hle_import_runner_resolves_q3_trimesh_scene_commands() {
let view = PPC_Q3_OBJECT_BASE;
let camera = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let light_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let trimesh: Vec<u8> = (0..PPC_Q3_TRIMESH_DATA_SIZE)
.map(|offset| 0x50u8.wrapping_add(offset as u8))
.collect();
loaded.memory.add_region(trimesh_data, trimesh.clone());
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded.q3_views.push(PpcQ3ViewStateRecord {
view,
renderer: 0x1111_2222,
light_group,
draw_context: 0x3333_4444,
camera,
rendering_depth: 1,
bounding_box_depth: 0,
cancelled: false,
});
let camera_record = PpcQ3CameraRecord {
camera,
camera_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
placement: PpcQ3CameraPlacement {
camera_location: (1.0, 2.0, 3.0),
point_of_interest: (4.0, 5.0, 6.0),
up_vector: (0.0, 1.0, 0.0),
},
range_hither: 0.5,
range_yon: 500.0,
viewport_origin: (0.0, 0.0),
viewport_width: 1.0,
viewport_height: 1.0,
projection: PpcQ3CameraProjection::ViewAngleAspect {
fov: 0.75,
aspect_ratio_x_to_y: 4.0 / 3.0,
},
};
loaded.q3_cameras.push(camera_record);
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group: light_group,
object: light,
before: None,
});
let light_record = PpcQ3LightRecord {
light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.75,
color: (0.25, 0.5, 1.0),
},
kind: PpcQ3LightKind::Ambient,
};
loaded.q3_lights.push(light_record);
let mut local_to_world = ppc_q3_matrix4x4_identity();
local_to_world[3][0] = 7.0;
local_to_world[3][1] = 8.0;
loaded.q3_view_transforms.push(PpcQ3ViewTransformRecord {
view,
stack: vec![local_to_world],
local_to_world,
});
let fog_style = PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_LINEAR,
fog_start: 2.0,
fog_end: 9.0,
density: 0.125,
color: (0.1, 0.2, 0.3, 1.0),
};
let fill_style = PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: 2,
};
let diffuse_attribute = PpcQ3AttributeRecord {
attribute_set: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 7,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: vec![1, 2, 3, 4],
};
loaded.q3_view_materials.push(PpcQ3ViewMaterialRecord {
view,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![fill_style],
fog_style: Some(fog_style),
attributes: vec![diffuse_attribute.clone()],
});
let shader_boundary = PpcQ3ShaderBoundaryRecord {
shader,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
};
loaded.q3_shader_boundaries.push(shader_boundary);
let texture_shader = PpcQ3TextureShaderRecord { shader, texture };
loaded.q3_texture_shaders.push(texture_shader);
let mipmap_texture = PpcQ3MipmapTextureRecord {
texture,
mipmap: vec![0x5a; PPC_Q3_MIPMAP_COPY_SIZE as usize],
};
loaded.q3_mipmap_textures.push(mipmap_texture.clone());
loaded.cpu.gpr[3] = trimesh_data;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_scene_commands(),
vec![PpcQ3SceneCommand::TriMesh(PpcQ3SceneTriMeshCommand {
submission_index: 0,
view_state: loaded.q3_views[0],
camera: Some(camera_record),
geometry: PpcQ3SceneTriMeshGeometry {
source: PpcQ3SceneTriMeshSource::DataPtr(trimesh_data),
data: trimesh,
},
local_to_world,
material: PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![fill_style],
fog_style: Some(fog_style),
attributes: vec![diffuse_attribute],
shader_uv_transform: None,
shader_boundary: Some(shader_boundary),
texture_shader: Some(texture_shader),
mipmap_texture: Some(mipmap_texture),
},
lights: PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group,
lights: vec![light_record],
},
})]
);
let object_trimesh = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 8;
let object_trimesh_data: Vec<u8> = (0..PPC_Q3_TRIMESH_DATA_SIZE)
.map(|offset| 0xa0u8.wrapping_add(offset as u8))
.collect();
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: object_trimesh,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_TRIMESH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_TRIMESH_DATA_SIZE,
});
loaded.q3_trimeshes.push(PpcQ3TriMeshRecord {
trimesh: object_trimesh,
data: object_trimesh_data.clone(),
triangle_attribute_sets: Vec::new(),
get_data_copies: Vec::new(),
});
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: object_trimesh,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: object_trimesh,
secondary: 0,
local_to_world,
});
let mut object_material = loaded.q3_submission_materials[0].clone();
object_material.primary = object_trimesh;
loaded.q3_submission_materials.push(object_material);
let mut object_lights = loaded.q3_submission_lights[0].clone();
object_lights.primary = object_trimesh;
loaded.q3_submission_lights.push(object_lights);
let commands = loaded.q3_scene_commands();
assert_eq!(commands.len(), 2);
let PpcQ3SceneCommand::TriMesh(command) = &commands[1] else {
panic!("expected TriMesh scene command");
};
assert_eq!(command.submission_index, 1);
assert_eq!(
command.geometry.source,
PpcQ3SceneTriMeshSource::Object(object_trimesh)
);
assert_eq!(command.geometry.data, object_trimesh_data);
assert_eq!(command.material.primary, object_trimesh);
assert_eq!(command.lights.primary, object_trimesh);
let style_submission = PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
};
loaded.q3_submissions.push(style_submission);
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::Style,
primary: style,
secondary: 0,
local_to_world,
});
let mut style_material = loaded.q3_submission_materials[0].clone();
style_material.kind = PpcQ3SubmissionKind::Style;
style_material.primary = style;
loaded.q3_submission_materials.push(style_material);
let mut style_lights = loaded.q3_submission_lights[0].clone();
style_lights.kind = PpcQ3SubmissionKind::Style;
style_lights.primary = style;
loaded.q3_submission_lights.push(style_lights);
let commands = loaded.q3_scene_commands();
assert_eq!(commands.len(), 3);
let PpcQ3SceneCommand::Submission(command) = &commands[2] else {
panic!("expected non-TriMesh scene command");
};
assert_eq!(command.submission_index, 2);
assert_eq!(command.view_state.view, view);
assert_eq!(command.submission, style_submission);
assert_eq!(command.local_to_world, local_to_world);
assert_eq!(command.material.primary, style);
assert_eq!(command.lights.primary, style);
}
#[test]
fn q3_software_renderer_replays_trimesh_scene_commands_to_front_buffer() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let mut diffuse = Vec::new();
for value in [0.0f32, 1.0, 0.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let captured_commands = loaded.q3_scene_commands();
assert_eq!(captured_commands.len(), 1);
let replay = loaded.capture_q3_scene_replay(captured_commands);
assert!(replay
.memory_regions
.iter()
.any(|region| region.base_addr == points_ptr && region.data.len() == 36));
assert!(replay
.memory_regions
.iter()
.any(|region| region.base_addr == triangles_ptr && region.data.len() == 12));
let replay_json = replay.to_json_pretty().unwrap();
assert!(replay_json.contains("\"commands\""));
assert!(replay_json.contains("\"memory_regions\""));
let replay = PpcQ3SceneReplay::from_json_str(&replay_json).unwrap();
loaded.q3_completed_frames.push(PpcQ3CompletedFrameRecord {
view,
submissions: loaded.q3_submissions.clone(),
submission_transforms: loaded.q3_submission_transforms.clone(),
submission_materials: loaded.q3_submission_materials.clone(),
submission_lights: loaded.q3_submission_lights.clone(),
retained_trimeshes: Vec::new(),
});
let gpu_frame = loaded
.take_completed_q3_gpu_frame()
.expect("simple filled triangle should use the GPU packet path");
assert_eq!((gpu_frame.width, gpu_frame.height), (8, 8));
assert_eq!(gpu_frame.viewport, [0, 0, 7, 7]);
assert!(gpu_frame.textures.is_empty());
assert_eq!(gpu_frame.draws.len(), 1);
assert_eq!(gpu_frame.draws[0].vertices.len(), 3);
assert_eq!(gpu_frame.draws[0].vertices[0].color, [0.0, 1.0, 0.0, 1.0]);
assert!(loaded.q3_completed_frames.is_empty());
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0)
);
loaded.q3_submission_lights[0]
.lights
.push(PpcQ3LightRecord {
light: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Ambient,
});
loaded.q3_completed_frames.push(PpcQ3CompletedFrameRecord {
view,
submissions: loaded.q3_submissions.clone(),
submission_transforms: loaded.q3_submission_transforms.clone(),
submission_materials: loaded.q3_submission_materials.clone(),
submission_lights: loaded.q3_submission_lights.clone(),
retained_trimeshes: Vec::new(),
});
assert!(loaded.take_completed_q3_gpu_frame().is_none());
assert_eq!(loaded.q3_completed_frames.len(), 1);
let fallback_stats = loaded.render_completed_q3_frames_to_front_buffer_fast();
assert_eq!(fallback_stats.frames, 1);
assert!(fallback_stats.pixels >= 8);
assert!(loaded.q3_completed_frames.is_empty());
let mut replay_loaded = load_pef_application(&pef).unwrap();
replay_loaded
.memory
.add_region(front_base, vec![0; 8 * 8 * 2]);
replay_loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
replay_loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
assert!(replay_loaded.q3_submissions.is_empty());
assert!(replay_loaded.q3_submission_transforms.is_empty());
assert!(replay_loaded.q3_submission_materials.is_empty());
assert!(replay_loaded.q3_submission_lights.is_empty());
let stats = replay_loaded.replay_q3_scene_replay_to_front_buffer(&replay);
assert_eq!(stats.commands, 1);
assert_eq!(stats.vertices, 3);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels >= 8);
assert_eq!(
replay_loaded
.memory
.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x03e0)
);
assert_eq!(
replay_loaded
.memory
.read_u16_be(front_base + 4 * 2),
Some(0x03e0)
);
assert_eq!(
replay_loaded
.memory
.read_u16_be(front_base + 4 * 16 + 7 * 2),
Some(0x03e0)
);
assert_eq!(
replay_loaded
.memory
.read_u16_be(front_base + 3 * 16 + 5 * 2),
Some(0x03e0)
);
}
#[test]
fn q3_scene_replay_capture_includes_texture_image_memory() {
let view = PPC_Q3_OBJECT_BASE;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let image_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(
image_ptr,
vec![0xee, 0xdd, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00],
);
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4].copy_from_slice(&storage.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_PIXEL_TYPE_RGB24.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_ENDIAN_BIG.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET as usize..][..4]
.copy_from_slice(&2u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET as usize..][..4]
.copy_from_slice(&6u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET as usize..][..4]
.copy_from_slice(&2u32.to_be_bytes());
loaded.q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage,
buffer_ptr: image_ptr,
valid_size: 8,
buffer_size: 8,
owns_buffer: false,
});
let material = PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::Shader,
primary: shader,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: Some(PpcQ3TextureShaderRecord { shader, texture }),
mipmap_texture: Some(PpcQ3MipmapTextureRecord { texture, mipmap }),
};
let replay = loaded.capture_q3_scene_replay(vec![PpcQ3SceneCommand::Submission(
PpcQ3SceneSubmissionCommand {
submission_index: 0,
view_state: PpcQ3ViewStateRecord::new(view),
submission: PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::Shader,
primary: shader,
secondary: 0,
},
local_to_world: ppc_q3_matrix4x4_identity(),
material,
lights: PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::Shader,
primary: shader,
secondary: 0,
light_group: 0,
lights: Vec::new(),
},
},
)]);
assert_eq!(replay.memory_regions.len(), 1);
assert_eq!(replay.memory_regions[0].base_addr, image_ptr + 2);
assert_eq!(
replay.memory_regions[0].data,
vec![0xff, 0x00, 0x00, 0x00, 0xff, 0x00]
);
}
#[test]
fn q3_software_renderer_uses_pixmap_draw_context_destination() {
fn write_u32_into_slice(data: &mut [u8], offset: u32, value: u32) {
let offset = offset as usize;
data[offset..offset + 4].copy_from_slice(&value.to_be_bytes());
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let draw_context = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let front_base = PPC_HEAP_BASE + 0x1000;
let pixmap_base = PPC_HEAP_BASE + 0x3000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.memory.add_region(pixmap_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: draw_context,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_PIXMAP_DRAW_CONTEXT_DATA_SIZE,
});
let mut draw_context_data = vec![0; PPC_Q3_PIXMAP_DRAW_CONTEXT_DATA_SIZE as usize];
write_u32_into_slice(
&mut draw_context_data,
PPC_Q3_DRAW_CONTEXT_DATA_SIZE,
pixmap_base,
);
write_u32_into_slice(
&mut draw_context_data,
PPC_Q3_PIXMAP_DRAW_CONTEXT_WIDTH_OFFSET,
8,
);
write_u32_into_slice(
&mut draw_context_data,
PPC_Q3_PIXMAP_DRAW_CONTEXT_HEIGHT_OFFSET,
8,
);
write_u32_into_slice(
&mut draw_context_data,
PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 12,
16,
);
write_u32_into_slice(
&mut draw_context_data,
PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 16,
16,
);
write_u32_into_slice(
&mut draw_context_data,
PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 20,
PPC_Q3_PIXEL_TYPE_RGB16,
);
loaded.q3_draw_contexts.push(PpcQ3DrawContextRecord {
draw_context,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP,
data: draw_context_data,
});
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let mut diffuse = Vec::new();
for value in [0.0f32, 1.0, 0.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let mut view_state = PpcQ3ViewStateRecord::new(view);
view_state.draw_context = draw_context;
loaded.q3_views.push(view_state);
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels >= 8);
for offset in [4 * 16 + 4 * 2, 4 * 2, 4 * 16 + 7 * 2] {
assert_eq!(
loaded.memory.read_u16_be(pixmap_base + offset),
Some(0x03e0)
);
assert_eq!(loaded.memory.read_u16_be(front_base + offset), Some(0));
}
}
#[test]
fn q3_software_renderer_uses_mac_draw_context_registered_port_destination() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let draw_context = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let main_base = PPC_HEAP_BASE + 0x1000;
let window_port = PPC_HEAP_BASE + 0x2000;
let window_base = PPC_HEAP_BASE + 0x3000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(main_base, vec![0; 8 * 8 * 2]);
loaded.memory.add_region(window_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![
PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: main_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
},
PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: window_port,
pixmap_handle: 0,
pixmap: 0,
base_addr: window_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
},
];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: draw_context,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE,
});
let mut draw_context_data = vec![0; PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE as usize];
draw_context_data[PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET as usize
..PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET as usize + 4]
.copy_from_slice(&window_port.to_be_bytes());
loaded.q3_draw_contexts.push(PpcQ3DrawContextRecord {
draw_context,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
data: draw_context_data,
});
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let mut diffuse = Vec::new();
for value in [0.0f32, 1.0, 0.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let mut view_state = PpcQ3ViewStateRecord::new(view);
view_state.draw_context = draw_context;
loaded.q3_views.push(view_state);
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels >= 8);
for offset in [4 * 16 + 4 * 2, 4 * 2, 4 * 16 + 7 * 2] {
assert_eq!(
loaded.memory.read_u16_be(window_base + offset),
Some(0x03e0)
);
assert_eq!(loaded.memory.read_u16_be(main_base + offset), Some(0));
}
}
#[test]
fn q3_completed_frame_renders_to_dsp_back_buffer_mac_draw_context_until_swap() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let draw_context = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let main_base = PPC_HEAP_BASE + 0x1000;
let back_base = PPC_HEAP_BASE + 0x3000;
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SwapBuffers");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(main_base, vec![0; 8 * 8 * 2]);
loaded.memory.add_region(back_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![
PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: main_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
},
PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_DSP_BACK_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: back_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
},
];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded.draw_sprocket.front_buffer_gworld = PPC_MAIN_GWORLD;
loaded.draw_sprocket.back_buffer_gworld = PPC_DSP_BACK_GWORLD;
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.q3_objects.push(test_q3_object(
draw_context,
PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
));
let mut draw_context_data = vec![0; PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE as usize];
draw_context_data[PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET as usize
..PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET as usize + 4]
.copy_from_slice(&PPC_DSP_BACK_GWORLD.to_be_bytes());
loaded.q3_draw_contexts.push(PpcQ3DrawContextRecord {
draw_context,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
data: draw_context_data,
});
let mut diffuse = Vec::new();
for value in [0.0f32, 1.0, 0.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let mut view_state = PpcQ3ViewStateRecord::new(view);
view_state.draw_context = draw_context;
loaded.q3_views.push(view_state);
let submission = PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
};
let transform = PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
};
let material = PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
};
let lights = PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
};
loaded.q3_completed_frames.push(PpcQ3CompletedFrameRecord {
view,
submissions: vec![submission],
submission_transforms: vec![transform],
submission_materials: vec![material],
submission_lights: vec![lights],
retained_trimeshes: Vec::new(),
});
let stats = loaded.render_completed_q3_frames_to_front_buffer();
assert_eq!(stats.frames, 1);
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels >= 8);
assert!(loaded.q3_completed_frames.is_empty());
assert_eq!(
loaded
.presented_front_buffer()
.map(|front_buffer| front_buffer.base_addr),
Some(main_base)
);
for offset in [4 * 16 + 4 * 2, 4 * 2, 4 * 16 + 7 * 2] {
assert_eq!(loaded.memory.read_u16_be(back_base + offset), Some(0x03e0));
assert_eq!(loaded.memory.read_u16_be(main_base + offset), Some(0));
}
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.draw_sprocket.front_buffer_gworld, PPC_MAIN_GWORLD);
assert_eq!(loaded.draw_sprocket.back_buffer_gworld, PPC_DSP_BACK_GWORLD);
assert_eq!(
loaded
.presented_front_buffer()
.map(|front_buffer| front_buffer.base_addr),
Some(main_base)
);
for offset in [4 * 16 + 4 * 2, 4 * 2, 4 * 16 + 7 * 2] {
assert_eq!(loaded.memory.read_u16_be(main_base + offset), Some(0x03e0));
}
}
#[test]
fn q3_software_renderer_respects_fill_style_edges_and_points() {
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [0.0f32, 1.0, 0.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
fn render_with_fill_style(
fill_style: u32,
) -> (PpcLoadedApp, u32, PpcQ3SoftwareRenderStats) {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (-0.8, -0.8, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (-0.8, 0.8, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.8, -0.8, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: fill_style,
}],
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
(loaded, front_base, stats)
}
let (mut edge_loaded, edge_front_base, edge_stats) =
render_with_fill_style(PPC_Q3_FILL_STYLE_EDGES);
assert_eq!(edge_stats.commands, 1);
assert_eq!(edge_stats.triangles, 1);
assert_eq!(
edge_loaded
.memory
.read_u16_be(edge_front_base + 3 * 16 + 2),
Some(0x03e0)
);
assert_eq!(
edge_loaded
.memory
.read_u16_be(edge_front_base + 5 * 16 + 2 * 2),
Some(0)
);
let (mut point_loaded, point_front_base, point_stats) =
render_with_fill_style(PPC_Q3_FILL_STYLE_POINTS);
assert_eq!(point_stats.commands, 1);
assert_eq!(point_stats.triangles, 1);
assert_eq!(point_stats.pixels, 3);
assert_eq!(
point_loaded
.memory
.read_u16_be(point_front_base + 6 * 16 + 2),
Some(0x03e0)
);
assert_eq!(
point_loaded
.memory
.read_u16_be(point_front_base + 3 * 16 + 2),
Some(0)
);
}
#[test]
fn q3_software_renderer_uses_trimesh_edge_attributes_for_edge_fill() {
let view = PPC_Q3_OBJECT_BASE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let edges_ptr = PPC_DATA_BASE + 0x1180;
let edge_attrs_ptr = PPC_DATA_BASE + 0x1200;
let edge_colors_ptr = PPC_DATA_BASE + 0x1280;
let edge_alphas_ptr = PPC_DATA_BASE + 0x1300;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x600]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_EDGES_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_EDGES_OFFSET, edges_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
2,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
edge_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
for (index, point) in [(-0.8, -0.8, 0.0), (-0.8, 0.8, 0.0), (0.8, -0.8, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
}
for (offset, index) in [0u32, 1, 2].into_iter().enumerate() {
loaded
.memory
.write_u32_be(triangles_ptr + offset as u32 * 4, index)
.unwrap();
}
for (index, (a, b)) in [(0u32, 1u32), (1, 2), (2, 0)].into_iter().enumerate() {
let edge_ptr = edges_ptr + index as u32 * PPC_Q3_TRIMESH_EDGE_DATA_SIZE;
loaded.memory.write_u32_be(edge_ptr, a).unwrap();
loaded.memory.write_u32_be(edge_ptr + 4, b).unwrap();
}
loaded
.memory
.write_u32_be(edge_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR)
.unwrap();
loaded
.memory
.write_u32_be(edge_attrs_ptr + 4, edge_colors_ptr)
.unwrap();
loaded.memory.write_u32_be(edge_attrs_ptr + 8, 0).unwrap();
loaded
.memory
.write_u32_be(
edge_attrs_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE,
PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
)
.unwrap();
loaded
.memory
.write_u32_be(
edge_attrs_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE + 4,
edge_alphas_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(edge_attrs_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE + 8, 0)
.unwrap();
for (index, color) in [(1.0, 0.0, 0.0), (0.0, 0.0, 1.0), (0.0, 1.0, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_color_rgb(
&mut loaded.memory,
edge_colors_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
color,
)
.unwrap();
}
for (index, alpha) in [(1.0, 1.0, 1.0), (0.5, 0.5, 0.5), (1.0, 1.0, 1.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_color_rgb(
&mut loaded.memory,
edge_alphas_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
alpha,
)
.unwrap();
}
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
}],
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 3 * 16 + 2),
Some(0x7c00)
);
assert_eq!(
loaded.memory.read_u16_be(front_base + 3 * 16 + 3 * 2),
Some(0x0010)
);
assert_eq!(
loaded.memory.read_u16_be(front_base + 6 * 16 + 3 * 2),
Some(0x03e0)
);
}
#[test]
fn q3_software_renderer_uses_edge_specular_attributes_for_edge_fill() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let edges_ptr = PPC_DATA_BASE + 0x1180;
let edge_attrs_ptr = PPC_DATA_BASE + 0x1200;
let edge_specular_colors_ptr = PPC_DATA_BASE + 0x1280;
let edge_specular_controls_ptr = PPC_DATA_BASE + 0x1300;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1380;
let normals_ptr = PPC_DATA_BASE + 0x1400;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x600]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_EDGES_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_EDGES_OFFSET, edges_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
2,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
edge_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
for (index, point) in [(-0.8, -0.8, 0.0), (-0.8, 0.8, 0.0), (0.8, -0.8, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
ppc_write_q3_vector3d(
&mut loaded.memory,
normals_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
}
for (offset, index) in [0u32, 1, 2].into_iter().enumerate() {
loaded
.memory
.write_u32_be(triangles_ptr + offset as u32 * 4, index)
.unwrap();
}
for (index, (a, b)) in [(0u32, 1u32), (1, 2), (2, 0)].into_iter().enumerate() {
let edge_ptr = edges_ptr + index as u32 * PPC_Q3_TRIMESH_EDGE_DATA_SIZE;
loaded.memory.write_u32_be(edge_ptr, a).unwrap();
loaded.memory.write_u32_be(edge_ptr + 4, b).unwrap();
}
for (index, (attribute_type, data_ptr)) in [
(
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
edge_specular_colors_ptr,
),
(
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
edge_specular_controls_ptr,
),
]
.into_iter()
.enumerate()
{
let entry_ptr = edge_attrs_ptr + index as u32 * PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE;
loaded
.memory
.write_u32_be(entry_ptr, attribute_type)
.unwrap();
loaded.memory.write_u32_be(entry_ptr + 4, data_ptr).unwrap();
loaded.memory.write_u32_be(entry_ptr + 8, 0).unwrap();
}
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, normals_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
for index in 0..3 {
ppc_write_q3_color_rgb(
&mut loaded.memory,
edge_specular_colors_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
ppc_write_f32_be(
&mut loaded.memory,
edge_specular_controls_ptr + index * 4,
1.0,
)
.unwrap();
}
let specular_control = 1.0f32.to_bits().to_be_bytes().to_vec();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
}],
fog_style: None,
attributes: vec![
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[0.0, 0.0, 0.0],
),
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
[1.0, 0.0, 0.0],
),
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
data: specular_control,
},
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 3 * 16 + 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_uses_edge_normals_for_edge_fill_directional_lights() {
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let edges_ptr = PPC_DATA_BASE + 0x1180;
let edge_attrs_ptr = PPC_DATA_BASE + 0x1200;
let edge_normals_ptr = PPC_DATA_BASE + 0x1280;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_EDGES_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_EDGES_OFFSET, edges_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
edge_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
for (index, point) in [(-0.8, -0.8, 0.0), (-0.8, 0.8, 0.0), (0.8, -0.8, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
}
for (offset, index) in [0u32, 1, 2].into_iter().enumerate() {
loaded
.memory
.write_u32_be(triangles_ptr + offset as u32 * 4, index)
.unwrap();
}
for (index, (a, b)) in [(0u32, 1u32), (1, 2), (2, 0)].into_iter().enumerate() {
let edge_ptr = edges_ptr + index as u32 * PPC_Q3_TRIMESH_EDGE_DATA_SIZE;
loaded.memory.write_u32_be(edge_ptr, a).unwrap();
loaded.memory.write_u32_be(edge_ptr + 4, b).unwrap();
}
loaded
.memory
.write_u32_be(edge_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
.unwrap();
loaded
.memory
.write_u32_be(edge_attrs_ptr + 4, edge_normals_ptr)
.unwrap();
loaded.memory.write_u32_be(edge_attrs_ptr + 8, 0).unwrap();
for (index, normal) in [(0.0, 0.0, 1.0), (1.0, 0.0, 0.0), (1.0, 0.0, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
edge_normals_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
normal,
)
.unwrap();
}
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_LAMBERT,
styles: vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
}],
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (0.0, 1.0, 0.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 3 * 16 + 2),
Some(0x03e0)
);
assert_eq!(
loaded.memory.read_u16_be(front_base + 6 * 16 + 3 * 2),
Some(0)
);
}
#[test]
fn q3_software_renderer_uses_edge_ambient_coefficients_for_edge_fill() {
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let edges_ptr = PPC_DATA_BASE + 0x1180;
let edge_attrs_ptr = PPC_DATA_BASE + 0x1200;
let edge_ambient_coefficients_ptr = PPC_DATA_BASE + 0x1280;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_EDGES_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_EDGES_OFFSET, edges_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
edge_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(edge_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT)
.unwrap();
loaded
.memory
.write_u32_be(edge_attrs_ptr + 4, edge_ambient_coefficients_ptr)
.unwrap();
loaded.memory.write_u32_be(edge_attrs_ptr + 8, 0).unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
for (index, point) in [(-0.8, -0.8, 0.0), (-0.8, 0.8, 0.0), (0.8, -0.8, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
}
for (offset, index) in [0u32, 1, 2].into_iter().enumerate() {
loaded
.memory
.write_u32_be(triangles_ptr + offset as u32 * 4, index)
.unwrap();
}
for (index, (a, b)) in [(0u32, 1u32), (1, 2), (2, 0)].into_iter().enumerate() {
let edge_ptr = edges_ptr + index as u32 * PPC_Q3_TRIMESH_EDGE_DATA_SIZE;
loaded.memory.write_u32_be(edge_ptr, a).unwrap();
loaded.memory.write_u32_be(edge_ptr + 4, b).unwrap();
}
for (index, coefficient) in [0.25f32, 0.0, 0.0].into_iter().enumerate() {
ppc_write_f32_be(
&mut loaded.memory,
edge_ambient_coefficients_ptr + index as u32 * 4,
coefficient,
)
.unwrap();
}
let ambient_zero = 0.0f32.to_bits().to_be_bytes().to_vec();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
}],
fog_style: None,
attributes: vec![
diffuse_attribute(attribute_set),
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT,
data: ambient_zero,
},
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 0.0, 0.0),
},
kind: PpcQ3LightKind::Ambient,
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 3 * 16 + 2),
Some(0x2000)
);
assert_eq!(
loaded.memory.read_u16_be(front_base + 6 * 16 + 3 * 2),
Some(0)
);
}
#[test]
fn q3_software_renderer_respects_backfacing_remove_style() {
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [0.0f32, 1.0, 0.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
fn render_with_backfacing_style(
backfacing_style: u32,
orientation_style: Option<u32>,
) -> (PpcLoadedApp, u32, PpcQ3SoftwareRenderStats) {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1200;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 2)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 6)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
for (index, point) in [
(-0.9, -0.8, 0.0),
(-0.1, -0.8, 0.0),
(-0.9, 0.8, 0.0),
(0.1, -0.8, 0.0),
(0.1, 0.8, 0.0),
(0.9, -0.8, 0.0),
]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
}
for (offset, index) in [0u32, 1, 2, 3, 4, 5].into_iter().enumerate() {
loaded
.memory
.write_u32_be(triangles_ptr + offset as u32 * 4, index)
.unwrap();
}
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
let mut styles = vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Backfacing,
value: backfacing_style,
}];
if let Some(orientation_style) = orientation_style {
styles.push(PpcQ3StyleRecord {
style: style + PPC_Q3_OBJECT_STRIDE,
kind: PpcQ3StyleKind::Orientation,
value: orientation_style,
});
}
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles,
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
(loaded, front_base, stats)
}
let (mut both_loaded, both_front_base, both_stats) =
render_with_backfacing_style(PPC_Q3_BACKFACING_STYLE_BOTH, None);
assert_eq!(both_stats.triangles, 2);
assert_eq!(
both_loaded
.memory
.read_u16_be(both_front_base + 5 * 16 + 2),
Some(0x03e0)
);
assert_eq!(
both_loaded
.memory
.read_u16_be(both_front_base + 5 * 16 + 5 * 2),
Some(0x03e0)
);
let (mut remove_loaded, remove_front_base, remove_stats) =
render_with_backfacing_style(PPC_Q3_BACKFACING_STYLE_REMOVE, None);
assert_eq!(remove_stats.triangles, 1);
assert_eq!(
remove_loaded
.memory
.read_u16_be(remove_front_base + 5 * 16 + 2),
Some(0)
);
assert_eq!(
remove_loaded
.memory
.read_u16_be(remove_front_base + 5 * 16 + 5 * 2),
Some(0x03e0)
);
let (mut clockwise_loaded, clockwise_front_base, clockwise_stats) =
render_with_backfacing_style(
PPC_Q3_BACKFACING_STYLE_REMOVE,
Some(PPC_Q3_ORIENTATION_STYLE_CLOCKWISE),
);
assert_eq!(clockwise_stats.triangles, 1);
assert_eq!(
clockwise_loaded
.memory
.read_u16_be(clockwise_front_base + 5 * 16 + 2),
Some(0x03e0)
);
assert_eq!(
clockwise_loaded
.memory
.read_u16_be(clockwise_front_base + 5 * 16 + 5 * 2),
Some(0)
);
}
#[test]
fn q3_software_renderer_flips_backfacing_normals_for_flip_style() {
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
fn render_with_backfacing_style(
backfacing_style: u32,
) -> (PpcLoadedApp, u32, PpcQ3SoftwareRenderStats) {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1200;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1280;
let normals_ptr = PPC_DATA_BASE + 0x12c0;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, normals_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
for (index, point) in [(0.1, -0.8, 0.0), (0.9, -0.8, 0.0), (0.1, 0.8, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
ppc_write_q3_vector3d(
&mut loaded.memory,
normals_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, -1.0),
)
.unwrap();
}
for (offset, index) in [0u32, 1, 2].into_iter().enumerate() {
loaded
.memory
.write_u32_be(triangles_ptr + offset as u32 * 4, index)
.unwrap();
}
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Backfacing,
value: backfacing_style,
}],
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (0.0, 1.0, 0.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
(loaded, front_base, stats)
}
let (mut both_loaded, both_front_base, both_stats) =
render_with_backfacing_style(PPC_Q3_BACKFACING_STYLE_BOTH);
assert_eq!(both_stats.triangles, 1);
assert_eq!(
both_loaded
.memory
.read_u16_be(both_front_base + 5 * 16 + 5 * 2),
Some(0)
);
let (mut flip_loaded, flip_front_base, flip_stats) =
render_with_backfacing_style(PPC_Q3_BACKFACING_STYLE_FLIP);
assert_eq!(flip_stats.triangles, 1);
assert_eq!(
flip_loaded
.memory
.read_u16_be(flip_front_base + 5 * 16 + 5 * 2),
Some(0x03e0)
);
}
#[test]
fn q3_software_renderer_fills_trimeshes_with_depth_testing() {
fn write_triangle_mesh(
memory: &mut PpcSectionMem,
trimesh_data: u32,
points_ptr: u32,
triangles_ptr: u32,
z: f32,
) {
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(memory, points_ptr, (-0.8, -0.8, z)).unwrap();
ppc_write_q3_vector3d(memory, points_ptr + 12, (-0.8, 0.8, z)).unwrap();
ppc_write_q3_vector3d(memory, points_ptr + 24, (0.8, -0.8, z)).unwrap();
memory.write_u32_be(triangles_ptr, 0).unwrap();
memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
}
fn diffuse_attribute(attribute_set: u32, rgb: [f32; 3]) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let near_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let far_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let near_trimesh_data = PPC_DATA_BASE + 0x1000;
let near_points_ptr = PPC_DATA_BASE + 0x1080;
let near_triangles_ptr = PPC_DATA_BASE + 0x1100;
let far_trimesh_data = PPC_DATA_BASE + 0x1200;
let far_points_ptr = PPC_DATA_BASE + 0x1280;
let far_triangles_ptr = PPC_DATA_BASE + 0x1300;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(near_trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
write_triangle_mesh(
&mut loaded.memory,
near_trimesh_data,
near_points_ptr,
near_triangles_ptr,
-0.5,
);
write_triangle_mesh(
&mut loaded.memory,
far_trimesh_data,
far_points_ptr,
far_triangles_ptr,
0.5,
);
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
for (trimesh_data, attribute_set, rgb) in [
(near_trimesh_data, near_attribute_set, [0.0, 0.0, 1.0]),
(far_trimesh_data, far_attribute_set, [1.0, 0.0, 0.0]),
] {
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set, rgb)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
}
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 2);
assert_eq!(stats.vertices, 6);
assert_eq!(stats.triangles, 2);
assert!(stats.pixels >= 15);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 3 * 2),
Some(0x001f)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 3 * 2),
Some(0x7c00)
);
}
#[test]
fn q3_software_renderer_sorts_transparent_filled_triangles_back_to_front() {
fn write_triangle_mesh(
memory: &mut PpcSectionMem,
trimesh_data: u32,
points_ptr: u32,
triangles_ptr: u32,
z: f32,
) {
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(memory, points_ptr, (-0.8, -0.8, z)).unwrap();
ppc_write_q3_vector3d(memory, points_ptr + 12, (-0.8, 0.8, z)).unwrap();
ppc_write_q3_vector3d(memory, points_ptr + 24, (0.8, -0.8, z)).unwrap();
memory.write_u32_be(triangles_ptr, 0).unwrap();
memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
}
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let near_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let far_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let near_trimesh_data = PPC_DATA_BASE + 0x1000;
let near_points_ptr = PPC_DATA_BASE + 0x1080;
let near_triangles_ptr = PPC_DATA_BASE + 0x1100;
let far_trimesh_data = PPC_DATA_BASE + 0x1200;
let far_points_ptr = PPC_DATA_BASE + 0x1280;
let far_triangles_ptr = PPC_DATA_BASE + 0x1300;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(near_trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
write_triangle_mesh(
&mut loaded.memory,
near_trimesh_data,
near_points_ptr,
near_triangles_ptr,
-0.5,
);
write_triangle_mesh(
&mut loaded.memory,
far_trimesh_data,
far_points_ptr,
far_triangles_ptr,
0.5,
);
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
for (trimesh_data, attribute_set, rgb) in [
(near_trimesh_data, near_attribute_set, [1.0, 0.0, 0.0]),
(far_trimesh_data, far_attribute_set, [0.0, 0.0, 1.0]),
] {
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
color_attribute(attribute_set, PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR, rgb),
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
[0.5, 0.5, 0.5],
),
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
}
let stats = loaded.render_q3_scene_commands_to_front_buffer();
let far_over_black =
ppc_q3_blend_transparency_color((0.0, 0.0, 1.0), (0.0, 0.0, 0.0), (0.5, 0.5, 0.5));
let expected = ppc_q3_rgb555(ppc_q3_blend_transparency_color(
(1.0, 0.0, 0.0),
far_over_black,
(0.5, 0.5, 0.5),
));
let near_only = ppc_q3_rgb555(ppc_q3_blend_transparency_color(
(1.0, 0.0, 0.0),
(0.0, 0.0, 0.0),
(0.5, 0.5, 0.5),
));
assert_eq!(stats.commands, 2);
assert_eq!(stats.vertices, 6);
assert_eq!(stats.triangles, 2);
assert!(stats.pixels >= 30);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 3 * 2),
Some(expected)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 3 * 2),
Some(near_only)
);
}
#[test]
fn q3_software_renderer_sorts_transparent_points_and_edges_back_to_front() {
fn write_trimesh(
memory: &mut PpcSectionMem,
trimesh_data: u32,
points_ptr: u32,
triangles_ptr: u32,
z: f32,
use_triangles: bool,
) {
let points = if use_triangles {
[(-0.8, -0.8, z), (-0.8, 0.8, z), (0.8, -0.8, z)]
} else {
[(0.0, 0.0, z), (0.0, 0.0, z), (0.0, 0.0, z)]
};
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET,
if use_triangles { 3 } else { 1 },
)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
for (index, point) in points.into_iter().enumerate() {
ppc_write_q3_vector3d(
memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
}
if use_triangles {
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
for (offset, index) in [0u32, 1, 2].into_iter().enumerate() {
memory
.write_u32_be(triangles_ptr + offset as u32 * 4, index)
.unwrap();
}
}
}
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
fn render_case(
fill_style: u32,
use_triangles: bool,
sample_x: u32,
sample_y: u32,
) -> (PpcLoadedApp, u32, PpcQ3SoftwareRenderStats, u16) {
let view = PPC_Q3_OBJECT_BASE;
let near_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let far_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let near_trimesh_data = PPC_DATA_BASE + 0x1000;
let near_points_ptr = PPC_DATA_BASE + 0x1080;
let near_triangles_ptr = PPC_DATA_BASE + 0x1100;
let far_trimesh_data = PPC_DATA_BASE + 0x1200;
let far_points_ptr = PPC_DATA_BASE + 0x1280;
let far_triangles_ptr = PPC_DATA_BASE + 0x1300;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(near_trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
write_trimesh(
&mut loaded.memory,
near_trimesh_data,
near_points_ptr,
near_triangles_ptr,
-0.5,
use_triangles,
);
write_trimesh(
&mut loaded.memory,
far_trimesh_data,
far_points_ptr,
far_triangles_ptr,
0.5,
use_triangles,
);
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
for (trimesh_data, attribute_set, rgb) in [
(near_trimesh_data, near_attribute_set, [1.0, 0.0, 0.0]),
(far_trimesh_data, far_attribute_set, [0.0, 0.0, 1.0]),
] {
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: fill_style,
}],
fog_style: None,
attributes: vec![
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
rgb,
),
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
[0.5, 0.5, 0.5],
),
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
}
let stats = loaded.render_q3_scene_commands_to_front_buffer();
let pixel = loaded
.memory
.read_u16_be(front_base + sample_y * 16 + sample_x * 2)
.unwrap();
(loaded, front_base, stats, pixel)
}
let far_over_black =
ppc_q3_blend_transparency_color((0.0, 0.0, 1.0), (0.0, 0.0, 0.0), (0.5, 0.5, 0.5));
let expected = ppc_q3_rgb555(ppc_q3_blend_transparency_color(
(1.0, 0.0, 0.0),
far_over_black,
(0.5, 0.5, 0.5),
));
let (_point_loaded, _point_front_base, point_stats, point_pixel) =
render_case(PPC_Q3_FILL_STYLE_POINTS, false, 4, 4);
assert_eq!(point_stats.commands, 2);
assert_eq!(point_stats.vertices, 2);
assert_eq!(point_stats.triangles, 0);
assert_eq!(point_stats.pixels, 2);
assert_eq!(point_pixel, expected);
let (_edge_loaded, _edge_front_base, edge_stats, edge_pixel) =
render_case(PPC_Q3_FILL_STYLE_EDGES, true, 1, 3);
assert_eq!(edge_stats.commands, 2);
assert_eq!(edge_stats.vertices, 6);
assert_eq!(edge_stats.triangles, 2);
assert!(edge_stats.pixels > 0);
assert_eq!(edge_pixel, expected);
}
#[test]
fn q3_software_renderer_blends_transparency_color_with_front_buffer() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut front_buffer_bytes = Vec::new();
for _ in 0..64 {
front_buffer_bytes.extend_from_slice(&0x001fu16.to_be_bytes());
}
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(front_base, front_buffer_bytes);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[1.0, 0.0, 0.0],
),
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
[0.25, 0.25, 0.25],
),
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x2017)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x7c00)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_material_blend_opacity_multiplies_texture_and_vertex_alpha() {
let material = PpcQ3SoftwareMaterialSample {
diffuse: (1.0, 1.0, 1.0),
ambient_coefficient: 1.0,
specular_color: (0.0, 0.0, 0.0),
specular_control: 0.0,
highlight_state: true,
transparency: (1.0, 1.0, 1.0),
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
texture: None,
uv_transform: None,
shader_boundary: None,
fog_style: None,
};
assert_eq!(
ppc_q3_software_blend_opacity(&material, 0.5, Some(0.25)),
0.125
);
let alpha_fog_material = PpcQ3SoftwareMaterialSample {
fog_style: Some(PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_ALPHA,
fog_start: 0.0,
fog_end: 1.0,
density: 1.0,
color: (0.0, 0.0, 0.0, 1.0),
}),
..material
};
assert_eq!(
ppc_q3_software_blend_opacity(&alpha_fog_material, 0.5, Some(0.25)),
0.5
);
}
#[test]
fn q3_software_renderer_blends_vertex_transparency_color_with_front_buffer() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let vertex_transparency_ptr = PPC_DATA_BASE + 0x1200;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut front_buffer_bytes = Vec::new();
for _ in 0..64 {
front_buffer_bytes.extend_from_slice(&0x001fu16.to_be_bytes());
}
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, front_buffer_bytes);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, vertex_transparency_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
for index in 0..3 {
ppc_write_q3_color_rgb(
&mut loaded.memory,
vertex_transparency_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.25, 0.25, 0.25),
)
.unwrap();
}
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[1.0, 0.0, 0.0],
)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x2017)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x7c00)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_uses_triangle_diffuse_and_transparency_colors() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let triangle_attrs_ptr = PPC_DATA_BASE + 0x1180;
let triangle_diffuse_ptr = PPC_DATA_BASE + 0x1200;
let triangle_transparency_ptr = PPC_DATA_BASE + 0x1240;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut front_buffer_bytes = Vec::new();
for _ in 0..64 {
front_buffer_bytes.extend_from_slice(&0x001fu16.to_be_bytes());
}
loaded.memory.add_region(trimesh_data, vec![0; 0x500]);
loaded.memory.add_region(front_base, front_buffer_bytes);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
2,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
triangle_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(triangle_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR)
.unwrap();
loaded
.memory
.write_u32_be(triangle_attrs_ptr + 4, triangle_diffuse_ptr)
.unwrap();
loaded
.memory
.write_u32_be(triangle_attrs_ptr + 8, 0)
.unwrap();
loaded
.memory
.write_u32_be(
triangle_attrs_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE,
PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
)
.unwrap();
loaded
.memory
.write_u32_be(
triangle_attrs_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE + 4,
triangle_transparency_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(
triangle_attrs_ptr + PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE + 8,
0,
)
.unwrap();
ppc_write_q3_color_rgb(&mut loaded.memory, triangle_diffuse_ptr, (0.0, 1.0, 0.0)).unwrap();
ppc_write_q3_color_rgb(
&mut loaded.memory,
triangle_transparency_ptr,
(0.25, 0.25, 0.25),
)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[1.0, 0.0, 0.0],
)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x0117)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x2017)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x03e0)
);
}
#[test]
fn q3_software_renderer_uses_vertex_diffuse_colors() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let vertex_colors_ptr = PPC_DATA_BASE + 0x1200;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, vertex_colors_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
for index in 0..3 {
ppc_write_q3_color_rgb(
&mut loaded.memory,
vertex_colors_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
}
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[1.0, 0.0, 0.0],
)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x7c00)
);
}
#[test]
fn q3_software_renderer_applies_captured_light_colors_to_materials() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let off_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let mut diffuse = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5,
lights: vec![
PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.5,
color: (1.0, 0.0, 0.0),
},
kind: PpcQ3LightKind::Ambient,
},
PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.25,
color: (0.0, 1.0, 0.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
// The triangle winding produces a -Z surface normal.
direction: (0.0, 0.0, 1.0),
},
},
PpcQ3LightRecord {
light: off_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 0,
brightness: 1.0,
color: (0.0, 0.0, 1.0),
},
kind: PpcQ3LightKind::Ambient,
},
],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x4100)
);
// Omitting diffuse attributes uses the view's half-grey material,
// so both enabled light channels contribute half the previous color.
loaded.q3_submission_materials[0].attributes.clear();
loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x2080)
);
}
#[test]
fn q3_software_renderer_applies_ambient_coefficient_to_ambient_lights() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let mut diffuse = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let ambient_coefficient = 0.25f32.to_bits().to_be_bytes().to_vec();
let material = PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_DATA_BASE,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
},
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT,
data: ambient_coefficient,
},
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
};
let lights = PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_DATA_BASE,
secondary: 0,
light_group: 0,
lights: vec![
PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 0.0, 0.0),
},
kind: PpcQ3LightKind::Ambient,
},
PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (0.0, 1.0, 0.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
},
],
};
let sample = ppc_q3_software_material_sample(&[], &[], &material);
let mut memory = PpcSectionMem::new();
assert_eq!(
ppc_q3_rgb555(ppc_q3_software_material_color(
&mut memory,
&sample,
&lights,
None,
None,
None,
None,
None,
0.0,
None,
)),
0x23e0
);
}
#[test]
fn q3_software_renderer_uses_vertex_ambient_coefficients_for_ambient_lights() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let ambient_coefficients_ptr = PPC_DATA_BASE + 0x1200;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, ambient_coefficients_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
for index in 0..3 {
ppc_write_f32_be(
&mut loaded.memory,
ambient_coefficients_ptr + index * 4,
0.25,
)
.unwrap();
}
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let mut diffuse = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let ambient_zero = 0.0f32.to_bits().to_be_bytes().to_vec();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
},
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT,
data: ambient_zero,
},
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 0.0, 0.0),
},
kind: PpcQ3LightKind::Ambient,
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x2000)
);
}
#[test]
fn q3_software_renderer_uses_triangle_ambient_coefficients_for_ambient_lights() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let triangle_attrs_ptr = PPC_DATA_BASE + 0x1180;
let ambient_coefficient_ptr = PPC_DATA_BASE + 0x1200;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
triangle_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(
triangle_attrs_ptr,
PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT,
)
.unwrap();
loaded
.memory
.write_u32_be(triangle_attrs_ptr + 4, ambient_coefficient_ptr)
.unwrap();
loaded
.memory
.write_u32_be(triangle_attrs_ptr + 8, 0)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
ppc_write_f32_be(&mut loaded.memory, ambient_coefficient_ptr, 0.25).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let mut diffuse = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let ambient_zero = 0.0f32.to_bits().to_be_bytes().to_vec();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
},
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT,
data: ambient_zero,
},
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 0.0, 0.0),
},
kind: PpcQ3LightKind::Ambient,
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x2000)
);
}
#[test]
fn q3_software_renderer_honors_illumination_shader_model() {
let view = PPC_Q3_OBJECT_BASE;
let light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let lights = PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_DATA_BASE,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
};
let mut memory = PpcSectionMem::new();
let sample = PpcQ3SoftwareMaterialSample {
diffuse: (0.25, 0.25, 0.25),
ambient_coefficient: 0.0,
specular_color: (0.5, 0.5, 0.5),
specular_control: 1.0,
highlight_state: true,
transparency: (1.0, 1.0, 1.0),
illumination_type: PPC_Q3_ILLUMINATION_TYPE_NULL,
texture: None,
uv_transform: None,
shader_boundary: None,
fog_style: None,
};
let null_color = ppc_q3_software_material_color(
&mut memory,
&sample,
&lights,
None,
None,
Some((0.0, 0.0, 1.0)),
None,
None,
0.0,
None,
);
let lambert_color = ppc_q3_software_material_color(
&mut memory,
&PpcQ3SoftwareMaterialSample {
illumination_type: PPC_Q3_ILLUMINATION_TYPE_LAMBERT,
..sample
},
&lights,
None,
None,
Some((0.0, 0.0, 1.0)),
None,
None,
0.0,
None,
);
let phong_color = ppc_q3_software_material_color(
&mut memory,
&PpcQ3SoftwareMaterialSample {
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
..sample
},
&lights,
None,
None,
Some((0.0, 0.0, 1.0)),
None,
None,
0.0,
None,
);
assert_eq!(null_color, (0.25, 0.25, 0.25));
assert_eq!(lambert_color, (0.25, 0.25, 0.25));
assert_eq!(phong_color, (0.75, 0.75, 0.75));
}
#[test]
fn q3_software_renderer_honors_highlight_state_for_phong_specular() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
fn scalar_attribute(
attribute_set: u32,
attribute_type: u32,
value: f32,
) -> PpcQ3AttributeRecord {
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data: value.to_bits().to_be_bytes().to_vec(),
}
}
fn switch_attribute(attribute_set: u32, value: u32) -> PpcQ3AttributeRecord {
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE,
data: value.to_be_bytes().to_vec(),
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let lights = PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_DATA_BASE,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
};
let material_with_highlight_state = |highlight_state| PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_DATA_BASE,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[0.25, 0.25, 0.25],
),
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
[0.5, 0.5, 0.5],
),
scalar_attribute(attribute_set, PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL, 1.0),
switch_attribute(attribute_set, highlight_state),
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
};
let mut memory = PpcSectionMem::new();
let highlighted =
ppc_q3_software_material_sample(&[], &[], &material_with_highlight_state(1));
let muted = ppc_q3_software_material_sample(&[], &[], &material_with_highlight_state(0));
assert_eq!(
ppc_q3_software_material_color(
&mut memory,
&highlighted,
&lights,
None,
None,
Some((0.0, 0.0, 1.0)),
None,
None,
0.0,
None,
),
(0.75, 0.75, 0.75)
);
assert_eq!(
ppc_q3_software_material_color(
&mut memory,
&muted,
&lights,
None,
None,
Some((0.0, 0.0, 1.0)),
None,
None,
0.0,
None,
),
(0.25, 0.25, 0.25)
);
}
fn q3_software_test_color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
fn q3_software_test_scalar_attribute(
attribute_set: u32,
attribute_type: u32,
value: f32,
) -> PpcQ3AttributeRecord {
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data: value.to_bits().to_be_bytes().to_vec(),
}
}
fn q3_software_test_write_attribute_entry(
memory: &mut PpcSectionMem,
attrs_ptr: u32,
index: usize,
attribute_type: u32,
data_ptr: u32,
) {
let entry_ptr = attrs_ptr + index as u32 * PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE;
memory.write_u32_be(entry_ptr, attribute_type).unwrap();
memory.write_u32_be(entry_ptr + 4, data_ptr).unwrap();
memory.write_u32_be(entry_ptr + 8, 0).unwrap();
}
fn q3_software_test_front_gworld(front_base: u32) -> PpcGWorldRecord {
PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}
}
fn q3_software_test_push_phong_specular_submission(
loaded: &mut PpcLoadedApp,
view: u32,
trimesh_data: u32,
attribute_set: u32,
styles: Vec<PpcQ3StyleRecord>,
directional_light: u32,
) {
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles,
fog_style: None,
attributes: vec![
q3_software_test_color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[0.0, 0.0, 0.0],
),
q3_software_test_color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
[1.0, 0.0, 0.0],
),
q3_software_test_scalar_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
1.0,
),
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
});
}
#[test]
fn q3_software_renderer_honors_vertex_highlight_states_for_phong_specular() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let normals_ptr = PPC_DATA_BASE + 0x1200;
let highlight_states_ptr = PPC_DATA_BASE + 0x1280;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut front_buffer_bytes = Vec::new();
for _ in 0..64 {
front_buffer_bytes.extend_from_slice(&0x7c00u16.to_be_bytes());
}
loaded.memory.add_region(trimesh_data, vec![0; 0x500]);
loaded.memory.add_region(front_base, front_buffer_bytes);
loaded.gworlds = vec![q3_software_test_front_gworld(front_base)];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
2,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
q3_software_test_write_attribute_entry(
&mut loaded.memory,
vertex_attrs_ptr,
0,
PPC_Q3_ATTRIBUTE_TYPE_NORMAL,
normals_ptr,
);
q3_software_test_write_attribute_entry(
&mut loaded.memory,
vertex_attrs_ptr,
1,
PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE,
highlight_states_ptr,
);
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
for index in 0..3 {
ppc_write_q3_vector3d(
&mut loaded.memory,
normals_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
loaded
.memory
.write_u32_be(highlight_states_ptr + index * 4, 0)
.unwrap();
}
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
q3_software_test_push_phong_specular_submission(
&mut loaded,
view,
trimesh_data,
attribute_set,
Vec::new(),
directional_light,
);
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0)
);
}
#[test]
fn q3_software_renderer_honors_triangle_highlight_states_for_phong_specular() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let triangle_attrs_ptr = PPC_DATA_BASE + 0x1180;
let highlight_states_ptr = PPC_DATA_BASE + 0x1200;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1280;
let normals_ptr = PPC_DATA_BASE + 0x1300;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut front_buffer_bytes = Vec::new();
for _ in 0..64 {
front_buffer_bytes.extend_from_slice(&0x7c00u16.to_be_bytes());
}
loaded.memory.add_region(trimesh_data, vec![0; 0x500]);
loaded.memory.add_region(front_base, front_buffer_bytes);
loaded.gworlds = vec![q3_software_test_front_gworld(front_base)];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
triangle_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
q3_software_test_write_attribute_entry(
&mut loaded.memory,
triangle_attrs_ptr,
0,
PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE,
highlight_states_ptr,
);
q3_software_test_write_attribute_entry(
&mut loaded.memory,
vertex_attrs_ptr,
0,
PPC_Q3_ATTRIBUTE_TYPE_NORMAL,
normals_ptr,
);
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
for index in 0..3 {
ppc_write_q3_vector3d(
&mut loaded.memory,
normals_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
}
loaded.memory.write_u32_be(highlight_states_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
q3_software_test_push_phong_specular_submission(
&mut loaded,
view,
trimesh_data,
attribute_set,
Vec::new(),
directional_light,
);
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0)
);
}
#[test]
fn q3_software_renderer_honors_edge_highlight_states_for_phong_specular() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let edges_ptr = PPC_DATA_BASE + 0x1180;
let edge_attrs_ptr = PPC_DATA_BASE + 0x1200;
let edge_specular_colors_ptr = PPC_DATA_BASE + 0x1280;
let edge_specular_controls_ptr = PPC_DATA_BASE + 0x1300;
let edge_highlight_states_ptr = PPC_DATA_BASE + 0x1380;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1400;
let normals_ptr = PPC_DATA_BASE + 0x1480;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut front_buffer_bytes = Vec::new();
for _ in 0..64 {
front_buffer_bytes.extend_from_slice(&0x7c00u16.to_be_bytes());
}
loaded.memory.add_region(trimesh_data, vec![0; 0x600]);
loaded.memory.add_region(front_base, front_buffer_bytes);
loaded.gworlds = vec![q3_software_test_front_gworld(front_base)];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_EDGES_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_EDGES_OFFSET, edges_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
3,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
edge_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
for (index, point) in [(-0.8, -0.8, 0.0), (-0.8, 0.8, 0.0), (0.8, -0.8, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
ppc_write_q3_vector3d(
&mut loaded.memory,
normals_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
}
for (offset, index) in [0u32, 1, 2].into_iter().enumerate() {
loaded
.memory
.write_u32_be(triangles_ptr + offset as u32 * 4, index)
.unwrap();
}
for (index, (a, b)) in [(0u32, 1u32), (1, 2), (2, 0)].into_iter().enumerate() {
let edge_ptr = edges_ptr + index as u32 * PPC_Q3_TRIMESH_EDGE_DATA_SIZE;
loaded.memory.write_u32_be(edge_ptr, a).unwrap();
loaded.memory.write_u32_be(edge_ptr + 4, b).unwrap();
}
for (index, (attribute_type, data_ptr)) in [
(
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
edge_specular_colors_ptr,
),
(
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
edge_specular_controls_ptr,
),
(
PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE,
edge_highlight_states_ptr,
),
]
.into_iter()
.enumerate()
{
q3_software_test_write_attribute_entry(
&mut loaded.memory,
edge_attrs_ptr,
index,
attribute_type,
data_ptr,
);
}
q3_software_test_write_attribute_entry(
&mut loaded.memory,
vertex_attrs_ptr,
0,
PPC_Q3_ATTRIBUTE_TYPE_NORMAL,
normals_ptr,
);
for index in 0..3 {
ppc_write_q3_color_rgb(
&mut loaded.memory,
edge_specular_colors_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
ppc_write_f32_be(
&mut loaded.memory,
edge_specular_controls_ptr + index * 4,
1.0,
)
.unwrap();
}
for (index, highlight_state) in [0u32, 1, 1].into_iter().enumerate() {
loaded
.memory
.write_u32_be(
edge_highlight_states_ptr + index as u32 * 4,
highlight_state,
)
.unwrap();
}
q3_software_test_push_phong_specular_submission(
&mut loaded,
view,
trimesh_data,
attribute_set,
vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Fill,
value: PPC_Q3_FILL_STYLE_EDGES,
}],
directional_light,
);
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 3 * 16 + 2),
Some(0)
);
assert_eq!(
loaded.memory.read_u16_be(front_base + 6 * 16 + 3 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_uses_camera_view_direction_for_specular_lights() {
let light = PpcQ3LightRecord {
light: PPC_Q3_OBJECT_BASE,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
};
let front_camera = PpcQ3CameraRecord {
camera: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
camera_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
placement: PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 5.0),
point_of_interest: (0.0, 0.0, 0.0),
up_vector: (0.0, 1.0, 0.0),
},
range_hither: 1.0,
range_yon: 10.0,
viewport_origin: (-1.0, 1.0),
viewport_width: 2.0,
viewport_height: 2.0,
projection: PpcQ3CameraProjection::ViewAngleAspect {
fov: std::f32::consts::FRAC_PI_2,
aspect_ratio_x_to_y: 1.0,
},
};
let front_view = ppc_q3_software_view_direction(Some(front_camera), (0.0, 0.0, 0.0));
assert_eq!(front_view, Some((0.0, 0.0, 1.0)));
assert_eq!(
ppc_q3_software_specular_contribution(
&light,
(0.0, 0.0, 1.0),
(0.0, 0.0, -1.0),
front_view,
1.0,
(1.0, 0.0, 0.0),
1.0,
),
Some((1.0, 0.0, 0.0))
);
assert_eq!(
ppc_q3_software_specular_contribution(
&light,
(0.0, 0.0, 1.0),
(0.0, 0.0, -1.0),
Some((0.0, 1.0, 0.0)),
1.0,
(1.0, 0.0, 0.0),
1.0,
),
None
);
// A zero exponent is a valid broad highlight, not an absent attribute.
assert_eq!(
ppc_q3_software_specular_contribution(
&light,
(0.0, 0.0, 1.0),
(0.0, 0.0, -1.0),
Some((0.0, 1.0, 1.0)),
1.0,
(0.5, 0.5, 0.5),
0.0,
),
Some((0.5, 0.5, 0.5))
);
}
#[test]
fn q3_software_renderer_applies_point_and_spot_specular_from_camera_view_direction() {
let view = PPC_Q3_OBJECT_BASE;
let point_light = PpcQ3LightRecord {
light: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
light_type: PPC_Q3_LIGHT_TYPE_POINT,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 0.0, 0.0),
},
kind: PpcQ3LightKind::Point {
casts_shadows: 0,
attenuation: PPC_Q3_ATTENUATION_TYPE_NONE,
location: (0.0, 0.0, 1.0),
},
};
let spot_light = PpcQ3LightRecord {
light: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2,
light_type: PPC_Q3_LIGHT_TYPE_SPOT,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (0.0, 1.0, 0.0),
},
kind: PpcQ3LightKind::Spot {
casts_shadows: 0,
attenuation: PPC_Q3_ATTENUATION_TYPE_NONE,
location: (0.0, 0.0, 1.0),
direction: (0.0, 0.0, -1.0),
hot_angle: 0.25,
outer_angle: 0.5,
fall_off: PPC_Q3_FALL_OFF_TYPE_NONE,
},
};
let lights = PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_DATA_BASE,
secondary: 0,
light_group: 0,
lights: vec![point_light, spot_light],
};
let phong_front = ppc_q3_software_apply_lights(
(0.0, 0.0, 0.0),
0.0,
(1.0, 1.0, 1.0),
1.0,
PPC_Q3_ILLUMINATION_TYPE_PHONG,
&lights,
Some((0.0, 0.0, 1.0)),
Some((0.0, 0.0, 0.0)),
Some((0.0, 0.0, 1.0)),
);
let phong_side = ppc_q3_software_apply_lights(
(0.0, 0.0, 0.0),
0.0,
(1.0, 1.0, 1.0),
1.0,
PPC_Q3_ILLUMINATION_TYPE_PHONG,
&lights,
Some((0.0, 0.0, 1.0)),
Some((0.0, 0.0, 0.0)),
Some((0.0, 1.0, 0.0)),
);
let lambert_front = ppc_q3_software_apply_lights(
(0.0, 0.0, 0.0),
0.0,
(1.0, 1.0, 1.0),
1.0,
PPC_Q3_ILLUMINATION_TYPE_LAMBERT,
&lights,
Some((0.0, 0.0, 1.0)),
Some((0.0, 0.0, 0.0)),
Some((0.0, 0.0, 1.0)),
);
assert_eq!(phong_front, (1.0, 1.0, 0.0));
assert_eq!(phong_side, (0.0, 0.0, 0.0));
assert_eq!(lambert_front, (0.0, 0.0, 0.0));
}
#[test]
fn q3_software_renderer_applies_point_attenuation_and_spot_falloff_scales() {
fn assert_close(actual: f32, expected: f32) {
assert!(
(actual - expected).abs() < 0.0001,
"expected {expected}, got {actual}"
);
}
let point_light = PpcQ3LightRecord {
light: PPC_Q3_OBJECT_BASE,
light_type: PPC_Q3_LIGHT_TYPE_POINT,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (0.0, 1.0, 0.0),
},
kind: PpcQ3LightKind::Point {
casts_shadows: 0,
attenuation: PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE,
location: (0.0, 0.0, 2.0),
},
};
let point_lights = PpcQ3SubmissionLightRecord {
view: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_DATA_BASE,
secondary: 0,
light_group: 0,
lights: vec![point_light],
};
let point_color = ppc_q3_software_apply_lights(
(1.0, 1.0, 1.0),
0.0,
(0.0, 0.0, 0.0),
0.0,
PPC_Q3_ILLUMINATION_TYPE_LAMBERT,
&point_lights,
Some((0.0, 0.0, 1.0)),
Some((0.0, 0.0, 0.0)),
Some((0.0, 0.0, 1.0)),
);
assert_close(point_color.0, 0.0);
assert_close(point_color.1, 0.5);
assert_close(point_color.2, 0.0);
let spot_angle = 0.5f32;
let spot_distance = 2.0f32;
let spot_light_direction = (spot_angle.sin(), 0.0, -spot_angle.cos());
let spot_world = (
spot_light_direction.0 * spot_distance,
0.0,
spot_light_direction.2 * spot_distance,
);
let spot_light = PpcQ3LightRecord {
light: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2,
light_type: PPC_Q3_LIGHT_TYPE_SPOT,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 0.0, 0.0),
},
kind: PpcQ3LightKind::Spot {
casts_shadows: 0,
attenuation: PPC_Q3_ATTENUATION_TYPE_NONE,
location: (0.0, 0.0, 0.0),
direction: (0.0, 0.0, -1.0),
hot_angle: 0.25,
outer_angle: 0.75,
fall_off: PPC_Q3_FALL_OFF_TYPE_LINEAR,
},
};
let spot_lights = PpcQ3SubmissionLightRecord {
view: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_DATA_BASE,
secondary: 0,
light_group: 0,
lights: vec![spot_light],
};
let spot_color = ppc_q3_software_apply_lights(
(1.0, 1.0, 1.0),
0.0,
(0.0, 0.0, 0.0),
0.0,
PPC_Q3_ILLUMINATION_TYPE_LAMBERT,
&spot_lights,
Some((
-spot_light_direction.0,
-spot_light_direction.1,
-spot_light_direction.2,
)),
Some(spot_world),
Some((0.0, 0.0, 1.0)),
);
assert_close(spot_color.0, 0.5);
assert_close(spot_color.1, 0.0);
assert_close(spot_color.2, 0.0);
}
#[test]
fn q3_software_light_helpers_cover_documented_attenuation_and_spot_falloff_modes() {
fn assert_close(actual: f32, expected: f32) {
assert!(
(actual - expected).abs() < 0.0001,
"expected {expected}, got {actual}"
);
}
let (direction, attenuation) = ppc_q3_software_point_light_direction_and_attenuation(
(0.0, 0.0, 0.0),
(0.0, 0.0, 2.0),
PPC_Q3_ATTENUATION_TYPE_NONE,
)
.unwrap();
assert_close(direction.0, 0.0);
assert_close(direction.1, 0.0);
assert_close(direction.2, -1.0);
assert_close(attenuation, 1.0);
let (_, attenuation) = ppc_q3_software_point_light_direction_and_attenuation(
(0.0, 0.0, 0.0),
(0.0, 0.0, 2.0),
PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE,
)
.unwrap();
assert_close(attenuation, 0.5);
let (_, attenuation) = ppc_q3_software_point_light_direction_and_attenuation(
(0.0, 0.0, 0.0),
(0.0, 0.0, 2.0),
PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE_SQUARED,
)
.unwrap();
assert_close(attenuation, 0.25);
assert_eq!(
ppc_q3_software_point_light_direction_and_attenuation(
(0.0, 0.0, 0.0),
(0.0, 0.0, 0.0),
PPC_Q3_ATTENUATION_TYPE_NONE,
),
None
);
let spot_direction = (0.0, 0.0, -1.0);
let center = (0.0, 0.0, -1.0);
let mid_angle = 0.5f32;
let mid = (mid_angle.sin(), 0.0, -mid_angle.cos());
let three_quarter_angle = 0.375f32;
let three_quarter = (three_quarter_angle.sin(), 0.0, -three_quarter_angle.cos());
let outside_angle = 0.8f32;
let outside = (outside_angle.sin(), 0.0, -outside_angle.cos());
assert_close(
ppc_q3_software_spot_factor(
center,
spot_direction,
0.25,
0.75,
PPC_Q3_FALL_OFF_TYPE_LINEAR,
)
.unwrap(),
1.0,
);
assert_close(
ppc_q3_software_spot_factor(mid, spot_direction, 0.25, 0.75, PPC_Q3_FALL_OFF_TYPE_NONE)
.unwrap(),
1.0,
);
assert_close(
ppc_q3_software_spot_factor(
mid,
spot_direction,
0.25,
0.75,
PPC_Q3_FALL_OFF_TYPE_LINEAR,
)
.unwrap(),
0.5,
);
assert_close(
ppc_q3_software_spot_factor(
mid,
spot_direction,
0.25,
0.75,
PPC_Q3_FALL_OFF_TYPE_EXPONENTIAL,
)
.unwrap(),
0.25,
);
assert_close(
ppc_q3_software_spot_factor(
three_quarter,
spot_direction,
0.25,
0.75,
PPC_Q3_FALL_OFF_TYPE_COSINE,
)
.unwrap(),
0.8535534,
);
assert_close(
ppc_q3_software_spot_factor(
outside,
spot_direction,
0.25,
0.75,
PPC_Q3_FALL_OFF_TYPE_LINEAR,
)
.unwrap(),
0.0,
);
}
#[test]
fn q3_software_renderer_applies_specular_attributes_to_directional_lights() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let normals_ptr = PPC_DATA_BASE + 0x1200;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, normals_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
for index in 0..3 {
ppc_write_q3_vector3d(
&mut loaded.memory,
normals_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
}
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let specular_control = 1.0f32.to_bits().to_be_bytes().to_vec();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[0.0, 0.0, 0.0],
),
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
[1.0, 0.0, 0.0],
),
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
data: specular_control,
},
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x7c00)
);
}
#[test]
fn q3_software_renderer_uses_vertex_specular_attributes_for_phong() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let normals_ptr = PPC_DATA_BASE + 0x1200;
let specular_colors_ptr = PPC_DATA_BASE + 0x1280;
let specular_controls_ptr = PPC_DATA_BASE + 0x1300;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x500]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
3,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
for (index, (attribute_type, data_ptr)) in [
(PPC_Q3_ATTRIBUTE_TYPE_NORMAL, normals_ptr),
(PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR, specular_colors_ptr),
(
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
specular_controls_ptr,
),
]
.into_iter()
.enumerate()
{
let entry_ptr = vertex_attrs_ptr + index as u32 * PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE;
loaded
.memory
.write_u32_be(entry_ptr, attribute_type)
.unwrap();
loaded.memory.write_u32_be(entry_ptr + 4, data_ptr).unwrap();
loaded.memory.write_u32_be(entry_ptr + 8, 0).unwrap();
}
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
for index in 0..3 {
ppc_write_q3_vector3d(
&mut loaded.memory,
normals_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
ppc_write_q3_color_rgb(
&mut loaded.memory,
specular_colors_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
ppc_write_f32_be(&mut loaded.memory, specular_controls_ptr + index * 4, 1.0).unwrap();
}
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let specular_control = 1.0f32.to_bits().to_be_bytes().to_vec();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[0.0, 0.0, 0.0],
),
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
[1.0, 0.0, 0.0],
),
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
data: specular_control,
},
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_uses_triangle_specular_attributes_for_phong() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let triangle_attrs_ptr = PPC_DATA_BASE + 0x1180;
let normals_ptr = PPC_DATA_BASE + 0x1200;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1280;
let specular_color_ptr = PPC_DATA_BASE + 0x1300;
let specular_control_ptr = PPC_DATA_BASE + 0x1340;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x500]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
2,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
triangle_attrs_ptr,
)
.unwrap();
for (index, (attribute_type, data_ptr)) in [
(PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR, specular_color_ptr),
(PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL, specular_control_ptr),
]
.into_iter()
.enumerate()
{
let entry_ptr = triangle_attrs_ptr + index as u32 * PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE;
loaded
.memory
.write_u32_be(entry_ptr, attribute_type)
.unwrap();
loaded.memory.write_u32_be(entry_ptr + 4, data_ptr).unwrap();
loaded.memory.write_u32_be(entry_ptr + 8, 0).unwrap();
}
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, normals_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
for index in 0..3 {
ppc_write_q3_vector3d(
&mut loaded.memory,
normals_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
}
ppc_write_q3_color_rgb(&mut loaded.memory, specular_color_ptr, (0.0, 0.0, 1.0)).unwrap();
ppc_write_f32_be(&mut loaded.memory, specular_control_ptr, 1.0).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let specular_control = 1.0f32.to_bits().to_be_bytes().to_vec();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[0.0, 0.0, 0.0],
),
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR,
[1.0, 0.0, 0.0],
),
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL,
data: specular_control,
},
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_uses_vertex_normals_for_directional_lights() {
fn write_lit_triangle_mesh(
memory: &mut PpcSectionMem,
trimesh_data: u32,
points_ptr: u32,
triangles_ptr: u32,
vertex_attrs_ptr: u32,
normals_ptr: u32,
points: [(f32, f32, f32); 3],
normal: (f32, f32, f32),
) {
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
.unwrap();
memory
.write_u32_be(vertex_attrs_ptr + 4, normals_ptr)
.unwrap();
memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
for (index, point) in points.into_iter().enumerate() {
ppc_write_q3_vector3d(memory, points_ptr + index as u32 * 12, point).unwrap();
ppc_write_q3_vector3d(memory, normals_ptr + index as u32 * 12, normal).unwrap();
}
memory.write_u32_be(triangles_ptr, 0).unwrap();
memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
}
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let ambient_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let front_base = PPC_HEAP_BASE + 0x1000;
let left_trimesh_data = PPC_DATA_BASE + 0x1000;
let left_points_ptr = PPC_DATA_BASE + 0x1080;
let left_triangles_ptr = PPC_DATA_BASE + 0x1100;
let left_vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let left_normals_ptr = PPC_DATA_BASE + 0x11c0;
let right_trimesh_data = PPC_DATA_BASE + 0x1200;
let right_points_ptr = PPC_DATA_BASE + 0x1280;
let right_triangles_ptr = PPC_DATA_BASE + 0x1300;
let right_vertex_attrs_ptr = PPC_DATA_BASE + 0x1380;
let right_normals_ptr = PPC_DATA_BASE + 0x13c0;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.memory
.add_region(PPC_DATA_BASE + 0x1000, vec![0; 0x800]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
write_lit_triangle_mesh(
&mut loaded.memory,
left_trimesh_data,
left_points_ptr,
left_triangles_ptr,
left_vertex_attrs_ptr,
left_normals_ptr,
[(-0.9, -0.8, 0.0), (-0.1, -0.8, 0.0), (-0.9, 0.8, 0.0)],
(0.0, 0.0, 1.0),
);
write_lit_triangle_mesh(
&mut loaded.memory,
right_trimesh_data,
right_points_ptr,
right_triangles_ptr,
right_vertex_attrs_ptr,
right_normals_ptr,
[(0.1, -0.8, 0.0), (0.9, -0.8, 0.0), (0.1, 0.8, 0.0)],
(0.0, 0.0, -1.0),
);
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
let lights = vec![
PpcQ3LightRecord {
light: ambient_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.25,
color: (1.0, 0.0, 0.0),
},
kind: PpcQ3LightKind::Ambient,
},
PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.75,
color: (0.0, 1.0, 0.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
},
];
for (index, (trimesh_data, attribute_set)) in [
(
left_trimesh_data,
PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3,
),
(
right_trimesh_data,
PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4,
),
]
.into_iter()
.enumerate()
{
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
// Isolate diffuse normal handling from specular highlights.
illumination_type: PPC_Q3_ILLUMINATION_TYPE_LAMBERT,
styles: Vec::new(),
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: index as u32,
lights: lights.clone(),
});
}
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 2);
assert_eq!(stats.triangles, 2);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 2),
Some(0x22e0)
);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 5 * 2),
Some(0x2000)
);
// Both triangles have counterclockwise geometry. Omitting the normal
// attributes must light both like the explicit +Z normal, rather than
// retaining the right triangle's deliberately opposing vertex normal.
for data in [left_trimesh_data, right_trimesh_data] {
loaded
.memory
.write_u32_be(data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET, 0)
.unwrap();
}
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.triangles, 2);
for x in [1, 5] {
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + x * 2),
Some(0x22e0)
);
}
// Clockwise front faces reverse generated normals; ambient lighting
// remains, but a light from +Z no longer illuminates either surface.
for material in &mut loaded.q3_submission_materials {
material.styles.push(PpcQ3StyleRecord {
style: 0,
kind: PpcQ3StyleKind::Orientation,
value: PPC_Q3_ORIENTATION_STYLE_CLOCKWISE,
});
}
loaded.render_q3_scene_commands_to_front_buffer();
for x in [1, 5] {
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + x * 2),
Some(0x2000)
);
}
}
#[test]
fn q3_software_renderer_uses_triangle_normals_for_directional_lights() {
fn write_lit_triangle_mesh(
memory: &mut PpcSectionMem,
trimesh_data: u32,
points_ptr: u32,
triangles_ptr: u32,
triangle_attrs_ptr: u32,
normal_ptr: u32,
points: [(f32, f32, f32); 3],
normal: (f32, f32, f32),
) {
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
triangle_attrs_ptr,
)
.unwrap();
memory
.write_u32_be(triangle_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
.unwrap();
memory
.write_u32_be(triangle_attrs_ptr + 4, normal_ptr)
.unwrap();
memory.write_u32_be(triangle_attrs_ptr + 8, 0).unwrap();
ppc_write_q3_vector3d(memory, normal_ptr, normal).unwrap();
for (index, point) in points.into_iter().enumerate() {
ppc_write_q3_vector3d(memory, points_ptr + index as u32 * 12, point).unwrap();
}
memory.write_u32_be(triangles_ptr, 0).unwrap();
memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
}
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let front_base = PPC_HEAP_BASE + 0x1000;
let left_trimesh_data = PPC_DATA_BASE + 0x1000;
let left_points_ptr = PPC_DATA_BASE + 0x1080;
let left_triangles_ptr = PPC_DATA_BASE + 0x1100;
let left_triangle_attrs_ptr = PPC_DATA_BASE + 0x1180;
let left_normal_ptr = PPC_DATA_BASE + 0x11c0;
let right_trimesh_data = PPC_DATA_BASE + 0x1200;
let right_points_ptr = PPC_DATA_BASE + 0x1280;
let right_triangles_ptr = PPC_DATA_BASE + 0x1300;
let right_triangle_attrs_ptr = PPC_DATA_BASE + 0x1380;
let right_normal_ptr = PPC_DATA_BASE + 0x13c0;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.memory
.add_region(PPC_DATA_BASE + 0x1000, vec![0; 0x800]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
write_lit_triangle_mesh(
&mut loaded.memory,
left_trimesh_data,
left_points_ptr,
left_triangles_ptr,
left_triangle_attrs_ptr,
left_normal_ptr,
[(-0.9, -0.8, 0.0), (-0.1, -0.8, 0.0), (-0.9, 0.8, 0.0)],
(0.0, 0.0, 1.0),
);
write_lit_triangle_mesh(
&mut loaded.memory,
right_trimesh_data,
right_points_ptr,
right_triangles_ptr,
right_triangle_attrs_ptr,
right_normal_ptr,
[(0.1, -0.8, 0.0), (0.9, -0.8, 0.0), (0.1, 0.8, 0.0)],
(1.0, 0.0, 0.0),
);
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
let lights = vec![PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (0.0, 1.0, 0.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}];
for (index, (trimesh_data, attribute_set)) in [
(
left_trimesh_data,
PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2,
),
(
right_trimesh_data,
PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3,
),
]
.into_iter()
.enumerate()
{
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_LAMBERT,
styles: Vec::new(),
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: index as u32,
lights: lights.clone(),
});
}
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 2);
assert_eq!(stats.triangles, 2);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 2),
Some(0x03e0)
);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 5 * 2),
Some(0)
);
}
#[test]
fn q3_software_renderer_applies_point_and_spot_lights_from_world_positions() {
fn write_lit_triangle_mesh(
memory: &mut PpcSectionMem,
trimesh_data: u32,
points_ptr: u32,
triangles_ptr: u32,
vertex_attrs_ptr: u32,
normals_ptr: u32,
) {
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
.unwrap();
memory
.write_u32_be(vertex_attrs_ptr + 4, normals_ptr)
.unwrap();
memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
for (index, point) in [(-0.9, -0.9, 0.0), (-0.9, 0.9, 0.0), (0.9, -0.9, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
ppc_write_q3_vector3d(
memory,
normals_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
(0.0, 0.0, 1.0),
)
.unwrap();
}
memory.write_u32_be(triangles_ptr, 0).unwrap();
memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
}
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
fn render_with_light(
light_type: u32,
light_kind: PpcQ3LightKind,
) -> (PpcLoadedApp, u32, PpcQ3SoftwareRenderStats) {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let normals_ptr = PPC_DATA_BASE + 0x11c0;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
write_lit_triangle_mesh(
&mut loaded.memory,
trimesh_data,
points_ptr,
triangles_ptr,
vertex_attrs_ptr,
normals_ptr,
);
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light,
light_type,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (0.0, 1.0, 0.0),
},
kind: light_kind,
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
(loaded, front_base, stats)
}
fn read_pixel(loaded: &mut PpcLoadedApp, front_base: u32, x: u32, y: u32) -> u16 {
loaded
.memory
.read_u16_be(front_base + y * 16 + x * 2)
.unwrap()
}
fn green_component(pixel: u16) -> u16 {
(pixel & 0x03e0) >> 5
}
fn any_nonzero_pixel(loaded: &mut PpcLoadedApp, front_base: u32) -> bool {
(0..8).any(|y| (0..8).any(|x| read_pixel(loaded, front_base, x, y) != 0))
}
let (mut point_loaded, point_front_base, point_stats) = render_with_light(
PPC_Q3_LIGHT_TYPE_POINT,
PpcQ3LightKind::Point {
casts_shadows: 0,
attenuation: PPC_Q3_ATTENUATION_TYPE_NONE,
location: (0.0, 0.0, 1.0),
},
);
assert_eq!(point_stats.commands, 1);
assert_eq!(point_stats.triangles, 1);
assert!(point_stats.pixels > 0);
let point_pixel = read_pixel(&mut point_loaded, point_front_base, 3, 4);
assert_ne!(point_pixel & 0x03e0, 0);
assert_eq!(point_pixel & 0x7c1f, 0);
let (mut dim_point_loaded, dim_point_front_base, dim_point_stats) = render_with_light(
PPC_Q3_LIGHT_TYPE_POINT,
PpcQ3LightKind::Point {
casts_shadows: 0,
attenuation: PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE_SQUARED,
location: (0.0, 0.0, 2.0),
},
);
assert_eq!(dim_point_stats.commands, 1);
assert_eq!(dim_point_stats.triangles, 1);
assert!(dim_point_stats.pixels > 0);
let dim_point_pixel = read_pixel(&mut dim_point_loaded, dim_point_front_base, 3, 4);
assert!(green_component(dim_point_pixel) > 0);
assert!(green_component(dim_point_pixel) < green_component(point_pixel));
assert_eq!(dim_point_pixel & 0x7c1f, 0);
let (mut spot_loaded, spot_front_base, spot_stats) = render_with_light(
PPC_Q3_LIGHT_TYPE_SPOT,
PpcQ3LightKind::Spot {
casts_shadows: 0,
attenuation: PPC_Q3_ATTENUATION_TYPE_NONE,
location: (0.0, 0.0, 1.0),
direction: (0.0, 0.0, -1.0),
hot_angle: 0.7,
outer_angle: 0.9,
fall_off: PPC_Q3_FALL_OFF_TYPE_LINEAR,
},
);
assert_eq!(spot_stats.commands, 1);
assert_eq!(spot_stats.triangles, 1);
assert!(spot_stats.pixels > 0);
let spot_pixel = read_pixel(&mut spot_loaded, spot_front_base, 3, 4);
assert_ne!(spot_pixel & 0x03e0, 0);
assert_eq!(spot_pixel & 0x7c1f, 0);
let (mut dim_spot_loaded, dim_spot_front_base, dim_spot_stats) = render_with_light(
PPC_Q3_LIGHT_TYPE_SPOT,
PpcQ3LightKind::Spot {
casts_shadows: 0,
attenuation: PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE,
location: (0.0, 0.0, 2.0),
direction: (0.0, 0.0, -1.0),
hot_angle: 0.0,
outer_angle: 1.2,
fall_off: PPC_Q3_FALL_OFF_TYPE_LINEAR,
},
);
assert_eq!(dim_spot_stats.commands, 1);
assert_eq!(dim_spot_stats.triangles, 1);
assert!(dim_spot_stats.pixels > 0);
let dim_spot_pixel = read_pixel(&mut dim_spot_loaded, dim_spot_front_base, 3, 4);
assert!(green_component(dim_spot_pixel) > 0);
assert!(green_component(dim_spot_pixel) < green_component(spot_pixel));
assert_eq!(dim_spot_pixel & 0x7c1f, 0);
let (mut away_loaded, away_front_base, away_stats) = render_with_light(
PPC_Q3_LIGHT_TYPE_SPOT,
PpcQ3LightKind::Spot {
casts_shadows: 0,
attenuation: PPC_Q3_ATTENUATION_TYPE_NONE,
location: (0.0, 0.0, 1.0),
direction: (0.0, 0.0, 1.0),
hot_angle: 0.7,
outer_angle: 0.9,
fall_off: PPC_Q3_FALL_OFF_TYPE_LINEAR,
},
);
assert_eq!(away_stats.commands, 1);
assert_eq!(away_stats.triangles, 1);
assert!(away_stats.pixels > 0);
assert!(!any_nonzero_pixel(&mut away_loaded, away_front_base));
}
#[test]
fn q3_software_renderer_respects_interpolation_style_shading_modes() {
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
fn render_with_interpolation_style(
interpolation_style: u32,
) -> (PpcLoadedApp, u32, PpcQ3SoftwareRenderStats) {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let style = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let directional_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let normals_ptr = PPC_DATA_BASE + 0x11c0;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_NORMAL)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, normals_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
for (index, point) in [(-0.8, -0.8, 0.0), (0.8, -0.8, 0.0), (-0.8, 0.8, 0.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
points_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
point,
)
.unwrap();
}
for (index, normal) in [(0.0, 0.0, 1.0), (0.0, 0.0, -1.0), (0.0, 0.0, -1.0)]
.into_iter()
.enumerate()
{
ppc_write_q3_vector3d(
&mut loaded.memory,
normals_ptr + index as u32 * PPC_Q3_POINT3D_SIZE,
normal,
)
.unwrap();
}
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style,
kind: PpcQ3StyleKind::Interpolation,
value: interpolation_style,
}],
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: vec![PpcQ3LightRecord {
light: directional_light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data: PpcQ3LightData {
is_on: 1,
brightness: 1.0,
color: (0.0, 1.0, 0.0),
},
kind: PpcQ3LightKind::Directional {
casts_shadows: 0,
direction: (0.0, 0.0, -1.0),
},
}],
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
(loaded, front_base, stats)
}
let (mut flat_loaded, flat_front_base, flat_stats) =
render_with_interpolation_style(PPC_Q3_INTERPOLATION_STYLE_NONE);
assert_eq!(flat_stats.commands, 1);
assert_eq!(flat_stats.triangles, 1);
assert!(flat_stats.pixels > 0);
assert_eq!(
flat_loaded
.memory
.read_u16_be(flat_front_base + 5 * 16 + 2 * 2),
Some(0)
);
let (mut vertex_loaded, vertex_front_base, vertex_stats) =
render_with_interpolation_style(PPC_Q3_INTERPOLATION_STYLE_VERTEX);
assert_eq!(vertex_stats.commands, 1);
assert_eq!(vertex_stats.triangles, 1);
assert!(vertex_stats.pixels > 0);
let vertex_pixel = vertex_loaded
.memory
.read_u16_be(vertex_front_base + 5 * 16 + 2 * 2)
.unwrap();
assert_ne!(vertex_pixel, 0);
assert_ne!(vertex_pixel, 0x03e0);
assert_ne!(vertex_pixel & 0x03e0, 0);
assert_eq!(vertex_pixel & 0x7c1f, 0);
let (mut pixel_loaded, pixel_front_base, pixel_stats) =
render_with_interpolation_style(PPC_Q3_INTERPOLATION_STYLE_PIXEL);
assert_eq!(pixel_stats.commands, 1);
assert_eq!(pixel_stats.triangles, 1);
assert!(pixel_stats.pixels > 0);
assert_eq!(
pixel_loaded
.memory
.read_u16_be(pixel_front_base + 5 * 16 + 2 * 2),
Some(0x03e0)
);
}
#[test]
fn q3_software_renderer_applies_linear_fog_style_to_materials() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 1.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 1.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 1.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let mut diffuse = Vec::new();
for value in [1.0f32, 0.0, 0.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: Some(PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_LINEAR,
fog_start: 0.0,
fog_end: 1.0,
density: 1.0,
color: (0.0, 0.0, 1.0, 1.0),
}),
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_applies_exponential_fog_modes_to_materials() {
fn assert_close(actual: f32, expected: f32) {
assert!(
(actual - expected).abs() < 0.0001,
"expected {expected}, got {actual}"
);
}
let view = PPC_Q3_OBJECT_BASE;
let lights = PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_DATA_BASE,
secondary: 0,
light_group: 0,
lights: Vec::new(),
};
let sample = PpcQ3SoftwareMaterialSample {
diffuse: (1.0, 0.0, 0.0),
ambient_coefficient: 1.0,
specular_color: (0.0, 0.0, 0.0),
specular_control: 0.0,
highlight_state: true,
transparency: (1.0, 1.0, 1.0),
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
texture: None,
uv_transform: None,
shader_boundary: None,
fog_style: None,
};
let mut memory = PpcSectionMem::new();
for (mode, expected_factor) in [
(PPC_Q3_FOG_MODE_EXPONENTIAL, (-0.5f32).exp()),
(PPC_Q3_FOG_MODE_EXPONENTIAL_SQUARED, (-0.25f32).exp()),
] {
let color = ppc_q3_software_material_color(
&mut memory,
&PpcQ3SoftwareMaterialSample {
fog_style: Some(PpcQ3FogStyleData {
state: 1,
mode,
fog_start: 0.0,
fog_end: 1.0,
density: 0.5,
color: (0.0, 0.0, 1.0, 1.0),
}),
..sample
},
&lights,
None,
None,
None,
None,
None,
1.0,
None,
);
assert_close(color.0, expected_factor);
assert_close(color.1, 0.0);
assert_close(color.2, 1.0 - expected_factor);
}
}
#[test]
fn q3_software_renderer_applies_alpha_fog_from_vertex_transparency() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let vertex_transparency_ptr = PPC_DATA_BASE + 0x1200;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, vertex_transparency_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 100.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 100.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 100.0)).unwrap();
for index in 0..3 {
ppc_write_q3_color_rgb(
&mut loaded.memory,
vertex_transparency_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.25, 0.25, 0.25),
)
.unwrap();
}
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: Some(PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_ALPHA,
fog_start: 0.0,
fog_end: 1.0,
density: 1.0,
color: (0.0, 0.0, 1.0, 1.0),
}),
attributes: vec![color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
[1.0, 0.0, 0.0],
)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x2017)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x7c00)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_applies_captured_mipmap_texture_color() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let image_ptr = PPC_DATA_BASE + 0x1200;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.memory.write_u8(image_ptr, 0).unwrap();
loaded.memory.write_u8(image_ptr + 1, 0).unwrap();
loaded.memory.write_u8(image_ptr + 2, 255).unwrap();
let mut diffuse = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4].copy_from_slice(&storage.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_PIXEL_TYPE_RGB24.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_ENDIAN_BIG.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET as usize..][..4]
.copy_from_slice(&3u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET as usize..][..4]
.copy_from_slice(&0u32.to_be_bytes());
loaded.q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage,
buffer_ptr: image_ptr,
valid_size: 3,
buffer_size: 3,
owns_buffer: false,
});
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: Some(PpcQ3TextureShaderRecord { shader, texture }),
mipmap_texture: Some(PpcQ3MipmapTextureRecord { texture, mipmap }),
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_blends_argb_texture_alpha() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let image_ptr = PPC_DATA_BASE + 0x1200;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut front_buffer_bytes = Vec::new();
for _ in 0..64 {
front_buffer_bytes.extend_from_slice(&0x001fu16.to_be_bytes());
}
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, front_buffer_bytes);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.memory.write_u8(image_ptr, 64).unwrap();
loaded.memory.write_u8(image_ptr + 1, 255).unwrap();
loaded.memory.write_u8(image_ptr + 2, 0).unwrap();
loaded.memory.write_u8(image_ptr + 3, 0).unwrap();
let mut diffuse = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4].copy_from_slice(&storage.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_PIXEL_TYPE_ARGB32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_ENDIAN_BIG.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET as usize..][..4]
.copy_from_slice(&4u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET as usize..][..4]
.copy_from_slice(&0u32.to_be_bytes());
loaded.q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage,
buffer_ptr: image_ptr,
valid_size: 4,
buffer_size: 4,
owns_buffer: false,
});
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: Some(PpcQ3TextureShaderRecord { shader, texture }),
mipmap_texture: Some(PpcQ3MipmapTextureRecord { texture, mipmap }),
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x2017)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x7c00)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_composes_texture_material_and_vertex_opacity() {
fn color_attribute(
attribute_set: u32,
attribute_type: u32,
rgb: [f32; 3],
) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let vertex_alphas_ptr = PPC_DATA_BASE + 0x11c0;
let image_ptr = PPC_DATA_BASE + 0x1240;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
let mut front_buffer_bytes = Vec::new();
for _ in 0..64 {
front_buffer_bytes.extend_from_slice(&0x001fu16.to_be_bytes());
}
loaded.memory.add_region(trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, front_buffer_bytes);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, vertex_alphas_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (0.0, 0.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (0.0, 0.9, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.9, 0.0, 0.0)).unwrap();
for index in 0..3 {
ppc_write_q3_color_rgb(
&mut loaded.memory,
vertex_alphas_ptr + index * PPC_Q3_POINT3D_SIZE,
(0.5, 0.5, 0.5),
)
.unwrap();
}
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded.memory.write_u8(image_ptr, 128).unwrap();
loaded.memory.write_u8(image_ptr + 1, 255).unwrap();
loaded.memory.write_u8(image_ptr + 2, 0).unwrap();
loaded.memory.write_u8(image_ptr + 3, 0).unwrap();
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4].copy_from_slice(&storage.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_PIXEL_TYPE_ARGB32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_ENDIAN_BIG.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET as usize..][..4]
.copy_from_slice(&4u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET as usize..][..4]
.copy_from_slice(&0u32.to_be_bytes());
loaded.q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage,
buffer_ptr: image_ptr,
valid_size: 4,
buffer_size: 4,
owns_buffer: false,
});
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
color_attribute(attribute_set, PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR, [1.0; 3]),
color_attribute(
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR,
[0.5; 3],
),
],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: Some(PpcQ3TextureShaderRecord { shader, texture }),
mipmap_texture: Some(PpcQ3MipmapTextureRecord { texture, mipmap }),
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
let texture_opacity = 128.0 / 255.0;
let vertex_opacity = 0.5;
let expected_transparency = ppc_q3_software_effective_transparency(
(0.5, 0.5, 0.5),
texture_opacity * vertex_opacity,
);
let expected = ppc_q3_rgb555(ppc_q3_blend_transparency_color(
(1.0, 0.0, 0.0),
(0.0, 0.0, 1.0),
expected_transparency,
));
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(expected)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x2017)
);
assert_ne!(
loaded.memory.read_u16_be(front_base + 4 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_texture_reads_argb16_alpha_bit() {
let opaque_red = ppc_q3_software_texture_pixel_color(
PPC_Q3_PIXEL_TYPE_ARGB16,
PPC_Q3_ENDIAN_BIG,
&[0xfc, 0x00, 0x00, 0x00],
)
.unwrap();
assert_eq!(opaque_red.color, (1.0, 0.0, 0.0));
assert_eq!(opaque_red.opacity, 1.0);
let transparent_red = ppc_q3_software_texture_pixel_color(
PPC_Q3_PIXEL_TYPE_ARGB16,
PPC_Q3_ENDIAN_BIG,
&[0x7c, 0x00, 0x00, 0x00],
)
.unwrap();
assert_eq!(transparent_red.color, (1.0, 0.0, 0.0));
assert_eq!(transparent_red.opacity, 0.0);
}
#[test]
fn q3_software_renderer_samples_captured_mipmap_with_vertex_uvs() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let uvs_ptr = PPC_DATA_BASE + 0x11c0;
let image_ptr = PPC_DATA_BASE + 0x1240;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x800]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (-1.0, -1.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (1.0, -1.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (-1.0, 1.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, uvs_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
ppc_write_q3_vector2d(&mut loaded.memory, uvs_ptr, (0.0, 0.0)).unwrap();
ppc_write_q3_vector2d(&mut loaded.memory, uvs_ptr + 8, (1.0, 0.0)).unwrap();
ppc_write_q3_vector2d(&mut loaded.memory, uvs_ptr + 16, (0.0, 0.0)).unwrap();
loaded.memory.write_u8(image_ptr, 255).unwrap();
loaded.memory.write_u8(image_ptr + 1, 0).unwrap();
loaded.memory.write_u8(image_ptr + 2, 0).unwrap();
loaded.memory.write_u8(image_ptr + 3, 0).unwrap();
loaded.memory.write_u8(image_ptr + 4, 0).unwrap();
loaded.memory.write_u8(image_ptr + 5, 255).unwrap();
let mut diffuse = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4].copy_from_slice(&storage.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_PIXEL_TYPE_RGB24.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_ENDIAN_BIG.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET as usize..][..4]
.copy_from_slice(&2u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET as usize..][..4]
.copy_from_slice(&6u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET as usize..][..4]
.copy_from_slice(&0u32.to_be_bytes());
loaded.q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage,
buffer_ptr: image_ptr,
valid_size: 6,
buffer_size: 6,
owns_buffer: false,
});
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: Some(PpcQ3ShaderBoundaryRecord {
shader,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
}),
texture_shader: Some(PpcQ3TextureShaderRecord { shader, texture }),
mipmap_texture: Some(PpcQ3MipmapTextureRecord { texture, mipmap }),
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 5 * 16 + 4 * 2),
Some(0x001f)
);
loaded.q3_submission_materials[0].styles = vec![PpcQ3StyleRecord {
style: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5,
kind: PpcQ3StyleKind::Interpolation,
value: PPC_Q3_INTERPOLATION_STYLE_VERTEX,
}];
for offset in 0..(8 * 8 * 2) {
loaded.memory.write_u8(front_base + offset, 0).unwrap();
}
let vertex_stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(vertex_stats.triangles, 1);
assert_eq!(
loaded.memory.read_u16_be(front_base + 5 * 16 + 4 * 2),
Some(0x001f),
"vertex lighting must still sample the texture per pixel"
);
}
#[test]
fn q3_software_renderer_honors_shader_uv_boundary_modes() {
fn render_boundary_sample(u_boundary: u32) -> u16 {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let uvs_ptr = PPC_DATA_BASE + 0x11c0;
let image_ptr = PPC_DATA_BASE + 0x1240;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x800]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (-1.0, -1.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (1.0, -1.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (-1.0, 1.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, uvs_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
for index in 0..3 {
ppc_write_q3_vector2d(&mut loaded.memory, uvs_ptr + index * 8, (1.25, 0.5))
.unwrap();
}
loaded.memory.write_u8(image_ptr, 255).unwrap();
loaded.memory.write_u8(image_ptr + 1, 0).unwrap();
loaded.memory.write_u8(image_ptr + 2, 0).unwrap();
loaded.memory.write_u8(image_ptr + 3, 0).unwrap();
loaded.memory.write_u8(image_ptr + 4, 0).unwrap();
loaded.memory.write_u8(image_ptr + 5, 255).unwrap();
let mut diffuse = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4]
.copy_from_slice(&storage.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_PIXEL_TYPE_RGB24.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_ENDIAN_BIG.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET as usize..][..4]
.copy_from_slice(&2u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET as usize..][..4]
.copy_from_slice(&6u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET as usize..][..4]
.copy_from_slice(&0u32.to_be_bytes());
loaded.q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage,
buffer_ptr: image_ptr,
valid_size: 6,
buffer_size: 6,
owns_buffer: false,
});
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: Some(PpcQ3ShaderBoundaryRecord {
shader,
u_boundary,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
}),
texture_shader: Some(PpcQ3TextureShaderRecord { shader, texture }),
mipmap_texture: Some(PpcQ3MipmapTextureRecord { texture, mipmap }),
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
loaded
.memory
.read_u16_be(front_base + 5 * 16 + 4 * 2)
.unwrap()
}
let wrapped = render_boundary_sample(PPC_Q3_SHADER_UV_BOUNDARY_WRAP);
let clamped = render_boundary_sample(PPC_Q3_SHADER_UV_BOUNDARY_CLAMP);
assert_eq!(wrapped, 0x7c00);
assert_eq!(clamped, 0x001f);
assert_ne!(wrapped, clamped);
}
#[test]
fn q3_software_renderer_applies_shader_uv_transform_before_texture_sampling() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let texture = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let storage = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let vertex_attrs_ptr = PPC_DATA_BASE + 0x1180;
let uvs_ptr = PPC_DATA_BASE + 0x11c0;
let image_ptr = PPC_DATA_BASE + 0x1240;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x800]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
1,
)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attrs_ptr,
)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (-1.0, -1.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (1.0, -1.0, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (-1.0, 1.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr, PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV)
.unwrap();
loaded
.memory
.write_u32_be(vertex_attrs_ptr + 4, uvs_ptr)
.unwrap();
loaded.memory.write_u32_be(vertex_attrs_ptr + 8, 0).unwrap();
for index in 0..3 {
ppc_write_q3_vector2d(&mut loaded.memory, uvs_ptr + index * 8, (0.0, 0.0)).unwrap();
}
loaded.memory.write_u8(image_ptr, 255).unwrap();
loaded.memory.write_u8(image_ptr + 1, 0).unwrap();
loaded.memory.write_u8(image_ptr + 2, 0).unwrap();
loaded.memory.write_u8(image_ptr + 3, 0).unwrap();
loaded.memory.write_u8(image_ptr + 4, 0).unwrap();
loaded.memory.write_u8(image_ptr + 5, 255).unwrap();
let mut diffuse = Vec::new();
for value in [1.0f32, 1.0, 1.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
mipmap[PPC_Q3_MIPMAP_IMAGE_OFFSET as usize..][..4].copy_from_slice(&storage.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_PIXEL_TYPE_RGB24.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET as usize..][..4]
.copy_from_slice(&PPC_Q3_ENDIAN_BIG.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET as usize..][..4]
.copy_from_slice(&2u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET as usize..][..4]
.copy_from_slice(&1u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET as usize..][..4]
.copy_from_slice(&6u32.to_be_bytes());
mipmap[PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET as usize..][..4]
.copy_from_slice(&0u32.to_be_bytes());
loaded.q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage,
buffer_ptr: image_ptr,
valid_size: 6,
buffer_size: 6,
owns_buffer: false,
});
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: Some(PpcQ3ShaderUvTransformRecord {
shader,
matrix: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.75, 0.0, 1.0]],
}),
shader_boundary: Some(PpcQ3ShaderBoundaryRecord {
shader,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
}),
texture_shader: Some(PpcQ3TextureShaderRecord { shader, texture }),
mipmap_texture: Some(PpcQ3MipmapTextureRecord { texture, mipmap }),
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 5 * 16 + 4 * 2),
Some(0x001f)
);
}
#[test]
fn q3_software_renderer_clips_partially_offscreen_trimeshes() {
let view = PPC_Q3_OBJECT_BASE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (-1.5, -0.8, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (-1.5, 0.8, 0.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (0.8, 0.0, 0.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let mut diffuse = Vec::new();
for value in [0.0f32, 1.0, 0.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
loaded.q3_views.push(PpcQ3ViewStateRecord::new(view));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
let mut left_edge_pixels = 0;
for y in 0..8 {
if loaded.memory.read_u16_be(front_base + y * 16) == Some(0x03e0) {
left_edge_pixels += 1;
}
}
assert!(left_edge_pixels > 0);
}
#[test]
fn q3_software_renderer_clips_camera_near_and_far_depth() {
fn write_triangle_mesh(
memory: &mut PpcSectionMem,
trimesh_data: u32,
points_ptr: u32,
triangles_ptr: u32,
vertices: [(f32, f32, f32); 3],
) {
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
for (index, vertex) in vertices.into_iter().enumerate() {
ppc_write_q3_vector3d(
memory,
points_ptr + (index as u32 * PPC_Q3_POINT3D_SIZE),
vertex,
)
.unwrap();
}
memory.write_u32_be(triangles_ptr, 0).unwrap();
memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
}
fn diffuse_attribute(attribute_set: u32, rgb: [f32; 3]) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in rgb {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let camera = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let far_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let near_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let far_trimesh_data = PPC_DATA_BASE + 0x1000;
let far_points_ptr = PPC_DATA_BASE + 0x1080;
let far_triangles_ptr = PPC_DATA_BASE + 0x1100;
let near_trimesh_data = PPC_DATA_BASE + 0x1200;
let near_points_ptr = PPC_DATA_BASE + 0x1280;
let near_triangles_ptr = PPC_DATA_BASE + 0x1300;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(far_trimesh_data, vec![0; 0x400]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
write_triangle_mesh(
&mut loaded.memory,
far_trimesh_data,
far_points_ptr,
far_triangles_ptr,
[(-4.0, -1.0, -8.0), (-4.0, 1.0, -8.0), (-2.0, 0.0, -8.0)],
);
write_triangle_mesh(
&mut loaded.memory,
near_trimesh_data,
near_points_ptr,
near_triangles_ptr,
[(-0.2, -0.2, -0.5), (-0.2, 0.2, -0.5), (0.8, 0.0, -2.0)],
);
let mut view_state = PpcQ3ViewStateRecord::new(view);
view_state.camera = camera;
loaded.q3_views.push(view_state);
loaded.q3_cameras.push(PpcQ3CameraRecord {
camera,
camera_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
placement: PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 0.0),
point_of_interest: (0.0, 0.0, -1.0),
up_vector: (0.0, 1.0, 0.0),
},
range_hither: 1.0,
range_yon: 5.0,
viewport_origin: (-1.0, 1.0),
viewport_width: 2.0,
viewport_height: 2.0,
projection: PpcQ3CameraProjection::ViewAngleAspect {
fov: std::f32::consts::FRAC_PI_2,
aspect_ratio_x_to_y: 1.0,
},
});
for (trimesh_data, attribute_set, rgb) in [
(far_trimesh_data, far_attribute_set, [1.0, 0.0, 0.0]),
(near_trimesh_data, near_attribute_set, [0.0, 1.0, 0.0]),
] {
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set, rgb)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
}
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 2);
assert_eq!(stats.vertices, 6);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
let mut red_pixels = 0;
let mut green_pixels = 0;
for y in 0..8 {
for x in 0..8 {
match loaded.memory.read_u16_be(front_base + y * 16 + x * 2) {
Some(0x7c00) => red_pixels += 1,
Some(0x03e0) => green_pixels += 1,
_ => {}
}
}
}
assert_eq!(red_pixels, 0);
assert!(green_pixels > 0);
}
#[test]
fn q3_software_triangle_edge_walker_matches_direct_edge_equations() {
fn point(x: i32, y: i32) -> PpcQ3SoftwareProjectedPoint {
PpcQ3SoftwareProjectedPoint {
x,
y,
z: 0.0,
reciprocal_w: 1.0,
world: (0.0, 0.0, 0.0),
view_direction: None,
fog_depth: 0.0,
uv: None,
diffuse: None,
ambient_coefficient: None,
normal: None,
specular_color: None,
specular_control: None,
highlight_state: None,
vertex_alpha: None,
}
}
let vertices = [point(3, 2), point(19, 7), point(8, 23)];
let start_x = -4;
let start_y = -3;
let (mut row_weights, x_steps, y_steps) =
ppc_q3_software_triangle_edge_walker(vertices, start_x, start_y);
for y in start_y..=28 {
let mut weights = row_weights;
for x in start_x..=25 {
let sample = point(x, y);
assert_eq!(
weights,
[
ppc_q3_software_edge_value(vertices[1], vertices[2], sample),
ppc_q3_software_edge_value(vertices[2], vertices[0], sample),
ppc_q3_software_edge_value(vertices[0], vertices[1], sample),
]
);
for index in 0..3 {
weights[index] += x_steps[index];
}
}
for index in 0..3 {
row_weights[index] += y_steps[index];
}
}
}
#[test]
fn q3_software_renderer_clips_camera_frustum_in_clip_space() {
let view = PPC_Q3_OBJECT_BASE;
let front_buffer = PpcFrontBuffer {
base_addr: PPC_HEAP_BASE,
row_bytes: 32 * 2,
width: 32,
height: 32,
depth: 16,
};
let camera = PpcQ3CameraRecord {
camera: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
camera_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
placement: PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 0.0),
point_of_interest: (0.0, 0.0, -1.0),
up_vector: (0.0, 1.0, 0.0),
},
range_hither: 1.0,
range_yon: 10.0,
viewport_origin: (-1.0, 1.0),
viewport_width: 2.0,
viewport_height: 2.0,
projection: PpcQ3CameraProjection::ViewAngleAspect {
fov: std::f32::consts::FRAC_PI_2,
aspect_ratio_x_to_y: 1.0,
},
};
let command = PpcQ3SceneTriMeshCommand {
submission_index: 0,
view_state: PpcQ3ViewStateRecord::new(view),
camera: Some(camera),
geometry: PpcQ3SceneTriMeshGeometry {
source: PpcQ3SceneTriMeshSource::DataPtr(0),
data: Vec::new(),
},
local_to_world: ppc_q3_matrix4x4_identity(),
material: PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: 0,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
},
lights: PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: 0,
secondary: 0,
light_group: 0,
lights: Vec::new(),
},
};
let vertices = [(-8.0, 8.0, 0.5), (-0.35, -0.35, -2.0), (0.35, -0.35, -2.0)].map(|point| {
ppc_q3_software_project_point(
&command,
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
point,
)
.unwrap()
});
assert!(vertices.iter().any(|vertex| {
vertex.x < 0.0
|| vertex.x > front_buffer.width.saturating_sub(1) as f32
|| vertex.y < 0.0
|| vertex.y > front_buffer.height.saturating_sub(1) as f32
}));
assert!(vertices
.iter()
.any(|vertex| !vertex.clip.is_some_and(ppc_q3_software_clip_inside_frustum)));
let clipped = ppc_q3_software_clip_projected_triangle(
Some(camera),
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
vertices,
);
assert!(clipped.len() >= 3, "{:?}", clipped);
let max_x = front_buffer.width.saturating_sub(1) as f32;
let max_y = front_buffer.height.saturating_sub(1) as f32;
for vertex in &clipped {
assert!(vertex.clip.is_some_and(ppc_q3_software_clip_inside_frustum));
assert!(
vertex.x >= -0.01 && vertex.x <= max_x + 0.01,
"{:?}",
clipped
);
assert!(
vertex.y >= -0.01 && vertex.y <= max_y + 0.01,
"{:?}",
clipped
);
}
}
#[test]
fn q3_software_renderer_maps_qd3d_full_viewport_to_front_buffer() {
let front_buffer = PpcFrontBuffer {
base_addr: PPC_HEAP_BASE,
row_bytes: 640 * 2,
width: 640,
height: 480,
depth: 16,
};
let camera = PpcQ3CameraRecord {
camera: PPC_Q3_OBJECT_BASE,
camera_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
placement: PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 0.0),
point_of_interest: (0.0, 0.0, -1.0),
up_vector: (0.0, 1.0, 0.0),
},
range_hither: 1.0,
range_yon: 10.0,
viewport_origin: (-1.0, 1.0),
viewport_width: 2.0,
viewport_height: 2.0,
projection: PpcQ3CameraProjection::ViewAngleAspect {
fov: std::f32::consts::FRAC_PI_2,
aspect_ratio_x_to_y: 4.0 / 3.0,
},
};
assert_eq!(
ppc_q3_software_projected_to_screen(
(-1.0, 1.0, 0.0),
Some(camera),
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
),
(0.0, 0.0)
);
assert_eq!(
ppc_q3_software_projected_to_screen(
(1.0, -1.0, 0.0),
Some(camera),
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
),
(639.0, 479.0)
);
assert_eq!(
ppc_q3_software_projected_to_screen(
(0.0, 0.0, 0.0),
Some(camera),
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
),
(319.5, 239.5)
);
}
#[test]
fn q3_software_renderer_maps_camera_viewport_to_front_buffer_region() {
fn write_triangle_mesh(
memory: &mut PpcSectionMem,
trimesh_data: u32,
points_ptr: u32,
triangles_ptr: u32,
) {
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(memory, points_ptr, (-1.6, -1.6, -2.0)).unwrap();
ppc_write_q3_vector3d(memory, points_ptr + 12, (-1.6, 1.6, -2.0)).unwrap();
ppc_write_q3_vector3d(memory, points_ptr + 24, (1.6, -1.6, -2.0)).unwrap();
memory.write_u32_be(triangles_ptr, 0).unwrap();
memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
}
fn diffuse_attribute(attribute_set: u32) -> PpcQ3AttributeRecord {
let mut data = Vec::new();
for value in [0.0f32, 1.0, 0.0] {
data.extend_from_slice(&value.to_bits().to_be_bytes());
}
PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data,
}
}
let view = PPC_Q3_OBJECT_BASE;
let camera = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
write_triangle_mesh(&mut loaded.memory, trimesh_data, points_ptr, triangles_ptr);
let mut view_state = PpcQ3ViewStateRecord::new(view);
view_state.camera = camera;
loaded.q3_views.push(view_state);
loaded.q3_cameras.push(PpcQ3CameraRecord {
camera,
camera_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
placement: PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 0.0),
point_of_interest: (0.0, 0.0, -1.0),
up_vector: (0.0, 1.0, 0.0),
},
range_hither: 1.0,
range_yon: 5.0,
viewport_origin: (0.0, 1.0),
viewport_width: 1.0,
viewport_height: 2.0,
projection: PpcQ3CameraProjection::ViewAngleAspect {
fov: std::f32::consts::FRAC_PI_2,
aspect_ratio_x_to_y: 1.0,
},
});
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![diffuse_attribute(attribute_set)],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
let mut left_half_green_pixels = 0;
let mut right_half_green_pixels = 0;
for y in 0..8 {
for x in 0..8 {
if loaded.memory.read_u16_be(front_base + y * 16 + x * 2) != Some(0x03e0) {
continue;
}
if x < 4 {
left_half_green_pixels += 1;
} else {
right_half_green_pixels += 1;
}
}
}
assert_eq!(left_half_green_pixels, 0);
assert!(right_half_green_pixels > 0);
}
#[test]
fn q3_software_renderer_maps_explicit_draw_context_pane_to_front_buffer_region() {
let view = PPC_Q3_OBJECT_BASE;
let camera = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE;
let draw_context = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2;
let attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3;
let trimesh_data = PPC_DATA_BASE + 0x1000;
let points_ptr = PPC_DATA_BASE + 0x1080;
let triangles_ptr = PPC_DATA_BASE + 0x1100;
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(trimesh_data, vec![0; 0x200]);
loaded.memory.add_region(front_base, vec![0; 8 * 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: 0,
pixmap: 0,
base_addr: front_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded.q3_objects.push(PpcQ3ObjectRecord {
object: draw_context,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE,
});
let mut draw_context_data = vec![0; PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE as usize];
ppc_q3_write_u32_to_slice(
&mut draw_context_data,
PPC_Q3_DRAW_CONTEXT_CLEAR_METHOD_OFFSET,
PPC_Q3_CLEAR_METHOD_WITH_COLOR,
)
.unwrap();
draw_context_data[PPC_Q3_DRAW_CONTEXT_CLEAR_COLOR_RED_OFFSET as usize
..PPC_Q3_DRAW_CONTEXT_CLEAR_COLOR_RED_OFFSET as usize + 4]
.copy_from_slice(&1.0f32.to_bits().to_be_bytes());
ppc_q3_write_u32_to_slice(
&mut draw_context_data,
PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET,
PPC_MAIN_GWORLD,
)
.unwrap();
ppc_q3_write_u32_to_slice(
&mut draw_context_data,
PPC_Q3_DRAW_CONTEXT_PANE_STATE_OFFSET,
1,
)
.unwrap();
for (offset, value) in [(0, 2.0f32), (4, 1.0f32), (8, 6.0f32), (12, 5.0f32)] {
draw_context_data[PPC_Q3_DRAW_CONTEXT_PANE_OFFSET as usize + offset
..PPC_Q3_DRAW_CONTEXT_PANE_OFFSET as usize + offset + 4]
.copy_from_slice(&value.to_bits().to_be_bytes());
}
loaded.q3_draw_contexts.push(PpcQ3DrawContextRecord {
draw_context,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
data: draw_context_data,
});
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u32_be(
trimesh_data + PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
triangles_ptr,
)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_NUM_POINTS_OFFSET, 3)
.unwrap();
loaded
.memory
.write_u32_be(trimesh_data + PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)
.unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr, (-2.0, -2.0, -2.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 12, (-2.0, 2.0, -2.0)).unwrap();
ppc_write_q3_vector3d(&mut loaded.memory, points_ptr + 24, (2.0, -2.0, -2.0)).unwrap();
loaded.memory.write_u32_be(triangles_ptr, 0).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 4, 1).unwrap();
loaded.memory.write_u32_be(triangles_ptr + 8, 2).unwrap();
let mut view_state = PpcQ3ViewStateRecord::new(view);
view_state.camera = camera;
view_state.draw_context = draw_context;
loaded.q3_views.push(view_state);
loaded.q3_cameras.push(PpcQ3CameraRecord {
camera,
camera_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
placement: PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 0.0),
point_of_interest: (0.0, 0.0, -1.0),
up_vector: (0.0, 1.0, 0.0),
},
range_hither: 1.0,
range_yon: 5.0,
viewport_origin: (-1.0, 1.0),
viewport_width: 2.0,
viewport_height: 2.0,
projection: PpcQ3CameraProjection::ViewAngleAspect {
fov: std::f32::consts::FRAC_PI_2,
aspect_ratio_x_to_y: 1.0,
},
});
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
let mut diffuse = Vec::new();
for value in [0.0f32, 1.0, 0.0] {
diffuse.extend_from_slice(&value.to_bits().to_be_bytes());
}
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: diffuse,
}],
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: trimesh_data,
secondary: 0,
light_group: 0,
lights: Vec::new(),
});
let stats = loaded.render_q3_scene_commands_to_front_buffer();
assert_eq!(stats.commands, 1);
assert_eq!(stats.triangles, 1);
assert!(stats.pixels > 0);
assert_eq!(
loaded.memory.read_u16_be(front_base + 16 + 5 * 2),
Some(0x7c00),
"draw-context clear color must fill uncovered pane pixels"
);
for y in 0..8 {
for x in 0..8 {
let pixel = loaded.memory.read_u16_be(front_base + y * 16 + x * 2);
if (2..6).contains(&x) && (1..5).contains(&y) {
continue;
}
assert_ne!(pixel, Some(0x03e0), "green pixel outside pane at {x},{y}");
}
}
}
#[test]
fn q3_software_surface_maps_rgb555_through_indexed_clut() {
let front_base = PPC_HEAP_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3TriMesh_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(front_base, vec![0; 4]);
let front_buffer = PpcFrontBuffer {
base_addr: front_base,
row_bytes: 2,
width: 2,
height: 2,
depth: 8,
};
let mut clut = [[0; 3]; 256];
clut[42] = [0, u16::MAX, u16::MAX];
let surface =
PpcQ3SoftwareFrontBufferSurface::new(&mut loaded.memory, front_buffer, Some(clut));
assert!(surface.write_pixel(&mut loaded.memory, (1, 0), 0x03ff));
assert_eq!(loaded.memory.read_u8(front_base + 1), Some(42));
assert_eq!(surface.read_pixel(&mut loaded.memory, (1, 0)), Some(0x03ff));
}
#[test]
fn q3_mac_draw_context_translates_port_local_pane_to_framebuffer() {
let front_buffer = PpcFrontBuffer {
base_addr: PPC_MAIN_SCREEN_BASE,
row_bytes: 1600,
width: 800,
height: 600,
depth: 16,
};
let mut data = vec![0; PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE as usize];
ppc_q3_write_u32_to_slice(&mut data, PPC_Q3_DRAW_CONTEXT_PANE_STATE_OFFSET, 1).unwrap();
for (offset, value) in [(0, 30.0f32), (4, 80.0), (8, 125.0), (12, 130.0)] {
data[PPC_Q3_DRAW_CONTEXT_PANE_OFFSET as usize + offset
..PPC_Q3_DRAW_CONTEXT_PANE_OFFSET as usize + offset + 4]
.copy_from_slice(&value.to_bits().to_be_bytes());
}
let record = PpcQ3DrawContextRecord {
draw_context: PPC_Q3_OBJECT_BASE,
draw_context_type: PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH,
data,
};
assert_eq!(
ppc_q3_draw_context_viewport_with_origin(&record, front_buffer, 40, 40),
Some(PpcQ3ViewportRect {
left: 70,
top: 120,
right: 165,
bottom: 170,
})
);
}
#[test]
fn q3_software_renderer_projects_orthographic_and_view_plane_cameras() {
fn assert_close(actual: f32, expected: f32) {
assert!(
(actual - expected).abs() < 0.001,
"expected {expected}, got {actual}"
);
}
fn projection_command(view: u32, camera: PpcQ3CameraRecord) -> PpcQ3SceneTriMeshCommand {
PpcQ3SceneTriMeshCommand {
submission_index: 0,
view_state: PpcQ3ViewStateRecord::new(view),
camera: Some(camera),
geometry: PpcQ3SceneTriMeshGeometry {
source: PpcQ3SceneTriMeshSource::DataPtr(0),
data: Vec::new(),
},
local_to_world: ppc_q3_matrix4x4_identity(),
material: PpcQ3SubmissionMaterialRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: 0,
secondary: 0,
shader: 0,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
},
lights: PpcQ3SubmissionLightRecord {
view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: 0,
secondary: 0,
light_group: 0,
lights: Vec::new(),
},
}
}
let view = PPC_Q3_OBJECT_BASE;
let front_buffer = PpcFrontBuffer {
base_addr: PPC_HEAP_BASE,
row_bytes: 640 * 2,
width: 640,
height: 480,
depth: 16,
};
let placement = PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 0.0),
point_of_interest: (0.0, 0.0, -1.0),
up_vector: (0.0, 1.0, 0.0),
};
let orthographic = PpcQ3CameraRecord {
camera: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
camera_type: PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC,
placement,
range_hither: 1.0,
range_yon: 10.0,
viewport_origin: (-1.0, 1.0),
viewport_width: 2.0,
viewport_height: 2.0,
projection: PpcQ3CameraProjection::Orthographic {
left: -2.0,
top: 1.0,
right: 2.0,
bottom: -1.0,
},
};
let orthographic_command = projection_command(view, orthographic);
let top_left = ppc_q3_software_project_point(
&orthographic_command,
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
(-2.0, 1.0, -1.0),
)
.unwrap();
let bottom_right = ppc_q3_software_project_point(
&orthographic_command,
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
(2.0, -1.0, -10.0),
)
.unwrap();
assert_close(top_left.x, 0.0);
assert_close(top_left.y, 0.0);
assert_close(top_left.z, -1.0);
assert_close(bottom_right.x, 639.0);
assert_close(bottom_right.y, 479.0);
assert_close(bottom_right.z, 1.0);
let view_plane = PpcQ3CameraRecord {
camera: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2,
camera_type: PPC_Q3_CAMERA_TYPE_VIEW_PLANE,
placement,
range_hither: 1.0,
range_yon: 10.0,
viewport_origin: (-1.0, 1.0),
viewport_width: 2.0,
viewport_height: 2.0,
projection: PpcQ3CameraProjection::ViewPlane {
view_plane: 2.0,
half_width_at_view_plane: 2.0,
half_height_at_view_plane: 1.0,
center_x_on_view_plane: 0.5,
center_y_on_view_plane: -0.25,
},
};
let view_plane_command = projection_command(view, view_plane);
let centered = ppc_q3_software_project_point(
&view_plane_command,
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
(0.5, -0.25, -2.0),
)
.unwrap();
let top_left = ppc_q3_software_project_point(
&view_plane_command,
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
(-1.5, 0.75, -2.0),
)
.unwrap();
let bottom_right = ppc_q3_software_project_point(
&view_plane_command,
front_buffer,
PpcQ3ViewportRect::full(front_buffer),
(2.5, -1.25, -2.0),
)
.unwrap();
assert_close(centered.x, 319.5);
assert_close(centered.y, 239.5);
assert_close(top_left.x, 0.0);
assert_close(top_left.y, 0.0);
assert_close(bottom_right.x, 639.0);
assert_close(bottom_right.y, 479.0);
}
#[test]
fn hle_import_runner_records_q3_fog_style_submit_state() {
let view = PPC_Q3_OBJECT_BASE;
let fog_data_ptr = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3FogStyle_Submit");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.q3_objects
.push(test_q3_object(view, PPC_Q3_TYPE_VIEW));
loaded
.memory
.add_region(fog_data_ptr, vec![0; PPC_Q3_FOG_STYLE_DATA_SIZE as usize]);
loaded.memory.write_u32_be(fog_data_ptr, 1).unwrap();
loaded
.memory
.write_u32_be(fog_data_ptr + 4, PPC_Q3_FOG_MODE_LINEAR)
.unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 8, 12.0).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 12, 96.0).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 16, 0.75).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 20, 1.0).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 24, 0.2).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 28, 0.3).unwrap();
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 32, 0.4).unwrap();
loaded.cpu.gpr[3] = fog_data_ptr;
loaded.cpu.gpr[4] = view;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.q3_submissions,
vec![PpcQ3SubmissionRecord {
view,
kind: PpcQ3SubmissionKind::FogStyle,
primary: fog_data_ptr,
secondary: 1,
}]
);
ppc_write_f32_be(&mut loaded.memory, fog_data_ptr + 8, 999.0).unwrap();
assert_eq!(
loaded.q3_fog_styles,
vec![PpcQ3FogStyleRecord {
view,
data_ptr: fog_data_ptr,
data: PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_LINEAR,
fog_start: 12.0,
fog_end: 96.0,
density: 0.75,
color: (1.0, 0.2, 0.3, 0.4),
},
}]
);
let submission_count = loaded.q3_submissions.len();
let fog_style_count = loaded.q3_fog_styles.len();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = fog_data_ptr;
loaded.cpu.gpr[4] = view + PPC_Q3_OBJECT_STRIDE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.q3_submissions.len(), submission_count);
assert_eq!(loaded.q3_fog_styles.len(), fog_style_count);
assert_eq!(
loaded.q3_error_state.first_error,
PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER
);
}
#[test]
fn hle_import_runner_removes_q3_side_state_on_object_dispose() {
let pef = synthetic_pef_with_library_import(b"QuickDraw\xaa 3D", b"Q3Object_Dispose");
let mut loaded = load_pef_application(&pef).unwrap();
let object = PPC_Q3_OBJECT_BASE;
let surviving_view = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 13;
let surviving_shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 14;
let surviving_attribute_set = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 15;
let secondary_only_view = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 16;
let secondary_only_primary = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 17;
let secondary_only_shader = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 18;
let secondary_only_light_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 19;
let secondary_only_light = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 20;
let file_owned_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 21;
let file_owned_parent_group = PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 22;
loaded.q3_objects.push(PpcQ3ObjectRecord {
object,
kind: PpcQ3ObjectKind::Generic,
object_type: PPC_Q3_TYPE_NONE,
source: PpcQ3ObjectSource::default(),
data_ptr: 0,
data_size: 0,
});
loaded
.q3_renderer_preferences
.push(PpcQ3RendererPreferenceRecord {
renderer: object,
double_buffer_bypass: Some(1),
preference_vendor: Some(PPC_QA_VENDOR_APPLE),
preference_engine: Some(PPC_QA_ENGINE_APPLE_SW),
rave_context_hints: Some(0x1234_5678),
rave_texture_filter: Some(2),
});
loaded.q3_files.push(PpcQ3FileRecord {
file: object,
storage: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
is_open: true,
object_type: 0,
read_offset: 0,
read_object: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2,
});
loaded
.q3_group_memberships
.push(PpcQ3GroupMembershipRecord {
group: object,
object: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
before: None,
});
loaded.q3_file_groups.push(PpcQ3FileGroupRecord {
file: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3,
offset: 24,
group: object,
group_type: u32::from_be_bytes(*b"dspg"),
parent_group: 0,
group_depth: 1,
});
loaded.q3_file_groups.push(PpcQ3FileGroupRecord {
file: object,
offset: 48,
group: file_owned_group,
group_type: u32::from_be_bytes(*b"ogtg"),
parent_group: file_owned_parent_group,
group_depth: 2,
});
loaded.q3_views.push(PpcQ3ViewStateRecord::new(object));
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view: object,
kind: PpcQ3SubmissionKind::Object,
primary: object,
secondary: 0,
});
loaded.q3_submissions.push(PpcQ3SubmissionRecord {
view: secondary_only_view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: secondary_only_primary,
secondary: object,
});
loaded.q3_view_transforms.push(PpcQ3ViewTransformRecord {
view: object,
stack: vec![ppc_q3_matrix4x4_identity()],
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view: object,
kind: PpcQ3SubmissionKind::Object,
primary: object,
secondary: 0,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded
.q3_submission_transforms
.push(PpcQ3SubmissionTransformRecord {
view: secondary_only_view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: secondary_only_primary,
secondary: object,
local_to_world: ppc_q3_matrix4x4_identity(),
});
loaded.q3_view_materials.push(PpcQ3ViewMaterialRecord {
view: object,
shader: object,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style: object,
kind: PpcQ3StyleKind::Fill,
value: 1,
}],
fog_style: Some(PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_LINEAR,
fog_start: 1.0,
fog_end: 2.0,
density: 0.5,
color: (0.1, 0.2, 0.3, 1.0),
}),
attributes: Vec::new(),
});
loaded.q3_view_materials.push(PpcQ3ViewMaterialRecord {
view: surviving_view,
shader: surviving_shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![
PpcQ3AttributeRecord {
attribute_set: object,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: vec![0; 12],
},
PpcQ3AttributeRecord {
attribute_set: surviving_attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: vec![1; 12],
},
],
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view: object,
kind: PpcQ3SubmissionKind::Object,
primary: object,
secondary: 0,
shader: object,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style: object,
kind: PpcQ3StyleKind::Fill,
value: 1,
}],
fog_style: Some(PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_LINEAR,
fog_start: 1.0,
fog_end: 2.0,
density: 0.5,
color: (0.1, 0.2, 0.3, 1.0),
}),
attributes: Vec::new(),
shader_uv_transform: Some(PpcQ3ShaderUvTransformRecord {
shader: object,
matrix: ppc_q3_matrix3x3_identity(),
}),
shader_boundary: Some(PpcQ3ShaderBoundaryRecord {
shader: object,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
}),
texture_shader: Some(PpcQ3TextureShaderRecord {
shader: object,
texture: object,
}),
mipmap_texture: Some(PpcQ3MipmapTextureRecord {
texture: object,
mipmap: vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize],
}),
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 2,
secondary: 0,
shader: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: Some(PpcQ3TextureShaderRecord {
shader: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 3,
texture: object,
}),
mipmap_texture: None,
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 7,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 8,
secondary: 0,
shader: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 9,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set: object,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: vec![0; 12],
}],
shader_uv_transform: None,
shader_boundary: Some(PpcQ3ShaderBoundaryRecord {
shader: object,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
}),
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_materials
.push(PpcQ3SubmissionMaterialRecord {
view: secondary_only_view,
kind: PpcQ3SubmissionKind::TriMesh,
primary: secondary_only_primary,
secondary: object,
shader: secondary_only_shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: None,
mipmap_texture: None,
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view: object,
kind: PpcQ3SubmissionKind::Object,
primary: object,
secondary: 0,
light_group: object,
lights: vec![PpcQ3LightRecord {
light: object,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.5,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Ambient,
}],
});
loaded
.q3_submission_lights
.push(PpcQ3SubmissionLightRecord {
view: secondary_only_view,
kind: PpcQ3SubmissionKind::Object,
primary: secondary_only_primary,
secondary: object,
light_group: secondary_only_light_group,
lights: vec![PpcQ3LightRecord {
light: secondary_only_light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.5,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Ambient,
}],
});
loaded
.q3_view_state_stack
.push(PpcQ3ViewStateSnapshotRecord {
view: object,
transform: Some(PpcQ3ViewTransformRecord {
view: object,
stack: vec![ppc_q3_matrix4x4_identity()],
local_to_world: ppc_q3_matrix4x4_identity(),
}),
material: Some(PpcQ3ViewMaterialRecord {
view: object,
shader: object,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: vec![PpcQ3StyleRecord {
style: object,
kind: PpcQ3StyleKind::Fill,
value: 1,
}],
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set: object,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: vec![0; 12],
}],
}),
});
loaded.q3_completed_frames.push(PpcQ3CompletedFrameRecord {
view: object,
submissions: vec![PpcQ3SubmissionRecord {
view: object,
kind: PpcQ3SubmissionKind::Object,
primary: object,
secondary: 0,
}],
submission_transforms: Vec::new(),
submission_materials: Vec::new(),
submission_lights: Vec::new(),
retained_trimeshes: Vec::new(),
});
loaded.q3_completed_frames.push(PpcQ3CompletedFrameRecord {
view: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4,
submissions: Vec::new(),
submission_transforms: Vec::new(),
submission_materials: vec![PpcQ3SubmissionMaterialRecord {
view: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 4,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 5,
secondary: 0,
shader: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: Vec::new(),
shader_uv_transform: None,
shader_boundary: None,
texture_shader: Some(PpcQ3TextureShaderRecord {
shader: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 6,
texture: object,
}),
mipmap_texture: None,
}],
submission_lights: Vec::new(),
retained_trimeshes: Vec::new(),
});
loaded.q3_completed_frames.push(PpcQ3CompletedFrameRecord {
view: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 10,
submissions: Vec::new(),
submission_transforms: Vec::new(),
submission_materials: vec![PpcQ3SubmissionMaterialRecord {
view: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 10,
kind: PpcQ3SubmissionKind::TriMesh,
primary: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 11,
secondary: 0,
shader: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE * 12,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set: object,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: vec![0; 12],
}],
shader_uv_transform: None,
shader_boundary: Some(PpcQ3ShaderBoundaryRecord {
shader: object,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
}),
texture_shader: None,
mipmap_texture: None,
}],
submission_lights: Vec::new(),
retained_trimeshes: Vec::new(),
});
loaded.q3_fog_styles.push(PpcQ3FogStyleRecord {
view: object,
data_ptr: PPC_DATA_BASE,
data: PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_LINEAR,
fog_start: 0.0,
fog_end: 100.0,
density: 1.0,
color: (1.0, 1.0, 1.0, 1.0),
},
});
loaded.q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage: object,
buffer_ptr: PPC_DATA_BASE,
valid_size: 16,
buffer_size: 32,
owns_buffer: false,
});
loaded.q3_attributes.push(PpcQ3AttributeRecord {
attribute_set: object,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: vec![0; 12],
});
loaded
.q3_shader_uv_transforms
.push(PpcQ3ShaderUvTransformRecord {
shader: object,
matrix: ppc_q3_matrix3x3_identity(),
});
loaded.q3_shader_boundaries.push(PpcQ3ShaderBoundaryRecord {
shader: object,
u_boundary: PPC_Q3_SHADER_UV_BOUNDARY_CLAMP,
v_boundary: PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
});
loaded.q3_mipmap_textures.push(PpcQ3MipmapTextureRecord {
texture: object,
mipmap: vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize],
});
loaded.q3_texture_shaders.push(PpcQ3TextureShaderRecord {
shader: object,
texture: PPC_Q3_OBJECT_BASE + PPC_Q3_OBJECT_STRIDE,
});
loaded.q3_trimeshes.push(PpcQ3TriMeshRecord {
trimesh: object,
data: vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize],
triangle_attribute_sets: Vec::new(),
get_data_copies: Vec::new(),
});
loaded.q3_styles.push(PpcQ3StyleRecord {
style: object,
kind: PpcQ3StyleKind::Fill,
value: 1,
});
loaded.q3_cameras.push(PpcQ3CameraRecord {
camera: object,
camera_type: PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
placement: PpcQ3CameraPlacement {
camera_location: (0.0, 0.0, 0.0),
point_of_interest: (0.0, 0.0, -1.0),
up_vector: (0.0, 1.0, 0.0),
},
range_hither: 0.1,
range_yon: 100.0,
viewport_origin: (-1.0, 1.0),
viewport_width: 2.0,
viewport_height: 2.0,
projection: PpcQ3CameraProjection::ViewAngleAspect {
fov: std::f32::consts::FRAC_PI_2,
aspect_ratio_x_to_y: 4.0 / 3.0,
},
});
loaded.q3_lights.push(PpcQ3LightRecord {
light: object,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data: PpcQ3LightData {
is_on: 1,
brightness: 0.5,
color: (1.0, 1.0, 1.0),
},
kind: PpcQ3LightKind::Ambient,
});
loaded.cpu.gpr[3] = object;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert!(loaded.q3_objects.is_empty());
assert!(loaded.q3_renderer_preferences.is_empty());
assert!(loaded.q3_files.is_empty());
assert!(loaded.q3_group_memberships.is_empty());
assert_eq!(
loaded.q3_file_groups,
vec![PpcQ3FileGroupRecord {
file: object,
offset: 48,
group: file_owned_group,
group_type: u32::from_be_bytes(*b"ogtg"),
parent_group: file_owned_parent_group,
group_depth: 2,
}]
);
assert!(loaded.q3_views.is_empty());
assert!(loaded.q3_submissions.is_empty());
assert!(loaded.q3_view_transforms.is_empty());
assert!(loaded.q3_submission_transforms.is_empty());
assert_eq!(
loaded.q3_view_materials,
vec![PpcQ3ViewMaterialRecord {
view: surviving_view,
shader: surviving_shader,
illumination_type: PPC_Q3_ILLUMINATION_TYPE_PHONG,
styles: Vec::new(),
fog_style: None,
attributes: vec![PpcQ3AttributeRecord {
attribute_set: surviving_attribute_set,
attribute_type: PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR,
data: vec![1; 12],
}],
}]
);
assert!(loaded.q3_submission_materials.is_empty());
assert!(loaded.q3_submission_lights.is_empty());
assert!(loaded.q3_view_state_stack.is_empty());
assert!(loaded.q3_completed_frames.is_empty());
assert!(loaded.q3_fog_styles.is_empty());
assert!(loaded.q3_memory_storages.is_empty());
assert!(loaded.q3_attributes.is_empty());
assert!(loaded.q3_shader_uv_transforms.is_empty());
assert!(loaded.q3_shader_boundaries.is_empty());
assert!(loaded.q3_mipmap_textures.is_empty());
assert!(loaded.q3_texture_shaders.is_empty());
assert!(loaded.q3_trimeshes.is_empty());
assert!(loaded.q3_styles.is_empty());
assert!(loaded.q3_cameras.is_empty());
assert!(loaded.q3_lights.is_empty());
}
#[test]
fn hle_import_runner_handles_qa_first_engine() {
let pef = synthetic_pef_with_library_import(
b"QuickDraw\xaa 3D Accelerator",
b"QADeviceGetFirstEngine",
);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_QA_ENGINE);
assert_eq!(loaded.memory.read_u8(PPC_QA_ENGINE), Some(0));
}
#[test]
fn hle_import_runner_handles_qa_next_engine_end_of_list() {
let pef = synthetic_pef_with_library_import(
b"QuickDraw\xaa 3D Accelerator",
b"QADeviceGetNextEngine",
);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = PPC_QA_ENGINE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn hle_import_runner_handles_qa_engine_gestalt() {
let pef =
synthetic_pef_with_library_import(b"QuickDraw\xaa 3D Accelerator", b"QAEngineGestalt");
let mut loaded = load_pef_application(&pef).unwrap();
let response_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(response_ptr, vec![0xaa; 64]);
loaded.cpu.gpr[3] = PPC_QA_ENGINE;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = response_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(response_ptr),
Some(ppc_qa_optional_features())
);
for (selector, expected) in [
(1, ppc_qa_fast_features()),
(2, PPC_QA_VENDOR_APPLE),
(3, PPC_QA_ENGINE_APPLE_SW),
(4, 1),
(5, PPC_QA_ENGINE_NAME.len() as u32),
(7, PPC_QA_AVAILABLE_TEXTURE_MEMORY),
(42, 0),
] {
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(response_ptr, vec![0xaa; 4]);
loaded.cpu.gpr[3] = PPC_QA_ENGINE;
loaded.cpu.gpr[4] = selector;
loaded.cpu.gpr[5] = response_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1, "selector {selector}");
assert_eq!(probe.unsupported_import_index, None, "selector {selector}");
assert_eq!(loaded.cpu.gpr[3], 0, "selector {selector}");
assert_eq!(
loaded.memory.read_u32_be(response_ptr),
Some(expected),
"selector {selector}"
);
}
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(response_ptr, vec![0xaa; 64]);
loaded.cpu.gpr[3] = PPC_QA_ENGINE;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = response_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for (offset, byte) in PPC_QA_ENGINE_NAME.iter().copied().enumerate() {
assert_eq!(
loaded.memory.read_u8(response_ptr + offset as u32),
Some(byte)
);
}
assert_eq!(
loaded
.memory
.read_u8(response_ptr + PPC_QA_ENGINE_NAME.len() as u32),
Some(0)
);
let mut loaded = load_pef_application(&pef).unwrap();
let short_word_response_ptr = PPC_DATA_BASE + 0x1100;
loaded
.memory
.add_region(short_word_response_ptr, vec![0xee; 2]);
loaded.cpu.gpr[3] = PPC_QA_ENGINE;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = short_word_response_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.memory.read_u8(short_word_response_ptr), Some(0xee));
assert_eq!(
loaded.memory.read_u8(short_word_response_ptr + 1),
Some(0xee)
);
let mut loaded = load_pef_application(&pef).unwrap();
let short_name_response_ptr = PPC_DATA_BASE + 0x1200;
loaded
.memory
.add_region(short_name_response_ptr, vec![0xdd; 4]);
loaded.cpu.gpr[3] = PPC_QA_ENGINE;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = short_name_response_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(
loaded.memory.read_u32_be(short_name_response_ptr),
Some(0xdddd_dddd)
);
let mut loaded = load_pef_application(&pef).unwrap();
let invalid_engine_response_ptr = PPC_DATA_BASE + 0x1300;
loaded
.memory
.add_region(invalid_engine_response_ptr, vec![0xcc; 4]);
loaded.cpu.gpr[3] = PPC_QA_ENGINE + 4;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = invalid_engine_response_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(
loaded.memory.read_u32_be(invalid_engine_response_ptr),
Some(0xcccc_cccc)
);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_QA_ENGINE;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
}
#[test]
fn hle_import_runner_tracks_quicktime_init_and_error_state() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"EnterMovies");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0xfeed_face;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.quicktime.movie_toolbox_enter_count, 1);
assert_eq!(loaded.quicktime.movie_toolbox_exit_count, 0);
assert_eq!(loaded.quicktime.movie_toolbox_init_depth, 1);
assert_eq!(loaded.quicktime.movie_error, PPC_NO_ERR);
assert_eq!(loaded.quicktime.movie_sticky_error, PPC_NO_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGraphicsImportSetGWorld;
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0x0600_3000;
loaded.cpu.gpr[5] = 0x0600_4000;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.quicktime.movie_error, PPC_PARAM_ERR);
assert_eq!(loaded.quicktime.movie_sticky_error, PPC_PARAM_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGetMoviesError;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.quicktime.movie_error, PPC_NO_ERR);
assert_eq!(loaded.quicktime.movie_sticky_error, PPC_PARAM_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGetMoviesStickyError;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.quicktime.movie_error, PPC_NO_ERR);
assert_eq!(loaded.quicktime.movie_sticky_error, PPC_PARAM_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtClearMoviesStickyError;
loaded.cpu.gpr[3] = 0xfeed_face;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xfeed_face);
assert_eq!(loaded.quicktime.movie_error, PPC_NO_ERR);
assert_eq!(loaded.quicktime.movie_sticky_error, PPC_NO_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtExitMovies;
loaded.cpu.gpr[3] = 0xcafe_babe;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xcafe_babe);
assert_eq!(loaded.quicktime.movie_toolbox_enter_count, 1);
assert_eq!(loaded.quicktime.movie_toolbox_exit_count, 1);
assert_eq!(loaded.quicktime.movie_toolbox_init_depth, 0);
}
#[test]
fn hle_import_runner_tracks_quicktime_movie_file_box_and_beginning_state() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"OpenMovieFile");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let ref_num_out_ptr = scratch;
let rect_ptr = scratch + 16;
let box_out_ptr = scratch + 32;
let movie_out_ptr = scratch + 48;
let movie_spec_ptr = scratch + 64;
let movie_data = test_quicktime_tkhd_movie(320, 240);
let expected_audio_samples = vec![0x80, 0x90, 0x70, 0x60, 0x50, 0x40];
let expected_video_track = PpcQuickTimeVideoTrackRecord {
media_time_scale: 60,
media_duration: 120,
sample_count: 2,
first_sample_duration: 60,
first_sample_size: 4,
first_chunk_offset: 8,
first_sample_data_len: 4,
first_sample_checksum: 0xa0,
first_sample_preview_len: 4,
first_sample_preview: [0x10, 0x20, 0x30, 0x40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
first_samples_per_chunk: 2,
sample_description_id: 1,
codec: u32::from_be_bytes(*b"rle "),
};
let expected_video_samples = PpcQuickTimeVideoSampleTableRecord {
media_time_scale: 60,
media_duration: 120,
sample_count: 2,
codec: u32::from_be_bytes(*b"rle "),
samples: vec![
PpcQuickTimeVideoSampleRecord {
offset: 8,
size: 4,
media_start_time: 0,
duration: 60,
data_len: 4,
checksum: 0xa0,
preview_len: 4,
preview: [0x10, 0x20, 0x30, 0x40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
},
PpcQuickTimeVideoSampleRecord {
offset: 12,
size: 4,
media_start_time: 60,
duration: 60,
data_len: 4,
checksum: 0x1e0,
preview_len: 4,
preview: [0x80, 0x90, 0x70, 0x60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
},
],
};
let expected_audio_track = PpcQuickTimeAudioTrackRecord {
media_time_scale: 22_050,
media_duration: 6,
sample_count: 6,
first_sample_duration: 1,
first_sample_size: 1,
first_chunk_offset: 16,
first_sample_data_len: 1,
first_sample_checksum: 0x80,
first_sample_preview_len: 1,
first_sample_preview: [0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
first_samples_per_chunk: 6,
sample_description_id: 1,
codec: u32::from_be_bytes(*b"raw "),
channel_count: 1,
sample_size_bits: 8,
sample_rate_fixed: 22_050u32 << 16,
};
loaded.memory.add_region(scratch, vec![0xaa; 80]);
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: "Intro.mov".to_string(),
data: (movie_data.clone()).into(),
creator: 0,
file_type: u32::from_be_bytes(*b"MooV"),
finder_flags: 0,
dirty: false,
});
write_ppc_fsspec(
&mut loaded.memory,
movie_spec_ptr,
PPC_BOOT_VOLUME_REF_NUM,
PPC_ROOT_DIR_ID,
b"Intro.mov",
);
loaded.cpu.gpr[3] = movie_spec_ptr;
loaded.cpu.gpr[4] = ref_num_out_ptr;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u16_be(ref_num_out_ptr),
Some(PPC_FIRST_FILE_REF_NUM as u16)
);
assert_eq!(loaded.quicktime.movie_file_open_count, 1);
assert_eq!(loaded.quicktime.movie_file_ref_num, PPC_FIRST_FILE_REF_NUM);
assert_eq!(loaded.quicktime.movie_file_path, "Intro.mov");
assert_eq!(loaded.quicktime.movie_file_data, movie_data);
assert_eq!(loaded.quicktime.movie_file_bounds, Some((0, 0, 240, 320)));
assert_eq!(loaded.quicktime.movie_file_time_scale, 60);
assert_eq!(loaded.quicktime.movie_file_duration, 120);
assert_eq!(loaded.quicktime.movie_file_tasks_until_done, 120);
assert_eq!(
loaded.quicktime.movie_file_video_track,
Some(expected_video_track)
);
assert_eq!(
loaded.quicktime.movie_file_video_samples,
Some(expected_video_samples.clone())
);
assert_eq!(
loaded.quicktime.movie_file_audio_track,
Some(expected_audio_track)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtNewMovieFromFile;
loaded.cpu.gpr[3] = movie_out_ptr;
loaded.cpu.gpr[4] = PPC_FIRST_FILE_REF_NUM as u16 as u32;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[8] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(movie_out_ptr), Some(PPC_QT_MOVIE));
assert!(loaded.quicktime.movie_at_beginning);
assert_eq!(loaded.quicktime.movie_box, (0, 0, 240, 320));
assert_eq!(loaded.quicktime.movie_tasks_until_done, 120);
assert_eq!(
loaded.quicktime.movie_video_track,
Some(expected_video_track)
);
assert_eq!(
loaded.quicktime.movie_video_samples,
Some(expected_video_samples.clone())
);
assert_eq!(
loaded.quicktime.movie_audio_track,
Some(expected_audio_track)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtStartMovie;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(loaded.quicktime.movie_started);
assert_eq!(loaded.sound.file_playbacks.len(), 1);
let movie_audio_playback = loaded.sound.file_playbacks.last().copied().unwrap();
assert_eq!(movie_audio_playback.channel, PPC_QT_MOVIE);
assert_eq!(movie_audio_playback.ref_num, PPC_FIRST_FILE_REF_NUM);
assert_eq!(
loaded.sound.manager.file_playback_paused(PPC_QT_MOVIE),
Some(false)
);
assert_eq!(
movie_audio_playback.decoded_aiff,
Some(PpcDecodedAiffSamples {
sample_rate_fixed: 22_050u32 << 16,
sample_count: 6,
preview_len: 6,
preview: [0x80, 0x90, 0x70, 0x60, 0x50, 0x40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
})
);
assert_eq!(
loaded.sound.decoded_file_playbacks,
vec![PpcDecodedAiffPlaybackRecord {
file_playback_index: 0,
channel: PPC_QT_MOVIE,
sample_rate_fixed: 22_050u32 << 16,
samples: expected_audio_samples.clone(),
}]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtStopMovie;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(!loaded.quicktime.movie_started);
assert_eq!(
loaded.sound.manager.file_playback_paused(PPC_QT_MOVIE),
None
);
loaded.quicktime.movie_started = true;
loaded.quicktime.movie_task_count = 119;
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtIsMovieDone;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.quicktime.movie_task_count = 120;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
ppc_write_rect(&mut loaded.memory, rect_ptr, 10, 20, 80, 120).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtSetMovieBox;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
loaded.cpu.gpr[4] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_QT_MOVIE);
assert_eq!(loaded.quicktime.movie_box, (10, 20, 80, 120));
assert_eq!(loaded.quicktime.movie_set_box_count, 1);
assert_eq!(loaded.quicktime.movie_error, PPC_NO_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGetMovieBox;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
loaded.cpu.gpr[4] = box_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_QT_MOVIE);
assert_eq!(
ppc_read_rect(&mut loaded.memory, box_out_ptr),
Some((10, 20, 80, 120))
);
loaded.sound.manager.play_file_buffer(
PPC_QT_MOVIE,
vec![0x80],
crate::sound::OUTPUT_RATE << 16,
None,
);
assert_eq!(
loaded.sound.manager.toggle_file_paused(PPC_QT_MOVIE),
Some(true)
);
loaded.quicktime.movie_started = true;
loaded.quicktime.movie_task_count = 3;
loaded.quicktime.movie_at_beginning = false;
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGoToBeginningOfMovie;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_QT_MOVIE);
assert_eq!(loaded.quicktime.movie_beginning_count, 1);
assert!(loaded.quicktime.movie_at_beginning);
assert!(!loaded.quicktime.movie_started);
assert_eq!(loaded.quicktime.movie_task_count, 0);
assert_eq!(
loaded.sound.manager.file_playback_paused(PPC_QT_MOVIE),
None
);
loaded.quicktime.movie_file_duration = 240;
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGetMovieDuration;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 240);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtLoadMovieIntoRam;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 240;
loaded.cpu.gpr[6] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.quicktime.movie_started = true;
loaded.quicktime.movie_at_beginning = true;
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGoToEndOfMovie;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(!loaded.quicktime.movie_at_beginning);
assert!(!loaded.quicktime.movie_started);
assert!(loaded.quicktime.movie_task_count >= 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtCloseMovieFile;
loaded.cpu.gpr[3] = PPC_FIRST_FILE_REF_NUM as u16 as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.quicktime.movie_file_close_count, 1);
assert_eq!(
loaded.quicktime.movie_file_last_closed_ref_num,
PPC_FIRST_FILE_REF_NUM
);
assert_eq!(loaded.quicktime.movie_file_ref_num, 0);
}
#[test]
fn quicktime_open_movie_file_combines_data_and_movie_resource_forks() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"OpenMovieFile");
let mut loaded = load_pef_application(&pef).unwrap();
let ref_num_out_ptr = PPC_DATA_BASE + 0x1000;
let movie_spec_ptr = PPC_DATA_BASE + 0x1020;
let movie_out_ptr = PPC_DATA_BASE + 0x1080;
let res_id_ptr = PPC_DATA_BASE + 0x1090;
let changed_ptr = PPC_DATA_BASE + 0x1092;
loaded.memory.add_region(ref_num_out_ptr, vec![0; 2]);
loaded.memory.add_region(movie_spec_ptr, vec![0; 80]);
loaded.memory.add_region(movie_out_ptr, vec![0; 4]);
loaded.memory.add_region(res_id_ptr, vec![0; 2]);
loaded.memory.add_region(changed_ptr, vec![0; 1]);
let complete_movie = test_quicktime_tkhd_movie(320, 240);
let movie_resource = ppc_qt_top_level_atom(&complete_movie, b"moov")
.expect("synthetic movie has a movie atom")
.to_vec();
let data_fork_len = complete_movie.len() - movie_resource.len();
let data_fork = complete_movie[..data_fork_len].to_vec();
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: "Music/Theme".to_string(),
data: (data_fork).into(),
creator: 0,
file_type: u32::from_be_bytes(*b"MooV"),
finder_flags: 0,
dirty: false,
});
let resource_fork = serialize_resource_fork(&[ResourceForkEntry {
res_type: *b"moov",
id: 128,
name: Vec::new(),
data: movie_resource,
attrs: 0,
}])
.unwrap();
loaded.push_vfs_resource_file(PpcVfsResourceFileRecord {
path: "music/theme".to_string(),
creator: 0,
file_type: u32::from_be_bytes(*b"MooV"),
finder_flags: 0,
resource_len: u32::try_from(resource_fork.len()).unwrap(),
raw_data: Some(resource_fork.into()),
map_attrs: 0,
dirty: false,
});
write_ppc_fsspec(
&mut loaded.memory,
movie_spec_ptr,
PPC_BOOT_VOLUME_REF_NUM,
PPC_ROOT_DIR_ID,
b"Music:Theme",
);
loaded.cpu.gpr[3] = movie_spec_ptr;
loaded.cpu.gpr[4] = ref_num_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.quicktime.movie_file_data,
complete_movie[..data_fork_len]
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtNewMovieFromFile;
loaded.cpu.gpr[3] = movie_out_ptr;
loaded.cpu.gpr[4] = PPC_FIRST_FILE_REF_NUM as u32;
loaded.cpu.gpr[5] = res_id_ptr;
loaded.cpu.gpr[8] = changed_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u16_be(res_id_ptr), Some(128));
assert_eq!(loaded.quicktime.movie_file_data, complete_movie);
assert_eq!(loaded.quicktime.movie_file_bounds, Some((0, 0, 240, 320)));
assert_eq!(loaded.quicktime.movie_file_time_scale, 60);
assert_eq!(loaded.quicktime.movie_file_duration, 120);
assert!(loaded.quicktime.movie_file_video_track.is_some());
assert!(loaded.quicktime.movie_file_audio_track.is_some());
loaded
.memory
.write_u32_be(movie_out_ptr, 0xdead_beef)
.unwrap();
loaded.memory.write_u16_be(res_id_ptr, 777).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.gpr[3] = movie_out_ptr;
loaded.cpu.gpr[4] = PPC_FIRST_FILE_REF_NUM as u32;
loaded.cpu.gpr[5] = res_id_ptr;
loaded.cpu.gpr[8] = changed_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_RES_NOT_FOUND_ERR));
assert_eq!(loaded.memory.read_u32_be(movie_out_ptr), Some(0));
}
#[test]
fn quicktime_movie_resource_selection_honors_requested_id() {
let first_movie = test_quicktime_tkhd_movie(320, 240);
let second_movie = test_quicktime_tkhd_movie(640, 480);
let first_moov = ppc_qt_top_level_atom(&first_movie, b"moov").unwrap();
let second_moov = ppc_qt_top_level_atom(&second_movie, b"moov").unwrap();
let data_fork = first_movie[..first_movie.len() - first_moov.len()].to_vec();
let resource_fork = serialize_resource_fork(&[
ResourceForkEntry {
res_type: *b"moov",
id: 128,
name: Vec::new(),
data: first_moov.to_vec(),
attrs: 0,
},
ResourceForkEntry {
res_type: *b"moov",
id: 129,
name: Vec::new(),
data: second_moov.to_vec(),
attrs: 0,
},
])
.unwrap();
let resource_files = [PpcVfsResourceFileRecord {
path: "Music/Theme".to_string(),
creator: 0,
file_type: u32::from_be_bytes(*b"MooV"),
finder_flags: 0,
resource_len: u32::try_from(resource_fork.len()).unwrap(),
raw_data: Some(resource_fork.into()),
map_attrs: 0,
dirty: false,
}];
let mut selected = data_fork.clone();
assert_eq!(
ppc_qt_append_movie_resource(
&mut selected,
&resource_files,
&[],
"music/theme",
Some(129),
),
Some(129)
);
assert_eq!(ppc_qt_movie_bounds(&selected), Some((0, 0, 480, 640)));
selected = data_fork.clone();
assert_eq!(
ppc_qt_append_movie_resource(
&mut selected,
&resource_files,
&[],
"Music/Theme",
Some(128),
),
Some(128)
);
assert_eq!(ppc_qt_movie_bounds(&selected), Some((0, 0, 240, 320)));
selected = first_movie.clone();
assert_eq!(
ppc_qt_append_movie_resource(
&mut selected,
&resource_files,
&[],
"Music/Theme",
Some(129),
),
Some(129)
);
assert_eq!(ppc_qt_movie_bounds(&selected), Some((0, 0, 480, 640)));
selected = data_fork;
assert_eq!(
ppc_qt_append_movie_resource(
&mut selected,
&resource_files,
&[],
"Music/Theme",
Some(-1),
),
None
);
}
#[test]
fn quicktime_movie_audio_decoder_downmixes_twos_16_bit_first_chunk() {
let mut movie_file_data = vec![0; 12];
movie_file_data.extend_from_slice(&[0x00, 0x00, 0x40, 0x00, 0xc0, 0x00]);
let decoded = ppc_qt_decode_movie_audio_samples(&PpcQuickTimeState {
movie_file_data,
movie_audio_track: Some(PpcQuickTimeAudioTrackRecord {
media_time_scale: 44_100,
media_duration: 3,
sample_count: 3,
first_sample_duration: 1,
first_sample_size: 1,
first_chunk_offset: 12,
first_sample_data_len: 1,
first_sample_checksum: 0,
first_sample_preview_len: 0,
first_sample_preview: [0; 16],
first_samples_per_chunk: 3,
sample_description_id: 1,
codec: u32::from_be_bytes(*b"twos"),
channel_count: 1,
sample_size_bits: 16,
sample_rate_fixed: 44_100u32 << 16,
}),
..PpcQuickTimeState::default()
})
.expect("16-bit twos movie chunk decodes");
assert_eq!(decoded.samples, vec![0x80, 0xc0, 0x40]);
assert_eq!(
decoded.summary,
PpcDecodedAiffSamples {
sample_rate_fixed: 44_100u32 << 16,
sample_count: 3,
preview_len: 3,
preview: [0x80, 0xc0, 0x40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
}
);
}
#[test]
fn quicktime_music_track_synthesizes_note_events() {
fn push_u32(bytes: &mut Vec<u8>, value: u32) {
bytes.extend_from_slice(&value.to_be_bytes());
}
let note = (1u32 << 29) | (28 << 18) | (127 << 11) | 300;
let mut movie_file_data = Vec::new();
push_quicktime_atom(&mut movie_file_data, b"mdat", ¬e.to_be_bytes());
let mut mdhd_payload = vec![0; 24];
mdhd_payload[12..16].copy_from_slice(&600u32.to_be_bytes());
mdhd_payload[16..20].copy_from_slice(&300u32.to_be_bytes());
let mut hdlr_payload = vec![0; 24];
hdlr_payload[4..8].copy_from_slice(b"mhlr");
hdlr_payload[8..12].copy_from_slice(b"musi");
let mut stsc_payload = Vec::new();
push_u32(&mut stsc_payload, 0);
push_u32(&mut stsc_payload, 1);
push_u32(&mut stsc_payload, 1);
push_u32(&mut stsc_payload, 1);
let mut stts_payload = Vec::new();
push_u32(&mut stts_payload, 0);
push_u32(&mut stts_payload, 1);
push_u32(&mut stts_payload, 1);
push_u32(&mut stts_payload, 300);
push_u32(&mut stsc_payload, 1);
let mut stsd_payload = Vec::new();
push_u32(&mut stsd_payload, 0);
push_u32(&mut stsd_payload, 1);
push_u32(&mut stsd_payload, 20);
stsd_payload.extend_from_slice(b"musi");
stsd_payload.extend_from_slice(&[0; 12]);
let mut stsz_payload = Vec::new();
push_u32(&mut stsz_payload, 0);
push_u32(&mut stsz_payload, 4);
push_u32(&mut stsz_payload, 1);
let mut stco_payload = Vec::new();
push_u32(&mut stco_payload, 0);
push_u32(&mut stco_payload, 1);
push_u32(&mut stco_payload, 8);
let mut stbl_payload = Vec::new();
push_quicktime_atom(&mut stbl_payload, b"stsd", &stsd_payload);
push_quicktime_atom(&mut stbl_payload, b"stts", &stts_payload);
push_quicktime_atom(&mut stbl_payload, b"stsc", &stsc_payload);
push_quicktime_atom(&mut stbl_payload, b"stsz", &stsz_payload);
push_quicktime_atom(&mut stbl_payload, b"stco", &stco_payload);
let mut minf_payload = Vec::new();
push_quicktime_atom(&mut minf_payload, b"stbl", &stbl_payload);
let mut mdia_payload = Vec::new();
push_quicktime_atom(&mut mdia_payload, b"mdhd", &mdhd_payload);
push_quicktime_atom(&mut mdia_payload, b"hdlr", &hdlr_payload);
push_quicktime_atom(&mut mdia_payload, b"minf", &minf_payload);
let mut trak_payload = Vec::new();
push_quicktime_atom(&mut trak_payload, b"mdia", &mdia_payload);
let mut moov_payload = Vec::new();
push_quicktime_atom(&mut moov_payload, b"trak", &trak_payload);
push_quicktime_atom(&mut movie_file_data, b"moov", &moov_payload);
let decoded = ppc_qt_movie_audio_samples(&movie_file_data).expect("music track decodes");
assert_eq!(decoded.summary.sample_rate_fixed, 22_050u32 << 16);
assert_eq!(decoded.samples.len(), 11_025);
assert!(decoded.samples.iter().any(|sample| *sample != 0x80));
}
#[test]
fn quicktime_music_sample_description_maps_parts_to_gm_instruments() {
let mut note_request = vec![0; 84];
note_request[76..80].copy_from_slice(&40u32.to_be_bytes());
note_request[80..84].copy_from_slice(&82u32.to_be_bytes());
let mut entry = Vec::new();
entry.extend_from_slice(&112u32.to_be_bytes());
entry.extend_from_slice(b"musi");
entry.extend_from_slice(&[0; 6]);
entry.extend_from_slice(&1u16.to_be_bytes());
entry.extend_from_slice(&0u32.to_be_bytes());
entry.extend_from_slice(&0xf005_0017u32.to_be_bytes());
entry.extend_from_slice(¬e_request);
entry.extend_from_slice(&0xc001_0017u32.to_be_bytes());
let mut stsd = vec![0; 4];
stsd.extend_from_slice(&1u32.to_be_bytes());
stsd.extend_from_slice(&entry);
let descriptions = ppc_qt_music_sample_descriptions(&stsd, 0, stsd.len()).unwrap();
assert_eq!(
descriptions,
vec![vec![PpcQuickTimeMusicPart {
part: 5,
instrument_number: 40,
gm_number: 82,
}]]
);
let last = stsd.len() - 4;
stsd[last..].copy_from_slice(&0xc001_0016u32.to_be_bytes());
assert!(ppc_qt_music_sample_descriptions(&stsd, 0, stsd.len()).is_none());
stsd[4..8].copy_from_slice(&u32::MAX.to_be_bytes());
assert!(ppc_qt_music_sample_descriptions(&stsd, 0, stsd.len()).is_none());
stsd[4..8].copy_from_slice(&1u32.to_be_bytes());
stsd[12..16].copy_from_slice(b"soun");
assert!(ppc_qt_music_sample_descriptions(&stsd, 0, stsd.len()).is_none());
}
#[test]
fn quicktime_music_uses_stts_sample_starts_and_controller_volume() {
let note = (1u32 << 29) | (28 << 18) | (127 << 11) | 10;
let data = [note.to_be_bytes(), note.to_be_bytes()].concat();
let mut info = PpcQuickTimeMusicDecodeInfo {
handler_subtype: u32::from_be_bytes(*b"musi"),
media_time_scale: 100,
media_duration: 200,
sample_durations: vec![100, 100],
sample_sizes: vec![4, 4],
stsc_entries: vec![PpcQuickTimeStscEntry {
first_chunk: 1,
samples_per_chunk: 2,
sample_description_id: 1,
}],
chunk_offsets: vec![0],
sample_descriptions: vec![vec![PpcQuickTimeMusicPart {
part: 0,
instrument_number: 40,
gm_number: 40,
}]],
};
let decoded = ppc_qt_synthesize_music_track(&data, &info).unwrap();
assert!(decoded.samples[..2_205]
.iter()
.any(|sample| *sample != 0x80));
assert!(decoded.samples[2_205..22_050]
.iter()
.all(|sample| *sample == 0x80));
assert!(decoded.samples[22_050..24_255]
.iter()
.any(|sample| *sample != 0x80));
let mute = (2u32 << 29) | (7 << 16);
let mut mixed = vec![0; 4_000];
let mut parts = vec![PpcQuickTimeMusicPartState {
part: 0,
instrument: 40,
volume: i16::MAX,
pitch_bend: 0,
sustain: false,
}];
let events = [mute.to_be_bytes(), note.to_be_bytes()].concat();
assert!(
ppc_qt_synthesize_music_events(&events, 600, 0, &mut mixed, 22_050, &mut parts,)
.is_some()
);
assert!(mixed.iter().all(|sample| *sample == 0));
let malformed_extended_note = [0x9000_003cu32.to_be_bytes(), 0u32.to_be_bytes()].concat();
assert!(ppc_qt_synthesize_music_events(
&malformed_extended_note,
600,
0,
&mut mixed,
22_050,
&mut parts,
)
.is_none());
let invalid_end_value = 0x6000_0001u32.to_be_bytes();
assert!(ppc_qt_synthesize_music_events(
&invalid_end_value,
600,
0,
&mut mixed,
22_050,
&mut parts,
)
.is_none());
let end_with_trailing_data = [0x6000_0000u32.to_be_bytes(), note.to_be_bytes()].concat();
assert!(ppc_qt_synthesize_music_events(
&end_with_trailing_data,
600,
0,
&mut mixed,
22_050,
&mut parts,
)
.is_none());
info.stsc_entries[0].sample_description_id = 2;
assert!(ppc_qt_synthesize_music_track(&data, &info).is_none());
let invalid_stsc = [
0u32, 2, // version/flags, entry count
1, 1, 1, // first entry
1, 1, 1, // non-increasing second entry
]
.into_iter()
.flat_map(u32::to_be_bytes)
.collect::<Vec<_>>();
assert!(ppc_qt_stsc_entries(&invalid_stsc, 0, invalid_stsc.len()).is_none());
}
#[test]
fn quicktime_music_timbre_follows_instrument_not_part_number() {
let mut first = vec![0; 2_000];
let mut same = vec![0; 2_000];
let mut different = vec![0; 2_000];
let state = PpcQuickTimeMusicPartState {
part: 0,
instrument: 40,
volume: i16::MAX,
pitch_bend: 0,
sustain: false,
};
ppc_qt_mix_music_note(&mut first, 0, 30, 60.0, 100, state, 600, 22_050).unwrap();
ppc_qt_mix_music_note(
&mut same,
0,
30,
60.0,
100,
PpcQuickTimeMusicPartState { part: 5, ..state },
600,
22_050,
)
.unwrap();
ppc_qt_mix_music_note(
&mut different,
0,
30,
60.0,
100,
PpcQuickTimeMusicPartState {
instrument: 82,
..state
},
600,
22_050,
)
.unwrap();
assert_eq!(first, same);
assert_ne!(first, different);
}
#[test]
fn quicktime_movie_frame_salt_uses_current_video_sample_payload() {
let mut quicktime = PpcQuickTimeState {
movie_tasks_until_done: 2,
movie_video_samples: Some(PpcQuickTimeVideoSampleTableRecord {
media_time_scale: 60,
media_duration: 2,
sample_count: 2,
codec: u32::from_be_bytes(*b"rle "),
samples: vec![
PpcQuickTimeVideoSampleRecord {
offset: 8,
size: 4,
media_start_time: 0,
duration: 1,
data_len: 4,
checksum: 0x10,
preview_len: 1,
preview: [0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
},
PpcQuickTimeVideoSampleRecord {
offset: 12,
size: 5,
media_start_time: 1,
duration: 1,
data_len: 5,
checksum: 0x2f,
preview_len: 1,
preview: [0x2f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
},
],
}),
..PpcQuickTimeState::default()
};
let first_salt = ppc_qt_movie_frame_salt(&quicktime, 0x21);
quicktime.movie_task_count = 1;
let second_salt = ppc_qt_movie_frame_salt(&quicktime, 0x21);
assert_ne!(first_salt, second_salt);
}
#[test]
fn quicktime_stts_expands_sample_durations() {
let mut payload = Vec::new();
payload.extend_from_slice(&0u32.to_be_bytes());
payload.extend_from_slice(&2u32.to_be_bytes());
payload.extend_from_slice(&1u32.to_be_bytes());
payload.extend_from_slice(&10u32.to_be_bytes());
payload.extend_from_slice(&2u32.to_be_bytes());
payload.extend_from_slice(&20u32.to_be_bytes());
assert_eq!(
ppc_qt_stts_sample_durations(&payload, 0, payload.len()),
Some(vec![10, 20, 20])
);
}
#[test]
fn quicktime_movie_timed_sample_index_uses_media_time() {
let mut quicktime = PpcQuickTimeState {
movie_tasks_until_done: 4,
..PpcQuickTimeState::default()
};
let samples = PpcQuickTimeVideoSampleTableRecord {
media_time_scale: 4,
media_duration: 4,
sample_count: 2,
codec: u32::from_be_bytes(*b"cvid"),
samples: vec![
PpcQuickTimeVideoSampleRecord {
offset: 0,
size: 1,
media_start_time: 0,
duration: 1,
data_len: 1,
checksum: 0,
preview_len: 0,
preview: [0; 16],
},
PpcQuickTimeVideoSampleRecord {
offset: 1,
size: 1,
media_start_time: 1,
duration: 3,
data_len: 1,
checksum: 0,
preview_len: 0,
preview: [0; 16],
},
],
};
assert_eq!(
ppc_qt_movie_timed_sample_index(&quicktime, &samples),
Some(0)
);
quicktime.movie_task_count = 1;
assert_eq!(
ppc_qt_movie_timed_sample_index(&quicktime, &samples),
Some(1)
);
quicktime.movie_task_count = 3;
assert_eq!(
ppc_qt_movie_timed_sample_index(&quicktime, &samples),
Some(1)
);
}
#[test]
fn quicktime_cinepak_decoder_expands_v1_blocks() {
let sample = test_cinepak_v1_frame_sample();
let mut decoder = PpcQuickTimeCinepakDecoder::new(4, 4).unwrap();
decoder.decode_sample(&sample).unwrap();
let frame = decoder.decoded_frame();
assert_eq!(ppc_test_rgb_at(&frame, 0, 0), [0, 0, 0]);
assert_eq!(ppc_test_rgb_at(&frame, 2, 0), [85, 85, 85]);
assert_eq!(ppc_test_rgb_at(&frame, 0, 2), [170, 170, 170]);
assert_eq!(ppc_test_rgb_at(&frame, 3, 3), [255, 255, 255]);
}
#[test]
fn quicktime_cinepak_decoder_expands_v4_blocks() {
let sample = test_cinepak_v4_frame_sample();
let mut decoder = PpcQuickTimeCinepakDecoder::new(4, 4).unwrap();
decoder.decode_sample(&sample).unwrap();
let frame = decoder.decoded_frame();
assert_eq!(ppc_test_rgb_at(&frame, 0, 0), [10, 10, 10]);
assert_eq!(ppc_test_rgb_at(&frame, 1, 0), [20, 20, 20]);
assert_eq!(ppc_test_rgb_at(&frame, 2, 0), [50, 50, 50]);
assert_eq!(ppc_test_rgb_at(&frame, 3, 0), [60, 60, 60]);
assert_eq!(ppc_test_rgb_at(&frame, 0, 2), [90, 90, 90]);
assert_eq!(ppc_test_rgb_at(&frame, 3, 3), [160, 160, 160]);
}
#[test]
fn quicktime_cinepak_decoder_applies_flagged_codebook_updates() {
let mut decoder = PpcQuickTimeCinepakDecoder::new(4, 4).unwrap();
decoder
.decode_sample(&test_cinepak_v1_frame_sample())
.unwrap();
decoder
.decode_sample(&test_cinepak_flagged_v1_update_sample())
.unwrap();
let frame = decoder.decoded_frame();
assert_eq!(ppc_test_rgb_at(&frame, 0, 0), [255, 255, 255]);
assert_eq!(ppc_test_rgb_at(&frame, 2, 0), [0, 0, 0]);
assert_eq!(ppc_test_rgb_at(&frame, 0, 2), [0, 0, 0]);
assert_eq!(ppc_test_rgb_at(&frame, 3, 3), [255, 255, 255]);
}
#[test]
fn quicktime_cinepak_decoder_preserves_skipped_interframe_blocks() {
let mut decoder = PpcQuickTimeCinepakDecoder::new(4, 4).unwrap();
decoder
.decode_sample(&test_cinepak_v1_frame_sample())
.unwrap();
let before = decoder.decoded_frame().rgb;
decoder
.decode_sample(&test_cinepak_skip_frame_sample())
.unwrap();
let after = decoder.decoded_frame().rgb;
assert_eq!(before, after);
}
#[test]
fn quicktime_movie_video_decode_cache_advances_without_redecoding_prior_samples() {
let first_sample = test_cinepak_v1_frame_sample();
let second_sample = test_cinepak_skip_frame_sample();
let second_offset = u64::try_from(first_sample.len()).unwrap();
let mut movie_file_data = first_sample.clone();
movie_file_data.extend_from_slice(&second_sample);
let mut quicktime = PpcQuickTimeState {
movie_file_data,
movie_tasks_until_done: 2,
movie_video_samples: Some(PpcQuickTimeVideoSampleTableRecord {
media_time_scale: 1,
media_duration: 2,
sample_count: 2,
codec: u32::from_be_bytes(*b"cvid"),
samples: vec![
PpcQuickTimeVideoSampleRecord {
offset: 0,
size: u32::try_from(first_sample.len()).unwrap(),
media_start_time: 0,
duration: 1,
data_len: u32::try_from(first_sample.len()).unwrap(),
checksum: 0,
preview_len: 0,
preview: [0; 16],
},
PpcQuickTimeVideoSampleRecord {
offset: second_offset,
size: u32::try_from(second_sample.len()).unwrap(),
media_start_time: 1,
duration: 1,
data_len: u32::try_from(second_sample.len()).unwrap(),
checksum: 0,
preview_len: 0,
preview: [0; 16],
},
],
}),
..PpcQuickTimeState::default()
};
let first_frame = ppc_qt_decode_current_movie_video_frame(&mut quicktime).unwrap();
assert_eq!(
quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index),
Some(0)
);
quicktime.movie_file_data[10] = 0xff;
quicktime.movie_task_count = 1;
let second_frame = ppc_qt_decode_current_movie_video_frame(&mut quicktime).unwrap();
assert_eq!(second_frame.rgb, first_frame.rgb);
assert_eq!(
quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index),
Some(1)
);
}
#[test]
fn quicktime_go_to_beginning_resets_video_decode_cache() {
let mut cpu = PpcCpu::new();
cpu.gpr[3] = PPC_QT_MOVIE;
let mut sound = PpcSoundState::default();
let mut quicktime = PpcQuickTimeState {
movie_started: true,
movie_task_count: 1,
movie_video_decode_cache: Some(PpcQuickTimeVideoDecodeCacheRecord {
codec: u32::from_be_bytes(*b"cvid"),
width: 4,
height: 4,
sample_index: 1,
rgb: vec![0; 4 * 4 * 3],
cinepak_strips: vec![
PpcQuickTimeCinepakStripState::default();
PpcQuickTimeCinepakDecoder::MAX_STRIPS
],
}),
..PpcQuickTimeState::default()
};
assert_eq!(
ppc_qt_go_to_beginning_of_movie(&mut cpu, &mut quicktime, &mut sound),
PPC_NO_ERR
);
assert!(!quicktime.movie_started);
assert_eq!(quicktime.movie_task_count, 0);
assert!(quicktime.movie_video_decode_cache.is_none());
}
fn external_ppc_fixture_archive() -> Option<std::path::PathBuf> {
let Some(path) = std::env::var_os("SYSTEMLESS_PPC_TEST_ARCHIVE") else {
eprintln!(
"[TEST] skipping external PPC archive fixture: set SYSTEMLESS_PPC_TEST_ARCHIVE"
);
return None;
};
let archive_path = std::path::PathBuf::from(path);
if !archive_path.is_file() {
eprintln!(
"[TEST] skipping external PPC archive fixture: missing {}",
archive_path.display()
);
return None;
}
Some(archive_path)
}
#[test]
fn quicktime_decodes_cinepak_movie_prefixes_from_external_archive_when_configured() {
let Some(archive_path) = external_ppc_fixture_archive() else {
return;
};
let archive_bytes = std::fs::read(&archive_path).unwrap();
let archive = stuffit::SitArchive::parse(&archive_bytes).unwrap();
for movie_path in ["Data/Movies/Win.mov", "Data/Movies/Lose.mov"] {
let entry = archive
.entries
.iter()
.find(|entry| entry.name == movie_path)
.unwrap_or_else(|| panic!("missing {movie_path} in {}", archive_path.display()));
let (movie_file_data, _) = entry.decompressed_forks().unwrap();
let video_samples = ppc_qt_movie_video_samples(&movie_file_data)
.unwrap_or_else(|| panic!("{movie_path}: missing video sample table"));
assert_eq!(video_samples.codec, u32::from_be_bytes(*b"cvid"));
assert!(video_samples.sample_count >= 4);
let mut quicktime = PpcQuickTimeState {
movie_file_data,
movie_tasks_until_done: u32::try_from(video_samples.media_duration).unwrap(),
movie_video_samples: Some(video_samples.clone()),
..PpcQuickTimeState::default()
};
for sample_index in 0..4usize {
quicktime.movie_task_count =
u32::try_from(video_samples.samples[sample_index].media_start_time).unwrap();
let frame = ppc_qt_decode_current_movie_video_frame(&mut quicktime)
.unwrap_or_else(|| panic!("{movie_path}: decode sample {sample_index}"));
assert_eq!(
frame.rgb.len(),
frame.width * frame.height * 3,
"{movie_path}: decoded RGB buffer size"
);
assert!(frame.width > 0 && frame.height > 0);
assert_eq!(
quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index),
Some(sample_index),
"{movie_path}: cache should advance to decoded sample"
);
}
}
}
#[test]
fn quicktime_draws_boot_picts_from_external_archive_when_configured() {
let Some(archive_path) = external_ppc_fixture_archive() else {
return;
};
let archive_bytes = std::fs::read(&archive_path).unwrap();
let archive = stuffit::SitArchive::parse(&archive_bytes).unwrap();
for pict_path in ["Data/Images/Boot1.PICT", "Data/Images/Boot2.PICT"] {
let entry = archive
.entries
.iter()
.find(|entry| entry.name == pict_path)
.unwrap_or_else(|| panic!("missing {pict_path} in {}", archive_path.display()));
let (pict_data, _) = entry.decompressed_forks().unwrap();
let mut memory = PpcSectionMem::new();
let base = PPC_HEAP_BASE + 0x8000;
memory.add_region(base, vec![0; 640 * 480 * 2]);
let front_buffer = PpcFrontBuffer {
base_addr: base,
row_bytes: 640 * 2,
width: 640,
height: 480,
depth: 16,
};
assert!(
ppc_qt_draw_pict_source_to_16bpp(&mut memory, front_buffer, &pict_data),
"{pict_path}: source PICT should render instead of falling back"
);
assert_ne!(
memory.read_u16_be(base),
Some(0),
"{pict_path}: first destination pixel should be populated"
);
}
}
#[test]
fn quicktime_movie_frame_draw_uses_cinepak_sample_pixels() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"StartMovie");
let mut loaded = load_pef_application(&pef).unwrap();
let gworld = 0x0600_3000;
let gdevice = 0x0600_4000;
let base = PPC_HEAP_BASE + 0x8000;
let sample_offset = 12u64;
let sample = test_cinepak_v1_frame_sample();
let mut movie_file_data = vec![0; usize::try_from(sample_offset).unwrap()];
movie_file_data.extend_from_slice(&sample);
loaded.memory.add_region(base, vec![0xee; 4 * 4 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: gworld,
pixmap_handle: 0,
pixmap: 0,
base_addr: base,
gdevice,
width: 4,
height: 4,
depth: 16,
row_bytes: 8,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded.quicktime = PpcQuickTimeState {
movie_file_data,
movie_box: (0, 0, 4, 4),
movie_tasks_until_done: 1,
movie_video_samples: Some(PpcQuickTimeVideoSampleTableRecord {
media_time_scale: 1,
media_duration: 1,
sample_count: 1,
codec: u32::from_be_bytes(*b"cvid"),
samples: vec![PpcQuickTimeVideoSampleRecord {
offset: sample_offset,
size: u32::try_from(sample.len()).unwrap(),
media_start_time: 0,
duration: 1,
data_len: u32::try_from(sample.len()).unwrap(),
checksum: sample.iter().copied().map(u32::from).sum(),
preview_len: 0,
preview: [0; 16],
}],
}),
..PpcQuickTimeState::default()
};
assert!(ppc_qt_draw_movie_frame(
&mut loaded.memory,
&loaded.gworlds,
gworld,
&mut loaded.quicktime,
0x21,
));
assert_eq!(loaded.memory.read_u16_be(base), Some(0x0000));
assert_eq!(
loaded.memory.read_u16_be(base + 4),
Some(ppc_qt_rgb555_from_u8(85, 85, 85))
);
assert_eq!(
loaded.memory.read_u16_be(base + 16),
Some(ppc_qt_rgb555_from_u8(170, 170, 170))
);
assert_eq!(loaded.memory.read_u16_be(base + 30), Some(0x7fff));
}
#[test]
fn quicktime_movie_audio_decoder_iterates_sample_table_chunks() {
fn push_u16(bytes: &mut Vec<u8>, value: u16) {
bytes.extend_from_slice(&value.to_be_bytes());
}
fn push_u32(bytes: &mut Vec<u8>, value: u32) {
bytes.extend_from_slice(&value.to_be_bytes());
}
let mut mdhd_payload = vec![0; 24];
mdhd_payload[12..16].copy_from_slice(&22_050u32.to_be_bytes());
mdhd_payload[16..20].copy_from_slice(&4u32.to_be_bytes());
let mut hdlr_payload = vec![0; 24];
hdlr_payload[4..8].copy_from_slice(b"mhlr");
hdlr_payload[8..12].copy_from_slice(b"soun");
let mut stsd_payload = Vec::new();
push_u32(&mut stsd_payload, 0);
push_u32(&mut stsd_payload, 1);
push_u32(&mut stsd_payload, 36);
stsd_payload.extend_from_slice(b"raw ");
push_u32(&mut stsd_payload, 0);
push_u16(&mut stsd_payload, 0);
push_u16(&mut stsd_payload, 1);
push_u16(&mut stsd_payload, 0);
push_u16(&mut stsd_payload, 0);
push_u32(&mut stsd_payload, 0);
push_u16(&mut stsd_payload, 1);
push_u16(&mut stsd_payload, 8);
push_u16(&mut stsd_payload, 0);
push_u16(&mut stsd_payload, 0);
push_u32(&mut stsd_payload, 22_050u32 << 16);
let mut stts_payload = Vec::new();
push_u32(&mut stts_payload, 0);
push_u32(&mut stts_payload, 1);
push_u32(&mut stts_payload, 4);
push_u32(&mut stts_payload, 1);
let mut stsc_payload = Vec::new();
push_u32(&mut stsc_payload, 0);
push_u32(&mut stsc_payload, 1);
push_u32(&mut stsc_payload, 1);
push_u32(&mut stsc_payload, 2);
push_u32(&mut stsc_payload, 1);
let mut stsz_payload = Vec::new();
push_u32(&mut stsz_payload, 0);
push_u32(&mut stsz_payload, 1);
push_u32(&mut stsz_payload, 4);
let mut stco_payload = Vec::new();
push_u32(&mut stco_payload, 0);
push_u32(&mut stco_payload, 2);
push_u32(&mut stco_payload, 8);
push_u32(&mut stco_payload, 10);
let mut stbl_payload = Vec::new();
push_quicktime_atom(&mut stbl_payload, b"stsd", &stsd_payload);
push_quicktime_atom(&mut stbl_payload, b"stts", &stts_payload);
push_quicktime_atom(&mut stbl_payload, b"stsc", &stsc_payload);
push_quicktime_atom(&mut stbl_payload, b"stsz", &stsz_payload);
push_quicktime_atom(&mut stbl_payload, b"stco", &stco_payload);
let mut minf_payload = Vec::new();
push_quicktime_atom(&mut minf_payload, b"stbl", &stbl_payload);
let mut mdia_payload = Vec::new();
push_quicktime_atom(&mut mdia_payload, b"mdhd", &mdhd_payload);
push_quicktime_atom(&mut mdia_payload, b"hdlr", &hdlr_payload);
push_quicktime_atom(&mut mdia_payload, b"minf", &minf_payload);
let mut trak_payload = Vec::new();
push_quicktime_atom(&mut trak_payload, b"mdia", &mdia_payload);
let mut moov_payload = Vec::new();
push_quicktime_atom(&mut moov_payload, b"trak", &trak_payload);
let mut movie_file_data = Vec::new();
push_quicktime_atom(&mut movie_file_data, b"mdat", &[0x80, 0x90, 0x70, 0x60]);
push_quicktime_atom(&mut movie_file_data, b"moov", &moov_payload);
let decoded = ppc_qt_decode_movie_audio_samples(&PpcQuickTimeState {
movie_file_data,
movie_audio_track: Some(PpcQuickTimeAudioTrackRecord {
media_time_scale: 22_050,
media_duration: 4,
sample_count: 4,
first_sample_duration: 1,
first_sample_size: 1,
first_chunk_offset: 8,
first_sample_data_len: 1,
first_sample_checksum: 0,
first_sample_preview_len: 0,
first_sample_preview: [0; 16],
first_samples_per_chunk: 2,
sample_description_id: 1,
codec: u32::from_be_bytes(*b"raw "),
channel_count: 1,
sample_size_bits: 8,
sample_rate_fixed: 22_050u32 << 16,
}),
..PpcQuickTimeState::default()
})
.expect("all audio chunks decode");
assert_eq!(decoded.samples, vec![0x80, 0x90, 0x70, 0x60]);
}
#[test]
fn quicktime_movie_audio_decoder_decodes_ima4_first_chunk() {
let mut movie_file_data = vec![0; 12];
movie_file_data.extend_from_slice(&[0x40, 0x00]);
movie_file_data.extend_from_slice(&[0; 32]);
let decoded = ppc_qt_decode_movie_audio_samples(&PpcQuickTimeState {
movie_file_data,
movie_audio_track: Some(PpcQuickTimeAudioTrackRecord {
media_time_scale: 44_100,
media_duration: 64,
sample_count: 64,
first_sample_duration: 1,
first_sample_size: 1,
first_chunk_offset: 12,
first_sample_data_len: 1,
first_sample_checksum: 0,
first_sample_preview_len: 0,
first_sample_preview: [0; 16],
first_samples_per_chunk: 64,
sample_description_id: 1,
codec: u32::from_be_bytes(*b"ima4"),
channel_count: 1,
sample_size_bits: 16,
sample_rate_fixed: 44_100u32 << 16,
}),
..PpcQuickTimeState::default()
})
.expect("IMA4 movie chunk decodes");
assert_eq!(decoded.samples, vec![0xc0; 64]);
assert_eq!(
decoded.summary,
PpcDecodedAiffSamples {
sample_rate_fixed: 44_100u32 << 16,
sample_count: 64,
preview_len: 16,
preview: [0xc0; 16],
}
);
}
#[test]
fn quicktime_start_movie_audio_hands_off_ima4_to_sound_state() {
let mut movie_file_data = vec![0; 12];
movie_file_data.extend_from_slice(&[0x00, 0x00]);
movie_file_data.extend_from_slice(&[0; 32]);
let quicktime = PpcQuickTimeState {
movie_file_ref_num: PPC_FIRST_FILE_REF_NUM,
movie_file_data,
movie_audio_track: Some(PpcQuickTimeAudioTrackRecord {
media_time_scale: 44_100,
media_duration: 64,
sample_count: 64,
first_sample_duration: 1,
first_sample_size: 1,
first_chunk_offset: 12,
first_sample_data_len: 1,
first_sample_checksum: 0,
first_sample_preview_len: 0,
first_sample_preview: [0; 16],
first_samples_per_chunk: 64,
sample_description_id: 1,
codec: u32::from_be_bytes(*b"ima4"),
channel_count: 1,
sample_size_bits: 16,
sample_rate_fixed: 44_100u32 << 16,
}),
..PpcQuickTimeState::default()
};
let mut sound = PpcSoundState::default();
assert!(ppc_qt_start_movie_audio(&quicktime, &mut sound));
assert_eq!(sound.file_playbacks.len(), 1);
assert_eq!(
sound.file_playbacks[0].decoded_aiff,
Some(PpcDecodedAiffSamples {
sample_rate_fixed: 44_100u32 << 16,
sample_count: 64,
preview_len: 16,
preview: [0x80; 16],
})
);
assert_eq!(
sound.decoded_file_playbacks,
vec![PpcDecodedAiffPlaybackRecord {
file_playback_index: 0,
channel: PPC_QT_MOVIE,
sample_rate_fixed: 44_100u32 << 16,
samples: vec![0x80; 64],
}]
);
}
#[test]
fn hle_import_runner_handles_quicktime_importer_and_movie_outputs() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"GetGraphicsImporterForFile");
let mut loaded = load_pef_application(&pef).unwrap();
let importer_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(importer_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = PPC_DATA_BASE;
loaded.cpu.gpr[4] = importer_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(importer_out_ptr),
Some(PPC_QT_GRAPHICS_IMPORTER)
);
assert!(loaded.quicktime.graphics_importer_open);
let pef =
synthetic_pef_with_library_import(b"QuickTimeLib", b"GraphicsImportGetBoundsRect");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 8]);
loaded.quicktime.graphics_importer_open = true;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
loaded.cpu.gpr[4] = bounds_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
ppc_read_rect(&mut loaded.memory, bounds_ptr),
Some((
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16
))
);
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"OpenMovieFile");
let mut loaded = load_pef_application(&pef).unwrap();
let ref_num_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(ref_num_out_ptr, vec![0; 2]);
loaded.cpu.gpr[3] = PPC_DATA_BASE;
loaded.cpu.gpr[4] = ref_num_out_ptr;
loaded.cpu.gpr[5] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u16_be(ref_num_out_ptr),
Some(PPC_FIRST_FILE_REF_NUM as u16)
);
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"NewMovieFromFile");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let movie_out_ptr = scratch;
let res_id_ptr = scratch + 4;
let data_ref_changed_ptr = scratch + 6;
loaded.memory.add_region(scratch, vec![0xaa; 16]);
loaded.cpu.gpr[3] = movie_out_ptr;
loaded.cpu.gpr[4] = PPC_FIRST_FILE_REF_NUM as u16 as u32;
loaded.cpu.gpr[5] = res_id_ptr;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = data_ref_changed_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(movie_out_ptr), Some(PPC_QT_MOVIE));
assert_eq!(loaded.memory.read_u16_be(res_id_ptr), Some(0));
assert_eq!(loaded.memory.read_u8(data_ref_changed_ptr), Some(0));
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"GetMovieBox");
let mut loaded = load_pef_application(&pef).unwrap();
let box_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(box_ptr, vec![0; 8]);
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
loaded.cpu.gpr[4] = box_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_QT_MOVIE);
assert_eq!(
ppc_read_rect(&mut loaded.memory, box_ptr),
Some((
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16
))
);
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"IsMovieDone");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
}
#[test]
fn hle_import_runner_quicktime_new_movie_from_file_quiets_previous_movie_audio() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"NewMovieFromFile");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let movie_out_ptr = scratch;
let res_id_ptr = scratch + 4;
let data_ref_changed_ptr = scratch + 6;
loaded.memory.add_region(scratch, vec![0xaa; 16]);
loaded.quicktime.movie_started = true;
loaded.quicktime.movie_task_count = 9;
loaded
.sound
.file_playbacks
.push(test_sound_file_playback(PPC_QT_MOVIE));
loaded
.sound
.file_playbacks
.push(test_sound_file_playback(0x1234_5678));
loaded.sound.manager.play_file_buffer(
PPC_QT_MOVIE,
vec![0x80],
crate::sound::OUTPUT_RATE << 16,
None,
);
loaded.sound.manager.play_file_buffer(
0x1234_5678,
vec![0x80],
crate::sound::OUTPUT_RATE << 16,
None,
);
loaded.cpu.gpr[3] = movie_out_ptr;
loaded.cpu.gpr[4] = PPC_FIRST_FILE_REF_NUM as u16 as u32;
loaded.cpu.gpr[5] = res_id_ptr;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = data_ref_changed_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(movie_out_ptr), Some(PPC_QT_MOVIE));
assert_eq!(loaded.memory.read_u16_be(res_id_ptr), Some(0));
assert_eq!(loaded.memory.read_u8(data_ref_changed_ptr), Some(0));
assert!(!loaded.quicktime.movie_started);
assert_eq!(loaded.quicktime.movie_task_count, 0);
assert!(loaded.quicktime.movie_at_beginning);
assert_eq!(
loaded.sound.file_playbacks[0],
test_sound_file_playback(PPC_QT_MOVIE)
);
assert_eq!(
loaded.sound.file_playbacks[1],
test_sound_file_playback(0x1234_5678)
);
assert_eq!(
loaded.sound.manager.file_playback_paused(PPC_QT_MOVIE),
None
);
assert_eq!(
loaded.sound.manager.file_playback_paused(0x1234_5678),
Some(false)
);
}
#[test]
fn hle_import_runner_prevalidates_quicktime_output_buffers() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"GetGraphicsImporterForFile");
let mut loaded = load_pef_application(&pef).unwrap();
let importer_out_ptr = PPC_DATA_BASE + 0x1000;
let bounds_ptr = PPC_DATA_BASE + 0x1100;
let ref_num_out_ptr = PPC_DATA_BASE + 0x1200;
let movie_out_ptr = PPC_DATA_BASE + 0x1300;
let res_id_ptr = PPC_DATA_BASE + 0x1400;
let data_ref_changed_ptr = PPC_DATA_BASE + 0x1500;
let box_ptr = PPC_DATA_BASE + 0x1600;
loaded.memory.add_region(importer_out_ptr, vec![0xd1; 3]);
loaded.memory.add_region(bounds_ptr, vec![0xd2; 7]);
loaded.memory.add_region(ref_num_out_ptr, vec![0xd3; 1]);
loaded.memory.add_region(movie_out_ptr, vec![0xd4; 4]);
loaded.memory.add_region(res_id_ptr, vec![0xd5; 1]);
loaded
.memory
.add_region(data_ref_changed_ptr, vec![0xd6; 1]);
loaded.memory.add_region(box_ptr, vec![0xd7; 7]);
loaded.quicktime.graphics_importer_path = "Previous PICT".to_string();
loaded.quicktime.graphics_importer_data = b"previous".to_vec();
loaded.quicktime.graphics_importer_bounds = Some((1, 2, 3, 4));
loaded.quicktime.graphics_importer_open = true;
let previous_video_track = PpcQuickTimeVideoTrackRecord {
media_time_scale: 30,
media_duration: 90,
sample_count: 3,
first_sample_duration: 30,
first_sample_size: 12,
first_chunk_offset: 0x44,
first_sample_data_len: 0,
first_sample_checksum: 0,
first_sample_preview_len: 0,
first_sample_preview: [0; 16],
first_samples_per_chunk: 3,
sample_description_id: 1,
codec: u32::from_be_bytes(*b"jpeg"),
};
let previous_video_samples = PpcQuickTimeVideoSampleTableRecord {
media_time_scale: 30,
media_duration: 90,
sample_count: 1,
codec: u32::from_be_bytes(*b"jpeg"),
samples: vec![PpcQuickTimeVideoSampleRecord {
offset: 0x44,
size: 12,
media_start_time: 0,
duration: 90,
data_len: 0,
checksum: 0,
preview_len: 0,
preview: [0; 16],
}],
};
let previous_audio_track = PpcQuickTimeAudioTrackRecord {
media_time_scale: 11_025,
media_duration: 2205,
sample_count: 2205,
first_sample_duration: 1,
first_sample_size: 1,
first_chunk_offset: 0x88,
first_sample_data_len: 0,
first_sample_checksum: 0,
first_sample_preview_len: 0,
first_sample_preview: [0; 16],
first_samples_per_chunk: 2205,
sample_description_id: 1,
codec: u32::from_be_bytes(*b"twos"),
channel_count: 1,
sample_size_bits: 8,
sample_rate_fixed: 11_025u32 << 16,
};
loaded.quicktime.movie_file_path = "Previous.mov".to_string();
loaded.quicktime.movie_file_data = b"previous movie".to_vec();
loaded.quicktime.movie_file_bounds = Some((5, 6, 7, 8));
loaded.quicktime.movie_file_time_scale = 30;
loaded.quicktime.movie_file_duration = 90;
loaded.quicktime.movie_file_tasks_until_done = 180;
loaded.quicktime.movie_file_video_track = Some(previous_video_track);
loaded.quicktime.movie_file_video_samples = Some(previous_video_samples.clone());
loaded.quicktime.movie_file_audio_track = Some(previous_audio_track);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = importer_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
for offset in 0..3 {
assert_eq!(loaded.memory.read_u8(importer_out_ptr + offset), Some(0xd1));
}
assert_eq!(loaded.quicktime.graphics_importer_path, "Previous PICT");
assert_eq!(loaded.quicktime.graphics_importer_data, b"previous");
assert_eq!(
loaded.quicktime.graphics_importer_bounds,
Some((1, 2, 3, 4))
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::QtGraphicsImportGetBoundsRect;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
loaded.cpu.gpr[4] = bounds_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
for offset in 0..7 {
assert_eq!(loaded.memory.read_u8(bounds_ptr + offset), Some(0xd2));
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtOpenMovieFile;
loaded.cpu.gpr[3] = PPC_DATA_BASE;
loaded.cpu.gpr[4] = ref_num_out_ptr;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.memory.read_u8(ref_num_out_ptr), Some(0xd3));
assert_eq!(loaded.quicktime.movie_file_open_count, 0);
assert_eq!(loaded.quicktime.movie_file_ref_num, 0);
assert_eq!(loaded.quicktime.movie_file_path, "Previous.mov");
assert_eq!(loaded.quicktime.movie_file_data, b"previous movie");
assert_eq!(loaded.quicktime.movie_file_bounds, Some((5, 6, 7, 8)));
assert_eq!(loaded.quicktime.movie_file_time_scale, 30);
assert_eq!(loaded.quicktime.movie_file_duration, 90);
assert_eq!(loaded.quicktime.movie_file_tasks_until_done, 180);
assert_eq!(
loaded.quicktime.movie_file_video_track,
Some(previous_video_track)
);
assert_eq!(
loaded.quicktime.movie_file_video_samples,
Some(previous_video_samples.clone())
);
assert_eq!(
loaded.quicktime.movie_file_audio_track,
Some(previous_audio_track)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtNewMovieFromFile;
loaded.quicktime.movie_started = true;
loaded.quicktime.movie_task_count = 7;
loaded.quicktime.movie_disposed = true;
loaded.quicktime.movie_at_beginning = false;
loaded.quicktime.movie_tasks_until_done = 42;
loaded.quicktime.movie_video_track = Some(previous_video_track);
loaded.quicktime.movie_video_samples = Some(previous_video_samples.clone());
loaded.quicktime.movie_audio_track = Some(previous_audio_track);
loaded
.sound
.file_playbacks
.push(test_sound_file_playback(PPC_QT_MOVIE));
loaded.cpu.gpr[3] = movie_out_ptr;
loaded.cpu.gpr[4] = PPC_FIRST_FILE_REF_NUM as u16 as u32;
loaded.cpu.gpr[5] = res_id_ptr;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = data_ref_changed_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.memory.read_u32_be(movie_out_ptr), Some(0xd4d4_d4d4));
assert_eq!(loaded.memory.read_u8(res_id_ptr), Some(0xd5));
assert_eq!(loaded.memory.read_u8(data_ref_changed_ptr), Some(0xd6));
assert!(loaded.quicktime.movie_started);
assert_eq!(loaded.quicktime.movie_task_count, 7);
assert!(loaded.quicktime.movie_disposed);
assert!(!loaded.quicktime.movie_at_beginning);
assert_eq!(loaded.quicktime.movie_tasks_until_done, 42);
assert_eq!(
loaded.quicktime.movie_video_track,
Some(previous_video_track)
);
assert_eq!(
loaded.quicktime.movie_video_samples,
Some(previous_video_samples)
);
assert_eq!(
loaded.quicktime.movie_audio_track,
Some(previous_audio_track)
);
assert_eq!(
loaded.sound.file_playbacks[0],
test_sound_file_playback(PPC_QT_MOVIE)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGetMovieBox;
loaded.quicktime.movie_disposed = false;
loaded.quicktime.movie_box = (10, 20, 30, 40);
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
loaded.cpu.gpr[4] = box_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_QT_MOVIE);
for offset in 0..7 {
assert_eq!(loaded.memory.read_u8(box_ptr + offset), Some(0xd7));
}
assert_eq!(loaded.quicktime.movie_box, (10, 20, 30, 40));
assert_eq!(loaded.quicktime.movie_error, PPC_PARAM_ERR);
}
#[test]
fn hle_import_runner_tracks_quicktime_gworld_targets_and_visible_draws() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"GraphicsImportSetGWorld");
let mut loaded = load_pef_application(&pef).unwrap();
let gworld = 0x0600_1000;
let gdevice = 0x0600_2000;
let base = PPC_HEAP_BASE + 0x6000;
loaded.memory.add_region(base, vec![0; 4 * 3 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: gworld,
pixmap_handle: 0,
pixmap: 0,
base_addr: base,
gdevice,
width: 4,
height: 3,
depth: 16,
row_bytes: 8,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded.quicktime.graphics_importer_open = true;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
loaded.cpu.gpr[4] = gworld;
loaded.cpu.gpr[5] = gdevice;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.quicktime.graphics_importer_gworld, gworld);
assert_eq!(loaded.quicktime.graphics_importer_gdevice, gdevice);
assert_eq!(loaded.memory.read_u16_be(base), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGraphicsImportDraw;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.quicktime.graphics_import_draw_count, 1);
assert_ne!(loaded.memory.read_u16_be(base), Some(0));
assert_ne!(loaded.memory.read_u16_be(base + 4 * 3 * 2 - 2), Some(0));
let _ = loaded.memory.write_u16_be(base, 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtSetMovieGWorld;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
loaded.cpu.gpr[4] = gworld;
loaded.cpu.gpr[5] = gdevice;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.quicktime.movie_gworld, gworld);
assert_eq!(loaded.quicktime.movie_gdevice, gdevice);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtStartMovie;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(loaded.quicktime.movie_started);
assert_ne!(loaded.memory.read_u16_be(base), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtIsMovieDone;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.quicktime.movie_error, PPC_NO_ERR);
loaded
.sound
.file_playbacks
.push(test_sound_file_playback(PPC_QT_MOVIE));
loaded.sound.manager.play_file_buffer(
PPC_QT_MOVIE,
vec![0x80],
crate::sound::OUTPUT_RATE << 16,
None,
);
assert_eq!(
loaded.sound.manager.toggle_file_paused(PPC_QT_MOVIE),
Some(true)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtMoviesTask;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.quicktime.movie_task_count, 1);
assert!(loaded.quicktime.movie_started);
assert_eq!(
loaded.sound.manager.file_playback_paused(PPC_QT_MOVIE),
Some(true)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtIsMovieDone;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
for expected_count in 2..=PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE {
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtMoviesTask;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.quicktime.movie_task_count, expected_count);
}
assert!(!loaded.quicktime.movie_started);
assert_eq!(
loaded.sound.manager.file_playback_paused(PPC_QT_MOVIE),
None
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtIsMovieDone;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtStopMovie;
loaded.cpu.gpr[3] = PPC_QT_MOVIE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(!loaded.quicktime.movie_started);
}
#[test]
fn hle_import_runner_close_component_closes_quicktime_importer() {
let pef = synthetic_pef_with_import(b"CloseComponent");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0xcc; 8]);
loaded.quicktime.graphics_importer_open = true;
loaded.quicktime.graphics_importer_gworld = 0x0600_1000;
loaded.quicktime.graphics_importer_gdevice = 0x0600_2000;
loaded.quicktime.graphics_importer_path = "Splash Pict".to_string();
loaded.quicktime.graphics_importer_data = b"pict".to_vec();
loaded.quicktime.graphics_importer_bounds = Some((1, 2, 3, 4));
loaded.quicktime.graphics_import_draw_count = 7;
loaded.quicktime.graphics_import_source_draw_count = 3;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(!loaded.quicktime.graphics_importer_open);
assert_eq!(loaded.quicktime.graphics_importer_gworld, 0);
assert_eq!(loaded.quicktime.graphics_importer_gdevice, 0);
assert!(loaded.quicktime.graphics_importer_path.is_empty());
assert!(loaded.quicktime.graphics_importer_data.is_empty());
assert_eq!(loaded.quicktime.graphics_importer_bounds, None);
assert_eq!(loaded.quicktime.graphics_import_draw_count, 7);
assert_eq!(loaded.quicktime.graphics_import_source_draw_count, 3);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::QtGraphicsImportGetBoundsRect;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
loaded.cpu.gpr[4] = bounds_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
for offset in 0..8 {
assert_eq!(loaded.memory.read_u8(bounds_ptr + offset), Some(0xcc));
}
}
#[test]
fn hle_import_runner_close_component_rejects_unknown_instances() {
let pef = synthetic_pef_with_import(b"CloseComponent");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.quicktime.graphics_importer_open = true;
loaded.quicktime.graphics_importer_path = "Still Open".to_string();
loaded.cpu.gpr[3] = 0x0bad_cafe;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_INVALID_COMPONENT_ID));
assert!(loaded.quicktime.graphics_importer_open);
assert_eq!(loaded.quicktime.graphics_importer_path, "Still Open");
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(!loaded.quicktime.graphics_importer_open);
}
#[test]
fn hle_import_runner_draws_quicktime_pict_file_into_gworld() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"GetGraphicsImporterForFile");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let importer_out_ptr = scratch + 80;
let bounds_ptr = scratch + 96;
let gworld = 0x0600_3000;
let gdevice = 0x0600_4000;
let base = PPC_HEAP_BASE + 0x7000;
loaded.memory.add_region(scratch, vec![0; 128]);
loaded.memory.add_region(base, vec![0xff; 8 * 2]);
loaded.gworlds = vec![PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: gworld,
pixmap_handle: 0,
pixmap: 0,
base_addr: base,
gdevice,
width: 8,
height: 1,
depth: 16,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
}];
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: "Splash Pict".to_string(),
data: (test_v1_one_bit_packbits_pict()).into(),
creator: 0,
file_type: u32::from_be_bytes(*b"PICT"),
finder_flags: 0,
dirty: false,
});
write_ppc_fsspec(
&mut loaded.memory,
scratch,
PPC_BOOT_VOLUME_REF_NUM,
PPC_ROOT_DIR_ID,
b"Splash Pict",
);
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = importer_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(importer_out_ptr),
Some(PPC_QT_GRAPHICS_IMPORTER)
);
assert_eq!(loaded.quicktime.graphics_importer_path, "Splash Pict");
assert_eq!(
loaded.quicktime.graphics_importer_bounds,
Some((0, 0, 1, 8))
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::QtGraphicsImportGetBoundsRect;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
loaded.cpu.gpr[4] = bounds_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
ppc_read_rect(&mut loaded.memory, bounds_ptr),
Some((0, 0, 1, 8))
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGraphicsImportSetGWorld;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
loaded.cpu.gpr[4] = gworld;
loaded.cpu.gpr[5] = gdevice;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::QtGraphicsImportDraw;
loaded.cpu.gpr[3] = PPC_QT_GRAPHICS_IMPORTER;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.quicktime.graphics_import_draw_count, 1);
assert_eq!(loaded.quicktime.graphics_import_source_draw_count, 1);
let pixels: Vec<u16> = (0..8)
.map(|x| loaded.memory.read_u16_be(base + x * 2).unwrap())
.collect();
assert_eq!(
pixels,
vec![0x0000, 0x7fff, 0x0000, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]
);
}
#[test]
fn hle_import_runner_quicktime_importer_resolves_unique_archive_suffix_path() {
let pef = synthetic_pef_with_library_import(b"QuickTimeLib", b"GetGraphicsImporterForFile");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let importer_out_ptr = scratch + 80;
let images_dir_id = PPC_FIRST_DYNAMIC_DIR_ID;
let mut directories = initial_ppc_vfs_directories();
directories.push(PpcVfsDirectory {
dir_id: images_dir_id,
parent_dir_id: PPC_ROOT_DIR_ID,
path: "Images".to_string(),
creator: PPC_DIRECTORY_CREATOR,
file_type: PPC_DIRECTORY_FILE_TYPE,
finder_flags: 0,
dirty: false,
});
loaded.seed_vfs_directories(directories, PPC_ROOT_DIR_ID, images_dir_id + 1);
loaded.memory.add_region(scratch, vec![0; 128]);
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: "Data/Images/Boot1.PICT".to_string(),
data: (test_v1_one_bit_packbits_pict()).into(),
creator: 0,
file_type: u32::from_be_bytes(*b"PICT"),
finder_flags: 0,
dirty: false,
});
write_ppc_fsspec(
&mut loaded.memory,
scratch,
PPC_BOOT_VOLUME_REF_NUM,
images_dir_id,
b"Boot1.pict",
);
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = importer_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(importer_out_ptr),
Some(PPC_QT_GRAPHICS_IMPORTER)
);
assert_eq!(
loaded.quicktime.graphics_importer_path,
"Data/Images/Boot1.PICT"
);
assert_eq!(
loaded.quicktime.graphics_importer_bounds,
Some((0, 0, 1, 8))
);
}
#[test]
fn hle_import_runner_handles_mathlib_ceil_in_fpr1() {
let pef = synthetic_pef_with_library_import(b"MathLib", b"ceil");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0xfeed_face;
loaded.cpu.fpr[1] = (-300.1f64).to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xfeed_face);
assert_eq!(f64::from_bits(loaded.cpu.fpr[1]), -300.0);
}
#[test]
fn mathlib_pi_tvector_import_binds_to_addressable_double_data() {
let pef = synthetic_pef_with_library_import(b"MathLib", b"pi");
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(loaded.imports[0].class, 2);
assert_eq!(loaded.imports[0].address, PPC_IMPORT_MATH_PI);
assert_eq!(loaded.imports[0].tvector_address, None);
assert_eq!(
loaded.memory.read_u64_be(PPC_IMPORT_MATH_PI),
Some(std::f64::consts::PI.to_bits())
);
}
#[test]
fn mathlib_default_environment_data_import_binds_to_zeroed_fenv() {
let pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
b"MathLib",
b"_FE_DFL_ENV",
1,
&[sm_index_reloc(0x30, 0)],
));
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(loaded.imports[0].class, 1);
assert_eq!(loaded.imports[0].address, PPC_IMPORT_MATH_FE_DFL_ENV);
assert_eq!(loaded.imports[0].tvector_address, None);
assert_ne!(PPC_IMPORT_MATH_FE_DFL_ENV, PPC_IMPORT_MATH_PI);
assert_eq!(
loaded.memory.read_u32_be(PPC_IMPORT_MATH_FE_DFL_ENV),
Some(0)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_DATA_BASE),
Some(PPC_IMPORT_MATH_FE_DFL_ENV)
);
}
#[test]
fn stdclib_floating_point_data_imports_bind_to_ieee_constants() {
let double_constants = [
(
b"_DBL_EPSILON".as_slice(),
PPC_IMPORT_STD_DBL_EPSILON,
f64::EPSILON.to_bits(),
),
(
b"_DBL_MAX".as_slice(),
PPC_IMPORT_STD_DBL_MAX,
f64::MAX.to_bits(),
),
(
b"_DBL_MIN".as_slice(),
PPC_IMPORT_STD_DBL_MIN,
f64::MIN_POSITIVE.to_bits(),
),
];
for (symbol, expected_address, expected_bits) in double_constants {
let pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
b"StdCLib",
symbol,
1,
&[sm_index_reloc(0x30, 0)],
));
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(loaded.imports[0].class, 1);
assert_eq!(loaded.imports[0].address, expected_address);
assert_eq!(loaded.imports[0].tvector_address, None);
assert_eq!(expected_address % 8, 0);
assert_eq!(
loaded.memory.read_u64_be(expected_address),
Some(expected_bits)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_DATA_BASE),
Some(expected_address)
);
}
let float_constants = [
(
b"_FLT_EPSILON".as_slice(),
PPC_IMPORT_STD_FLT_EPSILON,
f32::EPSILON.to_bits(),
),
(
b"_FLT_MAX".as_slice(),
PPC_IMPORT_STD_FLT_MAX,
f32::MAX.to_bits(),
),
(
b"_FLT_MIN".as_slice(),
PPC_IMPORT_STD_FLT_MIN,
f32::MIN_POSITIVE.to_bits(),
),
];
for (symbol, expected_address, expected_bits) in float_constants {
let pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
b"StdCLib",
symbol,
1,
&[sm_index_reloc(0x30, 0)],
));
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(loaded.imports[0].class, 1);
assert_eq!(loaded.imports[0].address, expected_address);
assert_eq!(loaded.imports[0].tvector_address, None);
assert_eq!(expected_address % 4, 0);
assert_eq!(
loaded.memory.read_u32_be(expected_address),
Some(expected_bits)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_DATA_BASE),
Some(expected_address)
);
}
let occupied = [
PPC_IMPORT_MATH_PI,
PPC_IMPORT_MATH_FE_DFL_ENV,
PPC_IMPORT_STD_DBL_EPSILON,
PPC_IMPORT_STD_DBL_MAX,
PPC_IMPORT_STD_DBL_MIN,
PPC_IMPORT_STD_FLT_EPSILON,
PPC_IMPORT_STD_FLT_MAX,
PPC_IMPORT_STD_FLT_MIN,
PPC_IMPORT_STD_ERRNO,
PPC_IMPORT_STD_MAC_OS_ERR,
];
assert!(occupied.windows(2).all(|pair| pair[0] < pair[1]));
assert!(PPC_IMPORT_STD_MAC_OS_ERR + 2 <= PPC_IMPORT_CTYPE_TABLE);
}
#[test]
fn stdclib_error_globals_are_writable_process_scoped_data() {
let errno_pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
b"StdCLib",
b"errno",
1,
&[sm_index_reloc(0x30, 0)],
));
let mut first = load_pef_application(&errno_pef).unwrap();
assert_eq!(first.imports[0].class, 1);
assert_eq!(first.imports[0].address, PPC_IMPORT_STD_ERRNO);
assert_eq!(first.imports[0].tvector_address, None);
assert_eq!(first.memory.read_u32_be(PPC_IMPORT_STD_ERRNO), Some(0));
assert_eq!(
first.memory.read_u32_be(PPC_DATA_BASE),
Some(PPC_IMPORT_STD_ERRNO)
);
assert!(first
.memory
.write_u32_be(PPC_IMPORT_STD_ERRNO, 34)
.is_some());
assert_eq!(first.memory.read_u32_be(PPC_IMPORT_STD_ERRNO), Some(34));
let mut second = load_pef_application(&errno_pef).unwrap();
assert_eq!(second.memory.read_u32_be(PPC_IMPORT_STD_ERRNO), Some(0));
let mac_os_err_pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
b"StdCLib",
b"MacOSErr",
1,
&[sm_index_reloc(0x30, 0)],
));
let mut loaded = load_pef_application(&mac_os_err_pef).unwrap();
assert_eq!(loaded.imports[0].class, 1);
assert_eq!(loaded.imports[0].address, PPC_IMPORT_STD_MAC_OS_ERR);
assert_eq!(loaded.imports[0].tvector_address, None);
assert_eq!(
loaded.memory.read_u16_be(PPC_IMPORT_STD_MAC_OS_ERR),
Some(0)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_DATA_BASE),
Some(PPC_IMPORT_STD_MAC_OS_ERR)
);
assert!(loaded
.memory
.write_u16_be(PPC_IMPORT_STD_MAC_OS_ERR, 0xffce)
.is_some());
assert_eq!(
loaded.memory.read_u16_be(PPC_IMPORT_STD_MAC_OS_ERR),
Some(0xffce)
);
}
#[test]
fn native_ppc_math_ceil_preserves_special_values_and_reports_signaling_nan() {
let mut cpu = PpcCpu::new();
cpu.fpscr = 3;
for input in [-0.0f64, f64::INFINITY, f64::NEG_INFINITY] {
cpu.fpr[1] = input.to_bits();
ppc_math_ceil(&mut cpu);
assert_eq!(cpu.fpr[1], input.to_bits());
assert_eq!(cpu.fpscr, 3);
}
let quiet_nan = 0x7ff8_0000_0000_0042;
cpu.fpr[1] = quiet_nan;
ppc_math_ceil(&mut cpu);
assert_eq!(cpu.fpr[1], quiet_nan);
assert_eq!(cpu.fpscr, 3);
let signaling_nan = 0xfff0_0000_0000_0042;
cpu.fpr[1] = signaling_nan;
cpu.set_fpscr_bit(24, true);
ppc_math_ceil(&mut cpu);
assert_eq!(cpu.fpr[1], signaling_nan | 0x0008_0000_0000_0000);
for bit in [0, 1, 2, 7, 24] {
assert!(cpu.fpscr_bit(bit));
}
}
#[test]
fn hle_import_runner_handles_mathlib_sqrt_in_fpr1() {
let pef = synthetic_pef_with_library_import(b"MathLib", b"sqrt");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0xfeed_face;
loaded.cpu.fpr[1] = 9.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xfeed_face);
assert_eq!(f64::from_bits(loaded.cpu.fpr[1]), 3.0);
}
#[test]
fn hle_import_runner_handles_mathlib_atan2_in_fprs() {
let pef = synthetic_pef_with_library_import(b"MathLib", b"atan2");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.fpr[1] = 1.0f64.to_bits();
loaded.cpu.fpr[2] = 1.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let result = f64::from_bits(loaded.cpu.fpr[1]);
assert!((result - std::f64::consts::FRAC_PI_4).abs() < 1e-12);
}
#[test]
fn hle_import_runner_handles_mathlib_fmod_in_fprs() {
let pef = synthetic_pef_with_library_import(b"MathLib", b"fmod");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0xfeed_face;
loaded.cpu.fpr[1] = (-5.5f64).to_bits();
loaded.cpu.fpr[2] = 2.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xfeed_face);
assert_eq!(f64::from_bits(loaded.cpu.fpr[1]), -1.5);
loaded.cpu.fpr[1] = (-0.0f64).to_bits();
loaded.cpu.fpr[2] = 3.0f64.to_bits();
ppc_math_fmod(&mut loaded.cpu);
assert_eq!(loaded.cpu.fpr[1], (-0.0f64).to_bits());
}
#[test]
fn hle_import_runner_handles_mathlib_atan_in_fpr1() {
let pef = synthetic_pef_with_library_import(b"MathLib", b"atan");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.fpr[1] = 1.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let result = f64::from_bits(loaded.cpu.fpr[1]);
assert!((result - std::f64::consts::FRAC_PI_4).abs() < 1e-12);
}
#[test]
fn hle_import_runner_handles_mathlib_log10_in_fpr1() {
let pef = synthetic_pef_with_library_import(b"MathLib", b"log10");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0xfeed_face;
loaded.cpu.fpr[1] = 1000.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xfeed_face);
assert_eq!(f64::from_bits(loaded.cpu.fpr[1]), 3.0);
}
#[test]
fn hle_import_runner_handles_mathlib_exp_in_fpr1() {
let pef = synthetic_pef_with_library_import(b"MathLib", b"exp");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0xfeed_face;
loaded.cpu.fpr[1] = 1.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xfeed_face);
let result = f64::from_bits(loaded.cpu.fpr[1]);
assert!((result - std::f64::consts::E).abs() < 1e-12);
}
#[test]
fn hle_import_runner_handles_mathlib_dtox80() {
let pef = synthetic_pef_with_library_import(b"MathLib", b"dtox80");
let mut loaded = load_pef_application(&pef).unwrap();
let input = PPC_HEAP_BASE + 0x100;
let output = PPC_HEAP_BASE + 0x108;
let bits = (-1.5f64).to_bits();
loaded.memory.write_u32_be(input, (bits >> 32) as u32);
loaded.memory.write_u32_be(input + 4, bits as u32);
loaded.cpu.gpr[3] = input;
loaded.cpu.gpr[4] = output;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(output), Some(0xbfff));
assert_eq!(loaded.memory.read_u32_be(output + 2), Some(0xc000_0000));
assert_eq!(loaded.memory.read_u32_be(output + 6), Some(0));
}
#[test]
fn hle_import_runner_handles_x2fix_in_fpr1() {
let pef = synthetic_pef_with_import(b"X2Fix");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.fpr[1] = 1.75f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x0001_c000);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.fpr[1] = 40000.0f64.to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x7fff_ffff);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.fpr[1] = (-40000.0f64).to_bits();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x8000_0000);
}
#[test]
fn hle_import_runner_handles_get_picture_as_valid_handle() {
let pef = synthetic_pef_with_import(b"GetPicture");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 128;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let handle = loaded.cpu.gpr[3];
assert_ne!(handle, 0);
assert_eq!(test_handle_records!(loaded).len(), 1);
assert_eq!(test_handle_records!(loaded)[0].handle, handle);
assert_eq!(
test_handle_records!(loaded)[0].size,
minimal_pict_bytes().len() as u32
);
let ptr = loaded.memory.read_u32_be(handle).unwrap();
assert_eq!(ptr, test_handle_records!(loaded)[0].ptr);
assert_eq!(loaded.memory.read_u16_be(ptr), Some(0x000c));
assert_eq!(loaded.memory.read_u16_be(ptr + 10), Some(0x00ff));
assert_eq!(loaded.test_resource_error(), PPC_RES_NOT_FOUND_ERR);
}
#[test]
fn hle_import_runner_get_picture_prefers_loaded_pict_resource() {
let pef = synthetic_pef_with_import(b"GetPicture");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_current_resource_refnum(42);
let pict = test_v1_one_bit_packbits_pict();
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: 42,
path: "Data/Images".to_string(),
res_type: u32::from_be_bytes(*b"PICT"),
res_id: 128,
name: b"Title".to_vec(),
data: pict.clone(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 128;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let handle = loaded.cpu.gpr[3];
assert_ne!(handle, 0);
assert_eq!(loaded.process_file_system.vfs_resources[0].handle, handle);
let ptr = loaded.memory.read_u32_be(handle).unwrap();
for (offset, byte) in pict.iter().copied().enumerate() {
assert_eq!(loaded.memory.read_u8(ptr + offset as u32), Some(byte));
}
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
}
#[test]
fn hle_import_runner_get_pix_pat_returns_fresh_resource_copies() {
let pef = synthetic_pef_with_import(b"GetPixPat");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_current_resource_refnum(42);
let pattern = vec![
0x00, 0x01, // patType
0x00, 0x00, 0x00, 0x1c, // patMap offset
0x00, 0x00, 0x00, 0x4e, // patData offset
0x00, 0x00, 0x00, 0x00, // patXData
0xff, 0xff, // patXValid
0x00, 0x00, 0x00, 0x00, // patXMap
0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, // pat1Data
];
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: 42,
path: "Escape Velocity".to_string(),
res_type: u32::from_be_bytes(*b"ppat"),
res_id: 129,
name: b"Dialog Pattern".to_vec(),
data: pattern.clone(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 129;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let first_handle = loaded.cpu.gpr[3];
assert_ne!(first_handle, 0);
assert_eq!(loaded.process_file_system.vfs_resources[0].handle, 0);
assert_eq!(
ppc_handle_bytes(
&mut loaded.memory,
&test_handle_records!(loaded),
first_handle
),
Some(pattern.clone())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 129;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let second_handle = loaded.cpu.gpr[3];
assert_ne!(second_handle, 0);
assert_ne!(second_handle, first_handle);
assert_eq!(
ppc_handle_bytes(
&mut loaded.memory,
&test_handle_records!(loaded),
second_handle
),
Some(pattern)
);
}
#[test]
fn hle_import_runner_draws_picture_handle_into_current_gworld() {
let pef = synthetic_pef_with_import(b"DrawPicture");
let mut loaded = load_pef_application(&pef).unwrap();
let pict = test_v1_one_bit_packbits_pict();
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&pict,
);
assert_ne!(handle, 0);
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 5, 6, 6, 14).unwrap();
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let red = ppc_rgb_color_to_rgb555(PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
});
let red_index = u16::from(ppc_rgb555_to_clut_index(red, &loaded.screen_clut));
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
front,
(6, 5),
red_index,
));
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
front,
(7, 5),
red_index,
));
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
front,
(20, 5),
red_index,
));
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (6, 5)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(PPC_RGB_BLACK)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (7, 5)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(PPC_RGB_WHITE)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (20, 5)),
Some(red_index)
);
}
#[test]
fn hle_import_runner_draws_picture_handle_into_8bpp_current_gworld() {
let pef = synthetic_pef_with_import(b"DrawPicture");
let mut loaded = load_pef_application(&pef).unwrap();
let pict = test_v1_one_bit_packbits_pict();
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&pict,
);
assert_ne!(handle, 0);
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 5, 6, 6, 14).unwrap();
let gworld = PPC_HEAP_BASE + 0x1000;
let pix_base = PPC_HEAP_BASE + 0x2000;
loaded.memory.add_region(pix_base, vec![42; 8 * 8]);
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: gworld,
pixmap_handle: 0,
pixmap: 0,
base_addr: pix_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 8,
row_bytes: 8,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = gworld);
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(pix_base + 5 * 8 + 6), Some(255));
assert_eq!(loaded.memory.read_u8(pix_base + 5 * 8 + 7), Some(0));
assert_eq!(loaded.memory.read_u8(pix_base + 5 * 8), Some(42));
}
#[test]
fn hle_import_runner_draws_picture_handle_into_4bpp_current_gworld() {
let pef = synthetic_pef_with_import(b"DrawPicture");
let mut loaded = load_pef_application(&pef).unwrap();
let pict = test_v1_one_bit_packbits_pict();
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&pict,
);
assert_ne!(handle, 0);
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 5, 0, 6, 8).unwrap();
let gworld = PPC_HEAP_BASE + 0x1000;
let pix_base = PPC_HEAP_BASE + 0x2000;
loaded.memory.add_region(pix_base, vec![0; 4 * 8]);
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: gworld,
pixmap_handle: 0,
pixmap: 0,
base_addr: pix_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 4,
row_bytes: 4,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = gworld);
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
// The source row alternates black/white for its first four pixels;
// black is index 11 in the standard 4-bpp GWorld table. Packed output
// must update both nibbles instead of reporting a successful parse
// while leaving the destination bytes untouched.
assert_eq!(loaded.memory.read_u8(pix_base + 5 * 4), Some(0xb0));
assert_eq!(loaded.memory.read_u8(pix_base + 5 * 4 + 1), Some(0xb0));
assert_eq!(loaded.memory.read_u8(pix_base + 4 * 4), Some(0));
assert_eq!(loaded.memory.read_u8(pix_base + 6 * 4), Some(0));
}
#[test]
fn basic_grafport_uses_port_rect_when_copied_bitmap_bounds_exceed_row_bytes() {
let pef = synthetic_pef_with_import(b"DrawPicture");
let mut loaded = load_pef_application(&pef).unwrap();
let port = PPC_HEAP_BASE + 0x1000;
let pixels = PPC_HEAP_BASE + 0x2000;
loaded.memory.add_region(port, vec![0xff; 0x80]);
loaded.memory.add_region(pixels, vec![0; 8]);
loaded.memory.write_u32_be(port + 2, pixels).unwrap();
loaded.memory.write_u16_be(port + 6, 1).unwrap();
ppc_write_rect(&mut loaded.memory, port + 8, 0, 0, 480, 640).unwrap();
ppc_write_rect(&mut loaded.memory, port + 16, 0, 0, 8, 8).unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle: 0,
pixmap: 0,
base_addr: pixels,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 1,
row_bytes: 1,
pixels_locked: false,
pixels_no_purge: false,
});
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, port).unwrap();
assert_eq!(surface.front_buffer.base_addr, pixels);
assert_eq!(surface.front_buffer.row_bytes, 1);
assert_eq!(surface.front_buffer.width, 8);
assert_eq!(surface.front_buffer.height, 8);
assert_eq!(surface.front_buffer.depth, 1);
}
#[test]
fn picture_renderer_draws_into_packed_one_bit_bitmap() {
let pef = synthetic_pef_with_import(b"DrawPicture");
let mut loaded = load_pef_application(&pef).unwrap();
let pixels = PPC_HEAP_BASE + 0x2000;
loaded.memory.add_region(pixels, vec![0x55; 8]);
let front = PpcFrontBuffer {
base_addr: pixels,
row_bytes: 1,
width: 8,
height: 8,
depth: 1,
};
// Only entries 0 and 1 are representable. Black deliberately has an
// exact match at the even index 42 in the inherited logical tail; an
// unclamped 256-entry match would truncate that to bit 0 and invert
// the source's black pixels.
let mut one_bit_clut = [[0xffff; 3]; 256];
one_bit_clut[1] = [0x1111, 0x1111, 0x1111];
one_bit_clut[42] = [0, 0, 0];
assert!(ppc_draw_pict_bytes_to_16bpp(
&mut loaded.memory,
front,
&test_v1_one_bit_packbits_pict(),
(5, 0, 6, 8),
&one_bit_clut,
0,
false,
));
assert_eq!(loaded.memory.read_u8(pixels + 5), Some(0b1010_0000));
assert_eq!(loaded.memory.read_u8(pixels + 4), Some(0x55));
assert_eq!(loaded.memory.read_u8(pixels + 6), Some(0x55));
}
#[test]
fn hle_import_runner_draws_raw_quilt_picture_frame_into_8bpp_current_gworld() {
let pef = synthetic_pef_with_import(b"DrawPicture");
let mut loaded = load_pef_application(&pef).unwrap();
let mut pict = Vec::new();
pict.extend_from_slice(&56u16.to_be_bytes());
pict.extend_from_slice(&[0, 0, 0, 0, 0, 2, 0, 3]);
pict.extend_from_slice(&[0; 14]);
let mut raw = vec![0u8; 32];
raw[0] = 11;
raw[1] = 12;
raw[2] = 13;
raw[16] = 21;
raw[17] = 0;
raw[18] = 23;
pict.extend_from_slice(&raw);
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&pict,
);
assert_ne!(handle, 0);
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 1, 2, 3, 5).unwrap();
let gworld = PPC_HEAP_BASE + 0x1000;
let pix_base = PPC_HEAP_BASE + 0x2000;
loaded.memory.add_region(pix_base, vec![42; 8 * 8]);
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: gworld,
pixmap_handle: 0,
pixmap: 0,
base_addr: pix_base,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 8,
depth: 8,
row_bytes: 8,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = gworld);
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(pix_base + 8 + 2), Some(11));
assert_eq!(loaded.memory.read_u8(pix_base + 8 + 3), Some(12));
assert_eq!(loaded.memory.read_u8(pix_base + 8 + 4), Some(13));
assert_eq!(loaded.memory.read_u8(pix_base + 16 + 2), Some(21));
assert_eq!(loaded.memory.read_u8(pix_base + 16 + 3), Some(0));
assert_eq!(loaded.memory.read_u8(pix_base + 16 + 4), Some(23));
assert_eq!(loaded.memory.read_u8(pix_base), Some(42));
assert!(ppc_draw_pict_bytes_to_16bpp(
&mut loaded.memory,
PpcFrontBuffer {
base_addr: pix_base,
row_bytes: 8,
width: 8,
height: 8,
depth: 8,
},
&pict,
(1, 2, 3, 5),
&loaded.screen_clut,
0,
true,
));
assert_eq!(
loaded.memory.read_u8(pix_base + 16 + 3),
Some(pict::closest_clut_index(0, 0, 0, &loaded.screen_clut))
);
}
#[test]
fn quilt_img_compositing_mode_controls_whether_zero_is_opaque() {
let picture_handle = PPC_HEAP_BASE + 0x1000;
let mut img = vec![0; 18];
img[10..12].copy_from_slice(&3u16.to_be_bytes());
let mut resources = vec![
PpcVfsResourceRecord {
ref_num: 128,
path: "Sprites/Robot.PICR".to_string(),
res_type: u32::from_be_bytes(*b"PICT"),
res_id: 1000,
name: Vec::new(),
data: Vec::new(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: picture_handle,
},
PpcVfsResourceRecord {
ref_num: 128,
path: "Sprites/Robot.PICR".to_string(),
res_type: u32::from_be_bytes(*b"#Img"),
res_id: 1000,
name: Vec::new(),
data: img,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
];
assert!(ppc_quilt_picture_zero_is_opaque(&resources, picture_handle));
resources[1].data[10..12].copy_from_slice(&2u16.to_be_bytes());
assert!(!ppc_quilt_picture_zero_is_opaque(
&resources,
picture_handle
));
}
#[test]
fn hle_import_runner_kill_picture_invalidates_tracked_handle() {
let pef = synthetic_pef_with_import(b"KillPicture");
let mut loaded = load_pef_application(&pef).unwrap();
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&minimal_pict_bytes(),
);
assert_ne!(handle, 0);
assert_eq!(test_handle_records!(loaded).len(), 1);
loaded.cpu.gpr[3] = handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(test_handle_records!(loaded).is_empty());
assert_eq!(loaded.memory.read_u32_be(handle), Some(0));
}
#[test]
fn hle_import_runner_handles_get_pict_info_zero_fill() {
let pef = synthetic_pef_with_import(b"GetPictInfo");
let mut loaded = load_pef_application(&pef).unwrap();
let pict_info_ptr = PPC_HEAP_BASE;
loaded
.memory
.add_region(pict_info_ptr, vec![0xaa; PPC_PICT_INFO_SIZE as usize]);
loaded.cpu.gpr[3] = PPC_HEAP_BASE + PPC_PICT_INFO_SIZE;
loaded.cpu.gpr[4] = pict_info_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3] as u16 as i16, PPC_NO_ERR);
for offset in 0..PPC_PICT_INFO_SIZE {
assert_eq!(loaded.memory.read_u8(pict_info_ptr + offset), Some(0));
}
}
#[test]
fn hle_import_runner_get_pict_info_output_is_all_or_nothing() {
let pef = synthetic_pef_with_import(b"GetPictInfo");
let mut loaded = load_pef_application(&pef).unwrap();
let pict_info_ptr = 0x06ff_0000;
loaded.memory.add_region(pict_info_ptr, vec![0xbb; 4]);
loaded.cpu.gpr[3] = PPC_HEAP_BASE + PPC_PICT_INFO_SIZE;
loaded.cpu.gpr[4] = pict_info_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3] as u16 as i16, PPC_PARAM_ERR);
for offset in 0..4 {
assert_eq!(loaded.memory.read_u8(pict_info_ptr + offset), Some(0xbb));
}
}
#[test]
fn hle_import_runner_handles_get_gworld_outputs() {
let pef = synthetic_pef_with_import(b"GetGWorld");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_HEAP_BASE;
loaded.memory.add_region(scratch, vec![0; 16]);
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = scratch + 4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], scratch);
assert_eq!(loaded.memory.read_u32_be(scratch), Some(PPC_MAIN_GWORLD));
assert_eq!(
loaded.memory.read_u32_be(scratch + 4),
Some(PPC_MAIN_GDEVICE)
);
let pef = synthetic_pef_with_import(b"GetPort");
let mut loaded = load_pef_application(&pef).unwrap();
let port_ptr = PPC_HEAP_BASE;
loaded.memory.add_region(port_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = port_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(port_ptr), Some(PPC_MAIN_GWORLD));
let pef = synthetic_pef_with_import(b"GetWMgrPort");
let mut loaded = load_pef_application(&pef).unwrap();
let port_ptr = PPC_HEAP_BASE;
loaded.memory.add_region(port_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = port_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(port_ptr), Some(PPC_MAIN_GWORLD));
}
#[test]
fn hle_import_runner_handles_set_gworld_state() {
let pef = synthetic_pef_with_import(b"SetGWorld");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.memory
.write_u16_be(PPC_HEAP_BASE + PPC_CGRAF_PORT_PN_LOC_OFFSET, 23)
.unwrap();
loaded
.memory
.write_u16_be(PPC_HEAP_BASE + PPC_CGRAF_PORT_PN_LOC_OFFSET + 2, 17)
.unwrap();
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
loaded.cpu.gpr[4] = PPC_HEAP_BASE + 4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE);
assert_eq!(*loaded.current_gworld, PPC_HEAP_BASE);
assert_eq!(*loaded.current_gdevice, PPC_HEAP_BASE + 4);
assert_eq!(loaded.quickdraw_pen_h, 17);
assert_eq!(loaded.quickdraw_pen_v, 23);
}
#[test]
fn hle_import_runner_handles_new_cwindow_allocation() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let bounds_ptr = scratch;
loaded.memory.add_region(scratch, vec![0; 32]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 20, 10, 260, 330).unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 8, b"Document");
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0x1234_5678;
let gworld_count = loaded.gworlds.len();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let window = loaded.cpu.gpr[3];
assert_ne!(window, 0);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(*loaded.current_gworld, window);
assert_eq!(*loaded.current_gdevice, PPC_MAIN_GDEVICE);
assert_eq!(loaded.gworlds.len(), gworld_count + 1);
let record = loaded
.gworlds
.iter()
.find(|record| record.port == window)
.unwrap();
assert_eq!(record.width, 320);
assert_eq!(record.height, 240);
assert_eq!(record.depth, PPC_MAIN_PIXEL_DEPTH);
assert_eq!(record.base_addr, PPC_MAIN_SCREEN_BASE);
assert_eq!(record.row_bytes, ppc_main_screen_row_bytes());
assert_eq!(
loaded.memory.read_u32_be(PPC_MAIN_PIXMAP + 42),
Some(PPC_MAIN_CTABLE_HANDLE)
);
assert_eq!(
loaded.memory.read_u32_be(record.pixmap + 42),
Some(PPC_MAIN_CTABLE_HANDLE)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_MAIN_CTABLE_HANDLE),
Some(PPC_MAIN_CTABLE)
);
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_CTABLE + 4), Some(0x8000));
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_CTABLE + 6), Some(255));
assert_eq!(
loaded.memory.read_u32_be(window + 2),
Some(record.pixmap_handle)
);
assert_eq!(loaded.memory.read_u16_be(window + 6), Some(0xc000));
assert_eq!(
loaded
.memory
.read_u16_be(window + PPC_CWINDOW_WINDOW_KIND_OFFSET),
Some(8)
);
assert_eq!(
loaded.memory.read_u8(window + PPC_CWINDOW_VISIBLE_OFFSET),
Some(1)
);
assert_eq!(
loaded.memory.read_u8(window + PPC_CWINDOW_GO_AWAY_OFFSET),
Some(1)
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, record.pixmap + 6),
Some((-20, -10, 580, 790))
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, window + 16),
Some((0, 0, 240, 320))
);
let vis_rgn = loaded
.memory
.read_u32_be(window + PPC_CGRAF_PORT_VIS_RGN_OFFSET)
.unwrap();
let clip_rgn = loaded
.memory
.read_u32_be(window + PPC_CGRAF_PORT_CLIP_RGN_OFFSET)
.unwrap();
let update_rgn = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_UPDATE_RGN_OFFSET)
.unwrap();
let structure_rgn = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_STRUCTURE_RGN_OFFSET)
.unwrap();
let content_rgn = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_CONTENT_RGN_OFFSET)
.unwrap();
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, vis_rgn),
Some((0, 0, 240, 320))
);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, clip_rgn),
Some((i16::MIN, i16::MIN, i16::MAX, i16::MAX))
);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, update_rgn),
Some((0, 0, 0, 0))
);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, structure_rgn),
Some((1, 9, 262, 332))
);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, content_rgn),
Some((20, 10, 260, 330))
);
let def_proc_handle = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_DEF_PROC_OFFSET)
.unwrap();
let def_proc = loaded.memory.read_u32_be(def_proc_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(def_proc), Some(0));
let title_handle = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_TITLE_HANDLE_OFFSET)
.unwrap();
let title = loaded.memory.read_u32_be(title_handle).unwrap();
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, title),
Some(b"Document".to_vec())
);
assert_ne!(
loaded
.memory
.read_u32_be(window + PPC_CWINDOW_STATE_HANDLE_OFFSET),
Some(0)
);
assert_eq!(loaded.memory.read_u32_be(window + 152), Some(0x1234_5678));
assert_eq!(
loaded.current_front_buffer(),
Some(PpcFrontBuffer {
base_addr: record.base_addr,
row_bytes: record.row_bytes,
width: record.width,
height: record.height,
depth: record.depth,
})
);
}
#[test]
fn native_toolbox_theme_changes_chrome_without_changing_guest_geometry() {
for depth in [1, 8, 16] {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
loaded.set_ui_theme(UiThemeId::SystemlessDefault);
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let mut palette = if depth == 1 {
UiThemeId::ClassicSystem7
} else {
UiThemeId::SystemlessDefault
}
.provider()
.palette();
if depth == 1 {
palette.desktop_dark = Rgb8 { r: 0, g: 0, b: 0 };
palette.desktop_light = Rgb8 {
r: 255,
g: 255,
b: 255,
};
}
for (point, color) in [
((700, 400), palette.desktop_dark),
((701, 400), palette.desktop_light),
] {
let expected =
ppc_physical_screen_color_pixel(front, ppc_theme_rgb(color), &loaded.screen_clut)
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, point),
Some(expected)
);
}
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 32]);
let window = create_test_cwindow(
&mut loaded,
bounds_ptr,
(100, 100, 260, 300),
0,
true,
u32::MAX,
);
let content = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_CONTENT_RGN_OFFSET)
.unwrap();
let geometry = ppc_read_rgn_bbox(&mut loaded.memory, content);
let expected = ppc_physical_screen_color_pixel(
front,
ppc_theme_rgb(palette.frame_light),
&loaded.screen_clut,
)
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (150, 84)),
Some(expected)
);
assert_eq!(geometry, Some((100, 100, 260, 300)));
ppc_standard_file_draw_button(
&mut loaded.memory,
front,
&loaded.gworlds,
(0, 0, 600, 800),
(320, 100, 340, 180),
b"Open",
true,
);
let expected_button = ppc_physical_screen_color_pixel(
front,
ppc_theme_rgb(palette.frame_light),
&loaded.screen_clut,
)
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (160, 325)),
Some(expected_button)
);
let marker =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
ppc_quickdraw_write_raw_pixel(&mut loaded.memory, front, (150, 150), marker);
loaded.set_ui_theme(UiThemeId::ClassicSystem7);
ppc_draw_existing_window_frame(
&mut loaded.memory,
&loaded.gworlds,
&loaded.window_list,
window,
false,
);
assert_eq!(ppc_read_rgn_bbox(&mut loaded.memory, content), geometry);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (150, 150)),
Some(marker)
);
}
}
#[test]
fn copy_bits_does_not_overwrite_a_front_window() {
// ClipAbove removes every front structure region before the Window
// Manager asks a rear WDEF to draw. Macintosh Toolbox Essentials
// (1992), pp. 4-106 and 4-118--4-119.
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 32]);
let back = create_test_cwindow(
&mut loaded,
bounds_ptr,
(100, 100, 260, 300),
0,
true,
u32::MAX,
);
let _front = create_test_cwindow(
&mut loaded,
bounds_ptr,
(120, 250, 280, 450),
0,
true,
u32::MAX,
);
let front_buffer =
ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let bitmap = PPC_DATA_BASE + 0x2000;
let pixels = bitmap + 64;
loaded.memory.add_region(bitmap, vec![0; 128]);
loaded.memory.write_u32_be(bitmap, pixels).unwrap();
loaded.memory.write_u16_be(bitmap + 4, 8).unwrap();
ppc_write_rect(&mut loaded.memory, bitmap + 6, 0, 0, 8, 64).unwrap();
ppc_write_rect(&mut loaded.memory, bitmap + 20, 0, 0, 8, 64).unwrap();
ppc_write_rect(&mut loaded.memory, bitmap + 28, 50, 100, 58, 183).unwrap();
loaded.cpu.gpr[3] = back;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetPort);
for point in [(275, 150), (210, 150)] {
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory, front_buffer, point, 0x7b,
));
}
loaded.cpu.gpr[3] = bitmap;
loaded.cpu.gpr[4] = back + 2;
loaded.cpu.gpr[5] = bitmap + 20;
loaded.cpu.gpr[6] = bitmap + 28;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::CopyBits);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front_buffer, (275, 150)),
Some(0x7b),
"CopyBits painted a back window through the front window"
);
assert_ne!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front_buffer, (210, 150)),
Some(0x7b),
"CopyBits must still update the unobscured back window"
);
}
#[test]
fn ppc_direct_chrome_redraw_does_not_paint_back_window_through_front_content() {
// ClipAbove removes every front structure region before the Window
// Manager asks a rear WDEF to draw. Macintosh Toolbox Essentials
// (1992), pp. 4-106 and 4-118--4-119.
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 32]);
let back = create_test_cwindow(
&mut loaded,
bounds_ptr,
(100, 100, 260, 300),
0,
true,
u32::MAX,
);
let _front = create_test_cwindow(
&mut loaded,
bounds_ptr,
(120, 250, 280, 450),
0,
true,
u32::MAX,
);
let front_buffer =
ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let protected = (300, 150);
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
front_buffer,
protected,
0x7b,
));
ppc_draw_existing_window_frame(
&mut loaded.memory,
&loaded.gworlds,
&loaded.window_list,
back,
false,
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front_buffer, protected),
Some(0x7b),
"back-window chrome must be clipped by the front window's content",
);
}
#[test]
fn hle_import_runner_new_cwindow_draws_document_frame_at_supported_depths() {
for depth in [1, 2, 4, 8, 16] {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(framebuffer_len).unwrap())
.map(|index| (index as u8).wrapping_mul(37).wrapping_add(depth as u8) ^ 0xa9)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
let outside = (98, 81);
let outside_before =
ppc_quickdraw_read_pixel(&mut loaded.memory, front, outside).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 32]);
ppc_write_rect(&mut loaded.memory, scratch, 100, 100, 200, 300).unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 8, b"Document");
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::NewCWindow;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
let window = loaded.cpu.gpr[3];
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, window).unwrap();
let black =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK)
.unwrap();
let white =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_WHITE)
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point((-1, -18)),),
Some(black),
"{depth}bpp document top frame did not draw",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point((30, -18)),),
Some(white),
"{depth}bpp title bar did not draw",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point((30, -17)),),
Some(black),
"{depth}bpp active title stripes did not draw",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point((8, -15)),),
Some(black),
"{depth}bpp close box did not draw",
);
let title_ink = (-12..-4)
.flat_map(|v| (100..200).map(move |h| (h, v)))
.filter(|&point| {
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point(point))
== Some(black)
})
.count();
assert!(title_ink > 0, "{depth}bpp title text did not draw");
assert_eq!(
loaded.memory.read_u8(window + PPC_CWINDOW_HILITED_OFFSET),
Some(1),
"{depth}bpp front window was not activated",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, outside),
Some(outside_before),
"{depth}bpp frame changed a pixel outside the structure region",
);
let frame_before_title =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 20, b"X");
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = scratch + 20;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::LegacyWindow(PpcLegacyWindowOperation::SetWindowTitle),
);
let frame_after_title =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
assert_ne!(
frame_after_title, frame_before_title,
"{depth}bpp SetWTitle did not redraw visible chrome",
);
let title_handle = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_TITLE_HANDLE_OFFSET)
.unwrap();
let title_ptr = loaded.memory.read_u32_be(title_handle).unwrap();
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, title_ptr),
Some(b"X".to_vec()),
);
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = 0;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::LegacyWindow(PpcLegacyWindowOperation::HighlightWindow),
);
assert_eq!(
loaded.memory.read_u8(window + PPC_CWINDOW_HILITED_OFFSET),
Some(0),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point((30, -17)),),
Some(white),
"{depth}bpp inactive title retained stripes",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point((8, -15)),),
Some(white),
"{depth}bpp inactive title retained its close box",
);
loaded.cpu.gpr[4] = 1;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::LegacyWindow(PpcLegacyWindowOperation::HighlightWindow),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point((30, -17)),),
Some(black),
"{depth}bpp reactivated title did not restore stripes",
);
loaded.cpu.gpr[3] = window;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HideWindow);
let hidden_frame =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 20, b"Hidden");
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = scratch + 20;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::LegacyWindow(PpcLegacyWindowOperation::SetWindowTitle),
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(hidden_frame.clone()),
"{depth}bpp SetWTitle repainted a hidden window",
);
loaded.cpu.gpr[3] = window;
run_test_import(&mut loaded, PpcImportDispatcherTarget::ShowWindow);
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(hidden_frame),
"{depth}bpp ShowWindow did not paint the deferred title",
);
ppc_write_rect(&mut loaded.memory, scratch, 250, 350, 350, 550).unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 8, b"Second");
loaded.imports[0].symbol_name = "NewCWindow".to_string();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
let second = loaded.cpu.gpr[3];
let second_surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, second).unwrap();
assert_eq!(
loaded.memory.read_u8(window + PPC_CWINDOW_HILITED_OFFSET),
Some(0),
"{depth}bpp previous front window stayed active",
);
assert_eq!(
loaded.memory.read_u8(second + PPC_CWINDOW_HILITED_OFFSET),
Some(1),
"{depth}bpp new front window was not activated",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point((30, -17)),),
Some(white),
"{depth}bpp previous title was not visibly deactivated",
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
second_surface.local_point((30, -17)),
),
Some(black),
"{depth}bpp new title was not visibly activated",
);
loaded.cpu.gpr[3] = window;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SelectWindow);
assert_eq!(
loaded.memory.read_u8(window + PPC_CWINDOW_HILITED_OFFSET),
Some(1),
);
assert_eq!(
loaded.memory.read_u8(second + PPC_CWINDOW_HILITED_OFFSET),
Some(0),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, surface.local_point((30, -17)),),
Some(black),
"{depth}bpp selected title was not visibly activated",
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
second_surface.local_point((30, -17)),
),
Some(white),
"{depth}bpp prior title was not visibly deactivated by SelectWindow",
);
}
}
#[test]
fn hle_import_runner_kiosk_suppresses_document_chrome_but_keeps_dialog_frames() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = 8;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
loaded.toolbox_startup.host_menu_bar_hidden = true;
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(framebuffer_len).unwrap())
.map(|index| (index as u8).wrapping_mul(37).wrapping_add(8) ^ 0xa9)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 32]);
ppc_write_rect(&mut loaded.memory, scratch, 100, 100, 200, 300).unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 8, b"Game Window");
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
let document_frame_point = (82, 99);
let document_frame_before =
ppc_quickdraw_read_pixel(&mut loaded.memory, front, document_frame_point);
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
let document = loaded.cpu.gpr[3];
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, document_frame_point),
document_frame_before,
);
assert_eq!(
loaded.memory.read_u8(document + PPC_CWINDOW_HILITED_OFFSET),
Some(1),
);
ppc_write_rect(&mut loaded.memory, scratch, 300, 300, 400, 500).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 1;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 0;
loaded.cpu.gpr[10] = 0;
let dialog_frame_point = (299, 300);
let dialog_frame_before =
ppc_quickdraw_read_pixel(&mut loaded.memory, front, dialog_frame_point);
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
assert_ne!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, dialog_frame_point),
dialog_frame_before,
);
}
#[test]
fn ppc_paint_behind_hidden_menu_uses_classic_desktop_pattern() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.toolbox_startup.host_menu_bar_hidden = true;
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
ppc_write_rgn_bbox(
&mut loaded.memory,
PPC_GRAY_RGN_HANDLE,
0,
0,
40,
40,
)
.unwrap();
let mut heap_cursor = loaded.heap_cursor();
let heap_limit = loaded.heap_limit();
let mut last_mem_error = loaded.last_mem_error();
let mut handles = Vec::new();
ppc_paint_behind(
None,
&mut loaded.memory,
&loaded.gworlds,
0,
PPC_GRAY_RGN_HANDLE,
true,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
);
let black = ppc_physical_screen_color_pixel(
front,
ppc_standard_desktop_color(&loaded.gworlds, 0, 0),
&loaded.screen_clut,
)
.unwrap();
let white = ppc_physical_screen_color_pixel(
front,
ppc_standard_desktop_color(&loaded.gworlds, 1, 0),
&loaded.screen_clut,
)
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (0, 0)),
Some(black),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (1, 0)),
Some(white),
"host menu suppression must not turn PaintBehind's desktop solid black",
);
}
#[test]
fn ppc_window_removal_exposure_uses_pattern_when_host_hides_menu_bar() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let mut event_queue = VecDeque::new();
ppc_restore_window_removal_exposure(
&mut loaded.memory,
&loaded.gworlds,
&loaded.window_list,
Some((0, 0, 2, 2)),
true,
&mut event_queue,
0,
PpcInputSnapshot::default(),
);
let black = ppc_physical_screen_color_pixel(
front,
ppc_standard_desktop_color(&loaded.gworlds, 0, 0),
&loaded.screen_clut,
)
.unwrap();
let white = ppc_physical_screen_color_pixel(
front,
ppc_standard_desktop_color(&loaded.gworlds, 1, 0),
&loaded.screen_clut,
)
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (0, 0)),
Some(black),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (1, 0)),
Some(white),
"moving or closing a window must restore GrayRgn even when its menu bar is hidden",
);
}
#[test]
fn hle_import_runner_track_go_away_retains_restores_and_uses_release_point() {
for depth in [1, 2, 4, 8, 16] {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 32]);
ppc_write_rect(&mut loaded.memory, scratch, 100, 100, 200, 300).unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 8, b"Document");
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
let window = loaded.cpu.gpr[3];
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let baseline =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::TrackGoAway,
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = (90u32 << 16) | 108;
let original_sp = loaded.cpu.gpr[1];
let original_start = loaded.cpu.gpr[4];
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 90,
mouse_h: 108,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.cpu.pc, loaded.import_trap_base);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(loaded.cpu.gpr[3], window);
assert_eq!(loaded.cpu.gpr[4], original_start);
assert!(loaded.toolbox_startup.go_away_tracking.is_some());
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(baseline.clone()),
"{depth}bpp close-box feedback did not draw",
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 120,
mouse_h: 140,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(baseline.clone()),
"{depth}bpp moving outside did not restore the close box",
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 90,
mouse_h: 108,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
loaded.event_queue.push_back(PpcQueuedEvent {
what: 2,
message: 0,
when: 0,
where_v: 90,
where_h: 108,
modifiers: 0,
});
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 90,
mouse_h: 108,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 1, "{depth}bpp inside release");
assert!(loaded.toolbox_startup.go_away_tracking.is_none());
assert!(!loaded.event_queue.iter().any(|event| event.what == 2));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(baseline.clone()),
"{depth}bpp accepted tracking did not restore pixels",
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = original_start;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 90,
mouse_h: 108,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 120,
mouse_h: 140,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0, "{depth}bpp outside release");
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(baseline.clone()),
"{depth}bpp cancelled tracking did not restore pixels",
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = (120u32 << 16) | 140;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 90,
mouse_h: 108,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0, "{depth}bpp invalid start");
assert!(loaded.toolbox_startup.go_away_tracking.is_none());
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(baseline.clone()),
"{depth}bpp invalid start changed pixels",
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = original_start;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 90,
mouse_h: 108,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert!(loaded
.memory
.write_u8(window + PPC_CWINDOW_VISIBLE_OFFSET, 0)
.is_some());
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0, "{depth}bpp hidden cancellation");
assert!(loaded.toolbox_startup.go_away_tracking.is_none());
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(baseline),
"{depth}bpp hidden cancellation did not restore pixels",
);
}
}
#[test]
fn hle_import_runner_drag_window_retains_outline_and_moves_on_valid_release() {
for depth in [1, 2, 4, 8, 16] {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 40]);
ppc_write_rect(&mut loaded.memory, scratch, 100, 100, 200, 300).unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 8, b"Document");
ppc_write_rect(&mut loaded.memory, scratch + 24, 20, 0, 480, 640).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
let window = loaded.cpu.gpr[3];
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..framebuffer_len)
.map(|index| (index as u8).wrapping_mul(37).wrapping_add(depth as u8))
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
let baseline =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::DragWindow,
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = (90u32 << 16) | 150;
loaded.cpu.gpr[5] = scratch + 24;
let original_sp = loaded.cpu.gpr[1];
let original_args = [loaded.cpu.gpr[3], loaded.cpu.gpr[4], loaded.cpu.gpr[5]];
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 90,
mouse_h: 150,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.cpu.pc, loaded.import_trap_base);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(
[loaded.cpu.gpr[3], loaded.cpu.gpr[4], loaded.cpu.gpr[5]],
original_args,
);
assert!(loaded.toolbox_startup.drag_window_tracking.is_some());
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(baseline.clone()),
"{depth}bpp initial drag outline did not draw",
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 120,
mouse_h: 180,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.drag_window_tracking
.as_ref()
.unwrap()
.outline,
(111, 129, 232, 332),
);
loaded.event_queue.push_back(PpcQueuedEvent {
what: 2,
message: 0,
when: 0,
where_v: 130,
where_h: 190,
modifiers: 0,
});
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 130,
mouse_h: 190,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert!(loaded.toolbox_startup.drag_window_tracking.is_none());
assert!(!loaded.event_queue.iter().any(|event| event.what == 2));
assert_eq!(
ppc_dialog_global_bounds(&mut loaded.memory, &loaded.gworlds, window),
Some((140, 140, 240, 340)),
"{depth}bpp valid release did not apply the final delta",
);
assert_eq!(*loaded.current_gworld, window);
let moved_frame =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
assert_ne!(
moved_frame, baseline,
"{depth}bpp accepted drag did not repaint the moved window",
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = (130u32 << 16) | 190;
loaded.cpu.gpr[5] = scratch + 24;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 150,
mouse_h: 210,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 10,
mouse_h: 10,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(
ppc_dialog_global_bounds(&mut loaded.memory, &loaded.gworlds, window),
Some((140, 140, 240, 340)),
"{depth}bpp out-of-bounds release moved the window",
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(moved_frame.clone()),
"{depth}bpp cancelled drag did not restore the framebuffer",
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = (130u32 << 16) | 190;
loaded.cpu.gpr[5] = scratch + 24;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 130,
mouse_h: 190,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert!(loaded
.memory
.write_u8(window + PPC_CWINDOW_VISIBLE_OFFSET, 0)
.is_some());
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert!(loaded.toolbox_startup.drag_window_tracking.is_none());
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(moved_frame),
"{depth}bpp hidden cancellation did not restore the framebuffer",
);
}
}
#[test]
fn hle_import_runner_grow_window_retains_clamps_and_uses_release_size() {
for depth in [1, 2, 4, 8, 16] {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 40]);
ppc_write_rect(&mut loaded.memory, scratch, 100, 100, 200, 300).unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 8, b"Document");
ppc_write_rect(&mut loaded.memory, scratch + 24, 50, 80, 180, 260).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
let window = loaded.cpu.gpr[3];
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..framebuffer_len)
.map(|index| (index as u8).wrapping_mul(29).wrapping_add(depth as u8))
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
let baseline =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::GrowWindow,
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = window;
// Retain the event point even when the live cursor has moved.
loaded.cpu.gpr[4] = (195u32 << 16) | 290;
loaded.cpu.gpr[5] = scratch + 24;
let original_sp = loaded.cpu.gpr[1];
let original_args = [loaded.cpu.gpr[3], loaded.cpu.gpr[4], loaded.cpu.gpr[5]];
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 200,
mouse_h: 300,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(
[loaded.cpu.gpr[3], loaded.cpu.gpr[4], loaded.cpu.gpr[5]],
original_args,
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 350,
mouse_h: 500,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.grow_window_tracking
.as_ref()
.unwrap()
.outline,
(81, 99, 282, 362),
"{depth}bpp held size did not clamp to maximums",
);
loaded.event_queue.push_back(PpcQueuedEvent {
what: 2,
message: 0,
when: 0,
where_v: 250,
where_h: 380,
modifiers: 0,
});
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 250,
mouse_h: 380,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], (155u32 << 16) | 260);
assert!(loaded.toolbox_startup.grow_window_tracking.is_none());
assert!(!loaded.event_queue.iter().any(|event| event.what == 2));
assert_eq!(
ppc_dialog_global_bounds(&mut loaded.memory, &loaded.gworlds, window),
Some((100, 100, 200, 300)),
"{depth}bpp GrowWindow resized instead of returning a proposal",
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(baseline.clone()),
"{depth}bpp accepted grow did not restore the framebuffer",
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = window;
// Retain the event point even when the live cursor has moved.
loaded.cpu.gpr[4] = (195u32 << 16) | 290;
loaded.cpu.gpr[5] = scratch + 24;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 220,
mouse_h: 320,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 195,
mouse_h: 290,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0, "{depth}bpp unchanged size sentinel");
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(baseline),
"{depth}bpp unchanged grow did not restore the framebuffer",
);
}
}
#[test]
fn new_cwindow_manager_regions_follow_move_and_size() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 32]);
ppc_write_rect(&mut loaded.memory, scratch, 20, 10, 260, 330).unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 8, b"Document");
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
let window = loaded.cpu.gpr[3];
let structure_rgn = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_STRUCTURE_RGN_OFFSET)
.unwrap();
let content_rgn = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_CONTENT_RGN_OFFSET)
.unwrap();
let mut move_cpu = loaded.cpu.clone();
move_cpu.gpr[3] = window;
move_cpu.gpr[4] = 30;
move_cpu.gpr[5] = 40;
assert_eq!(
ppc_move_window(&move_cpu, &mut loaded.memory, &mut loaded.gworlds),
Some(())
);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, content_rgn),
Some((40, 30, 280, 350))
);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, structure_rgn),
Some((21, 29, 282, 352))
);
let mut size_cpu = loaded.cpu.clone();
size_cpu.gpr[3] = window;
size_cpu.gpr[4] = 200;
size_cpu.gpr[5] = 100;
assert_eq!(
ppc_size_window(&size_cpu, &mut loaded.memory, &mut loaded.gworlds),
Some(())
);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, content_rgn),
Some((40, 30, 140, 230))
);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, structure_rgn),
Some((21, 29, 142, 232))
);
}
#[test]
fn hidden_ppc_geometry_changes_do_not_repaint_visible_pixels() {
let pef = synthetic_pef_with_import(b"MoveWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 32]);
let visible = create_test_cwindow(
&mut loaded,
bounds_ptr,
(100, 100, 260, 300),
0,
true,
u32::MAX,
);
let hidden = create_test_cwindow(
&mut loaded,
bounds_ptr,
(120, 120, 220, 220),
0,
false,
u32::MAX,
);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
ppc_quickdraw_write_pixel(&mut loaded.memory, front, (160, 160), PPC_RGB_BLACK);
let before = ppc_quickdraw_read_pixel(&mut loaded.memory, front, (160, 160));
loaded.set_event_queue(std::iter::empty());
loaded.cpu.gpr[3] = hidden;
loaded.cpu.gpr[4] = 140;
loaded.cpu.gpr[5] = 140;
loaded.cpu.gpr[6] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SizeWindow);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (160, 160)),
before,
"resizing a hidden window must not erase a visible window's content",
);
assert!(loaded.event_queue().is_empty());
loaded.cpu.gpr[3] = hidden;
loaded.cpu.gpr[4] = 300;
loaded.cpu.gpr[5] = 300;
loaded.cpu.gpr[6] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MoveWindow);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (160, 160)),
before,
"moving a hidden window must not erase a visible window's content",
);
assert!(loaded.event_queue().is_empty());
assert_eq!(ppc_front_visible_process_window(&mut loaded.memory, &loaded.window_list), Some(visible));
}
#[test]
fn disposing_hidden_ppc_window_does_not_repaint_exposed_pixels() {
let pef = synthetic_pef_with_import(b"DisposeWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 32]);
let _visible = create_test_cwindow(
&mut loaded,
bounds_ptr,
(100, 100, 260, 300),
0,
true,
u32::MAX,
);
let hidden = create_test_cwindow(
&mut loaded,
bounds_ptr,
(120, 120, 220, 220),
0,
false,
u32::MAX,
);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
ppc_quickdraw_write_pixel(&mut loaded.memory, front, (160, 160), PPC_RGB_BLACK);
let before = ppc_quickdraw_read_pixel(&mut loaded.memory, front, (160, 160));
loaded.set_event_queue(std::iter::empty());
loaded.cpu.gpr[3] = hidden;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::LegacyWindow(PpcLegacyWindowOperation::DisposeWindow),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (160, 160)),
before,
"disposing a hidden window must not repaint its former structure",
);
assert!(!loaded
.event_queue()
.iter()
.any(|event| event.message == hidden));
assert!(!loaded.window_list.contains(&hidden));
}
#[test]
fn ppc_move_window_front_true_reorders_and_activates_window() {
let pef = synthetic_pef_with_import(b"MoveWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 32]);
let back = create_test_cwindow(
&mut loaded,
bounds_ptr,
(100, 100, 260, 300),
0,
true,
u32::MAX,
);
let front = create_test_cwindow(
&mut loaded,
bounds_ptr,
(120, 120, 280, 320),
0,
true,
u32::MAX,
);
loaded.set_event_queue(std::iter::empty());
assert_eq!(loaded.window_list.first(), Some(front));
loaded.cpu.gpr[3] = back;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 100;
loaded.cpu.gpr[6] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MoveWindow);
assert_eq!(loaded.window_list.first(), Some(back));
assert_eq!(
ppc_front_visible_process_window(&mut loaded.memory, &loaded.window_list),
Some(back)
);
assert_eq!(*loaded.current_gworld, back);
assert_eq!(
loaded.memory.read_u8(back + PPC_CWINDOW_HILITED_OFFSET),
Some(1)
);
assert_eq!(
loaded.memory.read_u8(front + PPC_CWINDOW_HILITED_OFFSET),
Some(0)
);
assert_eq!(
ppc_find_window_at_point(
&mut loaded.memory,
&loaded.gworlds,
&loaded.window_list,
180,
180,
20,
),
(3, back),
"front=true must update hit testing as well as the list",
);
}
#[test]
fn ppc_zoom_window_recalculates_visibility_and_queues_redraw() {
let pef = synthetic_pef_with_import(b"ZoomWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 32]);
let window = create_test_cwindow(
&mut loaded,
bounds_ptr,
(100, 100, 240, 300),
8,
true,
u32::MAX,
);
let vis_rgn = loaded
.memory
.read_u32_be(window + PPC_CGRAF_PORT_VIS_RGN_OFFSET)
.unwrap();
let old_vis = ppc_read_rgn_bbox(&mut loaded.memory, vis_rgn).unwrap();
let update_rgn = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_UPDATE_RGN_OFFSET)
.unwrap();
ppc_set_empty_rgn(&mut loaded.memory, update_rgn);
loaded.set_event_queue(std::iter::empty());
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = 8;
loaded.cpu.gpr[5] = 1;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::LegacyWindow(PpcLegacyWindowOperation::ZoomWindow),
);
assert_eq!(
ppc_dialog_global_bounds(&mut loaded.memory, &loaded.gworlds, window),
Some((20, 0, PPC_MAIN_SCREEN_HEIGHT as i16, PPC_MAIN_SCREEN_WIDTH as i16)),
);
assert_ne!(
ppc_read_rgn_bbox(&mut loaded.memory, vis_rgn),
Some(old_vis),
"ZoomWindow must recalculate the visible region",
);
let update = ppc_read_rgn_bbox(&mut loaded.memory, update_rgn).unwrap();
assert!(update.0 < update.2 && update.1 < update.3);
assert!(loaded
.event_queue()
.iter()
.any(|event| event.what == 6 && event.message == window));
assert_eq!(*loaded.current_gworld, window);
}
#[test]
fn ppc_zoom_front_promotion_preserves_promoted_window_pixels() {
let pef = synthetic_pef_with_import(b"ZoomWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 32]);
let _formerly_front = create_test_cwindow(
&mut loaded,
bounds_ptr,
(100, 100, 260, 300),
1,
true,
u32::MAX,
);
let _middle = create_test_cwindow(
&mut loaded,
bounds_ptr,
(120, 120, 280, 320),
1,
true,
0,
);
let promoted = create_test_cwindow(
&mut loaded,
bounds_ptr,
(150, 150, 300, 350),
1,
true,
0,
);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let black = ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut)
.unwrap();
// The promoted dialog's top structure edge lies inside both older
// windows' content rectangles. A back-to-front repaint must leave
// this edge owned by the promoted window.
let promoted_edge = (200, 142);
loaded.set_event_queue(std::iter::empty());
loaded.cpu.gpr[3] = promoted;
loaded.cpu.gpr[4] = 4;
loaded.cpu.gpr[5] = 1;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::LegacyWindow(PpcLegacyWindowOperation::ZoomWindow),
);
assert_eq!(loaded.window_list.first(), Some(promoted));
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, promoted_edge),
Some(black),
"front-promoted ZoomWindow frame must remain above older overlapping windows",
);
}
#[test]
fn hle_import_runner_set_win_color_applies_content_color_and_queues_update() {
let pef = synthetic_pef_with_import(b"SetWinColor");
let mut loaded = load_pef_application(&pef).unwrap();
let table = [
0, 0, 0, 1, // reserved seed
0, 0, // reserved flags
0, 0, // one entry
0, 0, // wContentColor
0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
];
let table_handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&table,
);
loaded.cpu.gpr[3] = PPC_MAIN_GWORLD;
loaded.cpu.gpr[4] = table_handle;
loaded
.memory
.write_u8(PPC_MAIN_GWORLD + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded.memory.write_u16_be(PPC_MAIN_SCREEN_BASE, 0).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CWINDOW_COLOR_TABLE_HANDLE_OFFSET),
Some(table_handle)
);
assert_eq!(
loaded.quickdraw_back_color,
PpcRgbColor {
red: 0x1234,
green: 0x5678,
blue: 0x9abc,
}
);
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let expected = ppc_quickdraw_surface_color_pixel(
&mut loaded.memory,
surface,
loaded.quickdraw_back_color,
)
.unwrap();
match surface.front_buffer.depth {
8 => assert_eq!(
loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE),
Some(expected as u8)
),
16 => assert_eq!(
loaded.memory.read_u16_be(PPC_MAIN_SCREEN_BASE),
Some(expected)
),
depth => panic!("unexpected synthetic screen depth {depth}"),
}
assert!(loaded
.event_queue
.iter()
.any(|event| event.what == 6 && event.message == PPC_MAIN_GWORLD));
}
#[test]
fn hle_import_runner_new_cwindow_draws_dbox_structure_region() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 100, 100, 200, 300).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 1;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 0;
loaded.cpu.gpr[10] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let window = loaded.cpu.gpr[3];
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, window).unwrap();
let black =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK).unwrap();
let white =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_WHITE).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (92, 92)),
Some(black)
);
assert_ne!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (94, 94)),
Some(black)
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (95, 95)),
Some(black)
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (150, 150)),
Some(white)
);
}
#[test]
fn hle_import_runner_updates_guest_window_visibility() {
let window = PPC_DATA_BASE + 0x1000;
let pef = synthetic_pef_with_import(b"HideWindow");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.memory
.add_region(window, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded
.memory
.write_u8(window + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u8(window + PPC_CWINDOW_HILITED_OFFSET, 1)
.unwrap();
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = window);
loaded.cpu.gpr[3] = window;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.memory.read_u8(window + PPC_CWINDOW_VISIBLE_OFFSET),
Some(0)
);
assert_eq!(
loaded.memory.read_u8(window + PPC_CWINDOW_HILITED_OFFSET),
Some(0)
);
assert_eq!(*loaded.current_gworld, window);
let pef = synthetic_pef_with_import(b"ShowHide");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.memory
.add_region(window, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.memory.read_u8(window + PPC_CWINDOW_VISIBLE_OFFSET),
Some(1)
);
}
#[test]
fn hle_import_runner_new_cwindow_uses_current_screen_depth() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let mut depth_cpu = loaded.cpu.clone();
depth_cpu.gpr[3] = PPC_MAIN_GDEVICE;
depth_cpu.gpr[4] = 8;
let mut last_mem_error = PPC_NO_ERR;
assert_eq!(
with_test_display_cluts!(loaded, |screen_clut, color_manager_clut| ppc_set_depth(
&depth_cpu,
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
&mut loaded.gworlds,
&mut loaded.toolbox_startup,
screen_clut,
color_manager_clut,
)),
PPC_NO_ERR
);
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 0, 0, 240, 320).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 0;
loaded.cpu.gpr[10] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
let window = loaded.cpu.gpr[3];
let record = loaded
.gworlds
.iter()
.find(|record| record.port == window)
.unwrap();
assert_eq!(record.depth, 8);
assert_eq!(record.base_addr, PPC_MAIN_SCREEN_BASE);
assert_eq!(record.row_bytes, PPC_MAIN_SCREEN_WIDTH + 16);
assert_eq!(loaded.memory.read_u16_be(record.pixmap + 32), Some(8));
}
#[test]
fn hle_import_runner_handles_new_cwindow_caller_storage() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let bounds_ptr = scratch;
let storage_ptr = scratch + 0x100;
loaded.memory.add_region(scratch, vec![0; 32]);
loaded
.memory
.add_region(storage_ptr, vec![0xaa; PPC_CGRAF_PORT_SIZE as usize]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 20, 10, 260, 330).unwrap();
let heap_cursor = loaded.heap_cursor();
let required = ppc_heap_allocation_sequence_size(&[
PPC_PIXMAP_SIZE,
4,
4,
10,
4,
10,
4,
10,
4,
10,
4,
10,
4,
4,
4,
1,
4,
16,
])
.unwrap();
loaded.cpu.gpr[3] = storage_ptr;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 2;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0x1234_5678;
let gworld_count = loaded.gworlds.len();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], storage_ptr);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(*loaded.current_gworld, storage_ptr);
assert_eq!(*loaded.current_gdevice, PPC_MAIN_GDEVICE);
assert_eq!(loaded.heap_cursor(), heap_cursor + required);
assert_eq!(loaded.gworlds.len(), gworld_count + 1);
let record = loaded
.gworlds
.iter()
.find(|record| record.port == storage_ptr)
.unwrap();
assert_eq!(record.width, 320);
assert_eq!(record.height, 240);
assert_eq!(loaded.memory.read_u16_be(storage_ptr), Some(0));
assert_eq!(
loaded.memory.read_u32_be(storage_ptr + 2),
Some(record.pixmap_handle)
);
assert_eq!(
loaded.memory.read_u32_be(storage_ptr + 152),
Some(0x1234_5678)
);
}
#[test]
fn hle_import_runner_handles_get_new_cwindow() {
let pef = synthetic_pef_with_import(b"GetNewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let storage_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(storage_ptr, vec![0xaa; PPC_CGRAF_PORT_SIZE as usize]);
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"WIND"),
res_id: 1000,
name: Vec::new(),
data: test_wind_resource((40, 50, 240, 350), 0, false, true, 0x1234_5678, b"Document"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 1000;
loaded.cpu.gpr[4] = storage_ptr;
loaded.cpu.gpr[5] = u32::MAX;
let gworld_count = loaded.gworlds.len();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], storage_ptr);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(*loaded.current_gworld, storage_ptr);
assert_eq!(*loaded.current_gdevice, PPC_MAIN_GDEVICE);
assert_eq!(loaded.gworlds.len(), gworld_count + 1);
let record = loaded
.gworlds
.iter()
.find(|record| record.port == storage_ptr)
.unwrap();
assert_eq!(record.width, 300);
assert_eq!(record.height, 200);
assert_eq!(record.depth, PPC_MAIN_PIXEL_DEPTH);
assert_eq!(
ppc_read_rect(&mut loaded.memory, storage_ptr + 16),
Some((0, 0, 200, 300))
);
assert_eq!(
loaded
.memory
.read_u8(storage_ptr + PPC_CWINDOW_VISIBLE_OFFSET),
Some(0)
);
assert_eq!(
loaded
.memory
.read_u8(storage_ptr + PPC_CWINDOW_GO_AWAY_OFFSET),
Some(1)
);
assert_eq!(
loaded
.memory
.read_u32_be(storage_ptr + PPC_CGRAF_PORT_WINDOW_REF_CON_OFFSET),
Some(0x1234_5678)
);
let title_handle = loaded
.memory
.read_u32_be(storage_ptr + PPC_CWINDOW_TITLE_HANDLE_OFFSET)
.unwrap();
let title = loaded.memory.read_u32_be(title_handle).unwrap();
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, title),
Some(b"Document".to_vec())
);
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
loaded.cpu.gpr[3] = storage_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::ShowWindow);
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, storage_ptr).unwrap();
let black =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK).unwrap();
assert_eq!(
loaded
.memory
.read_u8(storage_ptr + PPC_CWINDOW_VISIBLE_OFFSET),
Some(1)
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
surface.front_buffer,
surface.local_point((-1, -18)),
),
Some(black),
"ShowWindow did not draw the hidden WIND document frame",
);
}
#[test]
fn hle_import_runner_get_new_cwindow_rejects_missing_and_malformed_wind_atomically() {
let pef = synthetic_pef_with_import(b"GetNewCWindow");
for (label, resource, expected_error) in [
("missing", None, PPC_RES_NOT_FOUND_ERR),
(
"truncated title",
Some({
let mut wind = test_wind_resource(
(40, 50, 240, 350),
0,
true,
true,
0x1234_5678,
b"Document",
);
wind.truncate(21);
wind
}),
PPC_PARAM_ERR,
),
] {
let mut loaded = load_pef_application(&pef).unwrap();
let storage_ptr = PPC_DATA_BASE + 0x1000;
let storage = vec![0xa5; PPC_CGRAF_PORT_SIZE as usize];
loaded.memory.add_region(storage_ptr, storage.clone());
if let Some(data) = resource {
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"WIND"),
res_id: 1000,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
loaded.cpu.gpr[3] = 1000;
loaded.cpu.gpr[4] = storage_ptr;
loaded.cpu.gpr[5] = u32::MAX;
let gworlds = loaded.gworlds.clone();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None, "{label}");
assert_eq!(loaded.cpu.gpr[3], 0, "{label}");
assert_eq!(loaded.test_resource_error(), expected_error, "{label}");
assert_eq!(loaded.gworlds, gworlds, "{label}");
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, storage_ptr, PPC_CGRAF_PORT_SIZE,),
Some(storage),
"{label}",
);
}
}
#[test]
fn hle_import_runner_get_new_cwindow_associates_matching_palette() {
let pef = synthetic_pef_with_import(b"GetNewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let storage_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(storage_ptr, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"WIND"),
res_id: 1000,
name: Vec::new(),
data: test_wind_resource((20, 30, 220, 330), 0, true, true, 0, b"Palette"),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
let mut palette_resource = vec![0xaa; 48];
palette_resource[..2].copy_from_slice(&2u16.to_be_bytes());
palette_resource[16..22].copy_from_slice(&[0x11, 0x11, 0x22, 0x22, 0x33, 0x33]);
palette_resource[22..24].copy_from_slice(&0x0002u16.to_be_bytes());
palette_resource[24..26].copy_from_slice(&0u16.to_be_bytes());
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"pltt"),
res_id: 1000,
name: Vec::new(),
data: palette_resource,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 1000;
loaded.cpu.gpr[4] = storage_ptr;
loaded.cpu.gpr[5] = u32::MAX;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
let palette_handle = loaded
.memory
.read_u32_be(storage_ptr + PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET)
.unwrap();
assert_ne!(palette_handle, 0);
assert_eq!(
loaded
.memory
.read_u16_be(storage_ptr + PPC_CGRAF_PORT_PALETTE_UPDATES_OFFSET),
Some(1)
);
let palette = loaded.memory.read_u32_be(palette_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(palette), Some(2));
assert_eq!(loaded.memory.read_u16_be(palette + 2), Some(0));
assert_eq!(loaded.memory.read_u16_be(palette + 16), Some(0x1111));
assert_eq!(loaded.memory.read_u16_be(palette + 18), Some(0x2222));
assert_eq!(loaded.memory.read_u16_be(palette + 20), Some(0x3333));
assert_eq!(loaded.screen_clut[1], [0x1111, 0x2222, 0x3333]);
}
#[test]
fn hle_import_runner_handles_set_w_ref_con() {
let pef = synthetic_pef_with_import(b"SetWRefCon");
let mut loaded = load_pef_application(&pef).unwrap();
let window_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(window_ptr, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded
.memory
.write_u32_be(window_ptr + 152, 0x1111_2222)
.unwrap();
loaded.cpu.gpr[3] = window_ptr;
loaded.cpu.gpr[4] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.memory.read_u32_be(window_ptr + 152),
Some(0x1234_5678)
);
}
#[test]
fn hle_import_runner_handles_get_w_ref_con() {
let pef = synthetic_pef_with_import(b"GetWRefCon");
let mut loaded = load_pef_application(&pef).unwrap();
let window_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(window_ptr, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded
.memory
.write_u32_be(window_ptr + 152, 0x1234_5678)
.unwrap();
loaded.cpu.gpr[3] = window_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x1234_5678);
}
#[test]
fn hle_import_runner_handles_size_window() {
let pef = synthetic_pef_with_import(b"SizeWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let window_ptr = PPC_DATA_BASE + 0x1000;
let pixmap_handle = PPC_DATA_BASE + 0x1100;
let pixmap = PPC_DATA_BASE + 0x1200;
loaded
.memory
.add_region(window_ptr, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded.memory.add_region(pixmap_handle, vec![0; 4]);
loaded
.memory
.add_region(pixmap, vec![0; PPC_PIXMAP_SIZE as usize]);
loaded
.memory
.write_u32_be(window_ptr + 2, pixmap_handle)
.unwrap();
loaded.memory.write_u32_be(pixmap_handle, pixmap).unwrap();
ppc_write_rect(&mut loaded.memory, window_ptr + 16, 0, 0, 240, 320).unwrap();
ppc_write_rect(&mut loaded.memory, pixmap + 6, -20, -10, 460, 630).unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: window_ptr,
pixmap_handle,
pixmap,
base_addr: PPC_DATA_BASE + 0x2000,
gdevice: PPC_MAIN_GDEVICE,
width: 320,
height: 240,
depth: PPC_MAIN_PIXEL_DEPTH,
row_bytes: 1280,
pixels_locked: false,
pixels_no_purge: false,
});
loaded.cpu.gpr[3] = window_ptr;
loaded.cpu.gpr[4] = 512;
loaded.cpu.gpr[5] = 384;
loaded.cpu.gpr[6] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_rect(&mut loaded.memory, window_ptr + 16),
Some((0, 0, 384, 512))
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, pixmap + 6),
Some((-20, -10, 460, 630))
);
let record = loaded
.gworlds
.iter()
.find(|record| record.port == window_ptr)
.unwrap();
assert_eq!(record.width, 512);
assert_eq!(record.height, 384);
assert_eq!(record.row_bytes, 1280);
}
#[test]
fn hle_import_runner_handles_move_window() {
let pef = synthetic_pef_with_import(b"MoveWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let window_ptr = PPC_DATA_BASE + 0x1000;
let pixmap_handle = PPC_DATA_BASE + 0x1100;
let pixmap = PPC_DATA_BASE + 0x1200;
loaded
.memory
.add_region(window_ptr, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded.memory.add_region(pixmap_handle, vec![0; 4]);
loaded
.memory
.add_region(pixmap, vec![0; PPC_PIXMAP_SIZE as usize]);
loaded
.memory
.write_u32_be(window_ptr + 2, pixmap_handle)
.unwrap();
loaded.memory.write_u32_be(pixmap_handle, pixmap).unwrap();
ppc_write_rect(&mut loaded.memory, window_ptr + 16, 0, 0, 384, 512).unwrap();
ppc_write_rect(&mut loaded.memory, pixmap + 6, -20, -10, 460, 630).unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: window_ptr,
pixmap_handle,
pixmap,
base_addr: PPC_DATA_BASE + 0x2000,
gdevice: PPC_MAIN_GDEVICE,
width: 512,
height: 384,
depth: PPC_MAIN_PIXEL_DEPTH,
row_bytes: 1280,
pixels_locked: false,
pixels_no_purge: false,
});
loaded.cpu.gpr[3] = window_ptr;
loaded.cpu.gpr[4] = 30;
loaded.cpu.gpr[5] = 40;
loaded.cpu.gpr[6] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_rect(&mut loaded.memory, window_ptr + 16),
Some((0, 0, 384, 512))
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, pixmap + 6),
Some((-40, -30, 440, 610))
);
let record = loaded
.gworlds
.iter()
.find(|record| record.port == window_ptr)
.unwrap();
assert_eq!(record.width, 512);
assert_eq!(record.height, 384);
assert_eq!(record.row_bytes, 1280);
}
#[test]
fn hle_import_runner_tracks_ppc_update_region_until_end_update() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 32]);
ppc_write_rect(&mut loaded.memory, scratch, 20, 10, 260, 330).unwrap();
ppc_write_pstring_bytes(&mut loaded.memory, scratch + 8, b"Document");
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch;
loaded.cpu.gpr[5] = scratch + 8;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewCWindow);
let window = loaded.cpu.gpr[3];
let update_rgn = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_UPDATE_RGN_OFFSET)
.unwrap();
let rect_ptr = scratch + 16;
ppc_write_rect(&mut loaded.memory, rect_ptr, 4, 6, 40, 50).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::InvalRect);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, update_rgn),
Some((4, 6, 40, 50)),
"InvalRect must publish a concrete local update region",
);
loaded.cpu.gpr[3] = window;
run_test_import(&mut loaded, PpcImportDispatcherTarget::BeginUpdate);
assert_eq!(*loaded.current_gworld, window);
run_test_import(&mut loaded, PpcImportDispatcherTarget::EndUpdate);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, update_rgn),
Some((0, 0, 0, 0)),
"EndUpdate must clear the committed update region",
);
}
#[test]
fn hle_import_runner_handles_select_window() {
let pef = synthetic_pef_with_import(b"SelectWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let window_ptr = PPC_DATA_BASE + 0x1000;
let gdevice = PPC_DATA_BASE + 0x2000;
loaded
.memory
.add_region(window_ptr, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded
.memory
.write_u8(window_ptr + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: window_ptr,
pixmap_handle: PPC_DATA_BASE + 0x1100,
pixmap: PPC_DATA_BASE + 0x1200,
base_addr: PPC_DATA_BASE + 0x3000,
gdevice,
width: 320,
height: 240,
depth: PPC_MAIN_PIXEL_DEPTH,
row_bytes: 640,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = PPC_MAIN_GDEVICE);
loaded.cpu.gpr[3] = window_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(*loaded.current_gworld, window_ptr);
assert_eq!(*loaded.current_gdevice, gdevice);
assert_eq!(
ppc_front_visible_window(&mut loaded.memory, &loaded.gworlds),
Some(window_ptr)
);
assert_eq!(
loaded
.memory
.read_u8(window_ptr + PPC_CWINDOW_HILITED_OFFSET),
Some(1)
);
}
#[test]
fn hle_import_runner_handles_close_window() {
let pef = synthetic_pef_with_import(b"CloseWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let underlying_window = PPC_DATA_BASE + 0x0800;
let window_ptr = PPC_DATA_BASE + 0x1000;
let gdevice = PPC_DATA_BASE + 0x2000;
loaded
.memory
.add_region(underlying_window, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded
.memory
.add_region(window_ptr, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded
.memory
.write_u8(underlying_window + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u8(window_ptr + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: underlying_window,
pixmap_handle: PPC_DATA_BASE + 0x0900,
pixmap: PPC_DATA_BASE + 0x0a00,
base_addr: PPC_DATA_BASE + 0x4000,
gdevice,
width: 320,
height: 240,
depth: PPC_MAIN_PIXEL_DEPTH,
row_bytes: 640,
pixels_locked: false,
pixels_no_purge: false,
});
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: window_ptr,
pixmap_handle: PPC_DATA_BASE + 0x1100,
pixmap: PPC_DATA_BASE + 0x1200,
base_addr: PPC_DATA_BASE + 0x3000,
gdevice,
width: 320,
height: 240,
depth: PPC_MAIN_PIXEL_DEPTH,
row_bytes: 640,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = window_ptr);
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = gdevice);
loaded.cpu.gpr[3] = window_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(loaded
.gworlds
.iter()
.any(|record| record.port == PPC_MAIN_GWORLD));
assert!(loaded
.gworlds
.iter()
.any(|record| record.port == PPC_DSP_BACK_GWORLD));
assert!(!loaded
.gworlds
.iter()
.any(|record| record.port == window_ptr));
assert_eq!(*loaded.current_gworld, underlying_window);
assert_eq!(*loaded.current_gdevice, gdevice);
assert!(loaded
.event_queue()
.iter()
.any(|event| event.what == 6 && event.message == underlying_window));
}
mod palette_manager;
#[test]
fn hle_import_runner_new_cwindow_heap_full_does_not_partially_allocate() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let bounds_ptr = scratch;
loaded.memory.add_region(scratch, vec![0; 32]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 20, 10, 260, 330).unwrap();
let heap_cursor = loaded.heap_cursor();
let region_count = loaded.memory.region_count();
let gworld_count = loaded.gworlds.len();
let required = ppc_heap_allocation_sequence_size(&[
PPC_PIXMAP_SIZE,
4,
PPC_CGRAF_PORT_SIZE,
4,
10,
4,
10,
4,
10,
])
.unwrap();
loaded.set_heap_limit(heap_cursor + required - 4);
assert_eq!(loaded.memory.read_u8(heap_cursor), Some(0));
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 2;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.last_mem_error(), PPC_MEM_FULL_ERR);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(loaded.memory.region_count(), region_count);
assert_eq!(loaded.memory.read_u8(heap_cursor), Some(0));
assert_eq!(loaded.gworlds.len(), gworld_count);
assert_eq!(*loaded.current_gworld, PPC_MAIN_GWORLD);
assert_eq!(*loaded.current_gdevice, PPC_MAIN_GDEVICE);
}
#[test]
fn hle_import_runner_new_cwindow_param_err_does_not_partially_allocate() {
let pef = synthetic_pef_with_import(b"NewCWindow");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let bounds_ptr = scratch;
loaded.memory.add_region(scratch, vec![0; 32]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 20, 10, 260, 330).unwrap();
let heap_cursor = loaded.heap_cursor();
let region_count = loaded.memory.region_count();
let gworld_count = loaded.gworlds.len();
assert_eq!(loaded.memory.read_u8(heap_cursor), Some(0));
loaded.cpu.gpr[3] = 0x06ff_0000;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 2;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.last_mem_error(), PPC_PARAM_ERR);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(loaded.memory.region_count(), region_count);
assert_eq!(loaded.memory.read_u8(heap_cursor), Some(0));
assert_eq!(loaded.gworlds.len(), gworld_count);
assert_eq!(*loaded.current_gworld, PPC_MAIN_GWORLD);
assert_eq!(*loaded.current_gdevice, PPC_MAIN_GDEVICE);
}
mod gworld;
mod blit;
#[test]
fn hle_import_runner_scrollrect_clips_and_reports_exact_l_shape() {
let pef = synthetic_pef_with_import(b"ScrollRect");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_HEAP_BASE + 0x14000;
let rect_ptr = scratch + 0x80;
let pixpat_handle = scratch + 0x1c0;
let pixpat_ptr = scratch + 0x1c4;
loaded.memory.add_region(scratch, vec![0; 0x300]);
// Replace the main PixMap's live base/bounds with a small test raster;
// the live-port resolver must follow these fields rather than the
// creation-time GWorld record.
ppc_write_pixmap(
&mut loaded.memory,
PPC_MAIN_PIXMAP,
scratch,
8,
0,
0,
6,
6,
8,
)
.unwrap();
for y in 0..8u32 {
for x in 0..8u32 {
loaded
.memory
.write_u8(scratch + y * 8 + x, (100 + y * 8 + x) as u8)
.unwrap();
}
}
// A live bkPixPat should supply the fill pattern in preference to
// the legacy cache. The differing fallback makes that precedence
// observable in the first exposed row.
loaded
.memory
.write_u32_be(pixpat_handle, pixpat_ptr)
.unwrap();
loaded
.memory
.write_bytes(pixpat_ptr + 20, &[0x80, 0, 0, 0, 0, 0, 0, 0])
.unwrap();
loaded
.memory
.write_u32_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_BK_PIXPAT_OFFSET, pixpat_handle)
.unwrap();
loaded.toolbox_startup.quickdraw_back_pattern = [0; 8];
let region = {
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewRgn);
loaded.cpu.gpr[3]
};
ppc_write_rect(&mut loaded.memory, rect_ptr, -1, -1, 5, 5).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = 2;
loaded.cpu.gpr[6] = region;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::ScrollRect,
),
);
// The requested rect is clipped to [0,5)×[0,5), and the source is
// snapshotted before overlapping writes. x=5/y=5 remain untouched.
assert_eq!(loaded.memory.read_u8(scratch), Some(255));
assert_eq!(loaded.memory.read_u8(scratch + 1), Some(0));
assert_eq!(loaded.memory.read_u8(scratch + 8), Some(0));
assert_eq!(loaded.memory.read_u8(scratch + 2 + 2 * 8), Some(100));
assert_eq!(loaded.memory.read_u8(scratch + 5), Some(105));
assert_eq!(loaded.memory.read_u8(scratch + 5 * 8), Some(140));
let storage = ppc_region_storage(&mut loaded.memory, region).unwrap();
assert_eq!(ppc_region_storage_bbox(&storage), Some((0, 0, 5, 5)));
assert!(ppc_point_in_region_storage(&storage, 0, 4));
assert!(ppc_point_in_region_storage(&storage, 1, 0));
assert!(ppc_point_in_region_storage(&storage, 2, 1));
assert!(!ppc_point_in_region_storage(&storage, 2, 2));
assert!(!ppc_point_in_region_storage(&storage, 4, 2));
assert!(!ppc_point_in_region_storage(&storage, 5, 0));
assert_eq!(loaded.cpu.gpr[3], rect_ptr);
}
#[test]
fn hle_import_runner_backpat_and_backpixpat_install_fill_patterns() {
let backpat_pef = synthetic_pef_with_import(b"BackPat");
let mut loaded = load_pef_application(&backpat_pef).unwrap();
let pattern_ptr = PPC_HEAP_BASE + 0x14200;
loaded.memory.add_region(pattern_ptr, vec![0; 8]);
loaded.memory.write_bytes(pattern_ptr, &[0x80; 8]).unwrap();
loaded.cpu.gpr[3] = pattern_ptr;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::BackPat,
),
);
assert_eq!(loaded.toolbox_startup.quickdraw_back_pattern, [0x80; 8]);
assert_eq!(
loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_BK_PIXPAT_OFFSET),
Some(0),
"BackPat must clear a stale bkPixPat so its Pattern is authoritative"
);
let pixpat_pef = synthetic_pef_with_import(b"BackPixPat");
let mut loaded = load_pef_application(&pixpat_pef).unwrap();
let scratch = PPC_HEAP_BASE + 0x14400;
let pattern_handle = scratch;
let pattern_record = scratch + 4;
loaded.memory.add_region(scratch, vec![0; 0x40]);
loaded.memory.write_u32_be(pattern_handle, pattern_record).unwrap();
loaded
.memory
.write_bytes(pattern_record + 20, &[0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0])
.unwrap();
loaded.cpu.gpr[3] = pattern_handle;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::BackPixPat,
),
);
assert_eq!(
loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_BK_PIXPAT_OFFSET),
Some(pattern_handle)
);
assert_eq!(
loaded.toolbox_startup.quickdraw_back_pattern,
[0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0]
);
}
#[test]
fn hle_import_runner_handles_set_rect() {
let pef = synthetic_pef_with_import(b"SetRect");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_HEAP_BASE;
loaded.memory.add_region(rect_ptr, vec![0xaa; 8]);
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = 20; // left
loaded.cpu.gpr[5] = 10; // top
loaded.cpu.gpr[6] = 120; // right
loaded.cpu.gpr[7] = 80; // bottom
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], rect_ptr);
assert_eq!(loaded.memory.read_u16_be(rect_ptr), Some(10));
assert_eq!(loaded.memory.read_u16_be(rect_ptr + 2), Some(20));
assert_eq!(loaded.memory.read_u16_be(rect_ptr + 4), Some(80));
assert_eq!(loaded.memory.read_u16_be(rect_ptr + 6), Some(120));
}
#[test]
fn hle_import_runner_handles_union_rect_with_aliased_destination() {
let pef = synthetic_pef_with_import(b"UnionRect");
let mut loaded = load_pef_application(&pef).unwrap();
let first = PPC_HEAP_BASE;
let second = PPC_HEAP_BASE + 8;
loaded.memory.add_region(first, vec![0; 16]);
ppc_write_rect(&mut loaded.memory, first, 10, 30, 80, 100).unwrap();
ppc_write_rect(&mut loaded.memory, second, -5, 40, 60, 120).unwrap();
loaded.cpu.gpr[3] = first;
loaded.cpu.gpr[4] = second;
loaded.cpu.gpr[5] = first;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_rect(&mut loaded.memory, first),
Some((-5, 30, 80, 120))
);
}
#[test]
fn hle_import_runner_handles_empty_rect() {
let pef = synthetic_pef_with_import(b"EmptyRect");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_HEAP_BASE;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 10, 20, 10, 40).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
}
#[test]
fn hle_import_runner_handles_set_pt() {
let pef = synthetic_pef_with_import(b"SetPt");
let mut loaded = load_pef_application(&pef).unwrap();
let point_ptr = PPC_HEAP_BASE;
loaded.memory.add_region(point_ptr, vec![0xaa; 4]);
loaded.cpu.gpr[3] = point_ptr;
loaded.cpu.gpr[4] = 123; // h
loaded.cpu.gpr[5] = 45; // v
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(point_ptr), Some(45));
assert_eq!(loaded.memory.read_u16_be(point_ptr + 2), Some(123));
}
#[test]
fn hle_import_runner_handles_equal_pt() {
let pef = synthetic_pef_with_import(b"EqualPt");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = (45u32 << 16) | 123;
loaded.cpu.gpr[4] = (45u32 << 16) | 123;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = (45u32 << 16) | 123;
loaded.cpu.gpr[4] = (46u32 << 16) | 123;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn quickdraw_point_transforms_use_current_port_offset() {
let pef = synthetic_pef_with_import(b"SetPt");
let mut loaded = load_pef_application(&pef).unwrap();
let point_ptr = PPC_HEAP_BASE;
loaded.memory.add_region(point_ptr, vec![0; 4]);
ppc_write_rect(&mut loaded.memory, PPC_MAIN_GWORLD + 16, 0, 0, 460, 590).unwrap();
ppc_write_rect(&mut loaded.memory, PPC_MAIN_PIXMAP + 6, -20, -50, 460, 590).unwrap();
loaded.memory.write_u16_be(point_ptr, 100).unwrap();
loaded.memory.write_u16_be(point_ptr + 2, 200).unwrap();
ppc_transform_port_point(&mut loaded.memory, PPC_MAIN_GWORLD, point_ptr, true).unwrap();
assert_eq!(loaded.memory.read_u16_be(point_ptr), Some(120));
assert_eq!(loaded.memory.read_u16_be(point_ptr + 2), Some(250));
ppc_transform_port_point(&mut loaded.memory, PPC_MAIN_GWORLD, point_ptr, false).unwrap();
assert_eq!(loaded.memory.read_u16_be(point_ptr), Some(100));
assert_eq!(loaded.memory.read_u16_be(point_ptr + 2), Some(200));
}
#[test]
fn hle_import_runner_handles_pt_in_rect() {
let pef = synthetic_pef_with_import(b"PtInRect");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_HEAP_BASE;
loaded.memory.add_region(rect_ptr, vec![0xaa; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 10, 20, 30, 40).unwrap();
loaded.cpu.gpr[3] = (10u32 << 16) | 20;
loaded.cpu.gpr[4] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = (30u32 << 16) | 20;
loaded.cpu.gpr[4] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn hle_import_runner_handles_offset_rect() {
let pef = synthetic_pef_with_import(b"OffsetRect");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_HEAP_BASE;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 10, 20, 80, 120).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = (-3i16 as u16) as u32; // dh
loaded.cpu.gpr[5] = 7; // dv
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], rect_ptr);
assert_eq!(loaded.memory.read_u16_be(rect_ptr), Some(17));
assert_eq!(loaded.memory.read_u16_be(rect_ptr + 2), Some(17));
assert_eq!(loaded.memory.read_u16_be(rect_ptr + 4), Some(87));
assert_eq!(loaded.memory.read_u16_be(rect_ptr + 6), Some(117));
}
#[test]
fn hle_import_runner_handles_map_rect() {
let pef = synthetic_pef_with_import(b"MapRect");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_HEAP_BASE;
let src_ptr = rect_ptr + 8;
let dst_ptr = src_ptr + 8;
loaded.memory.add_region(rect_ptr, vec![0; 24]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 20, 25, 60, 75).unwrap();
ppc_write_rect(&mut loaded.memory, src_ptr, 10, 20, 110, 120).unwrap();
ppc_write_rect(&mut loaded.memory, dst_ptr, -30, 200, 170, 600).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = src_ptr;
loaded.cpu.gpr[5] = dst_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_rect(&mut loaded.memory, rect_ptr),
Some((-10, 220, 70, 420))
);
}
#[test]
fn hle_import_runner_quickdraw_outputs_are_all_or_nothing() {
let pef = synthetic_pef_with_import(b"GetForeColor");
let mut loaded = load_pef_application(&pef).unwrap();
let color_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(color_ptr, vec![0xab; 4]);
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(color_ptr), Some(0xabab_abab));
let pef = synthetic_pef_with_import(b"GetPort");
let mut loaded = load_pef_application(&pef).unwrap();
let port_ptr = PPC_DATA_BASE + 0x1080;
loaded.memory.add_region(port_ptr, vec![0xba; 2]);
loaded.cpu.gpr[3] = port_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(port_ptr), Some(0xbaba));
let pef = synthetic_pef_with_import(b"GetGWorld");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(scratch, vec![0xcc; 6]);
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = scratch + 4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
for offset in 0..6 {
assert_eq!(loaded.memory.read_u8(scratch + offset), Some(0xcc));
}
let pef = synthetic_pef_with_import(b"DMGetGDeviceByDisplayID");
let mut loaded = load_pef_application(&pef).unwrap();
let gdevice_ptr = PPC_DATA_BASE + 0x1180;
loaded.memory.add_region(gdevice_ptr, vec![0xcd; 2]);
loaded.cpu.gpr[3] = PPC_DSP_DISPLAY_ID;
loaded.cpu.gpr[4] = gdevice_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.memory.read_u16_be(gdevice_ptr), Some(0xcdcd));
let pef = synthetic_pef_with_import(b"SetRect");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_DATA_BASE + 0x1200;
loaded.memory.add_region(rect_ptr, vec![0xdd; 4]);
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = 20;
loaded.cpu.gpr[5] = 10;
loaded.cpu.gpr[6] = 120;
loaded.cpu.gpr[7] = 80;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(rect_ptr), Some(0xdddd_dddd));
let pef = synthetic_pef_with_import(b"OffsetRect");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_DATA_BASE + 0x1300;
loaded.memory.add_region(rect_ptr, vec![0xee; 4]);
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = 3;
loaded.cpu.gpr[5] = 7;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(rect_ptr), Some(0xeeee_eeee));
}
mod file_manager;
#[test]
fn dialog_static_text_preserves_resource_line_breaks_before_wrapping() {
let text = b"Toolbox Showcase 2.0\rClassic Macintosh Fat-App Fixture\rRunning 68K and PowerPC slices";
assert_eq!(
ppc_dialog_text_lines(text, 260),
vec![
b"Toolbox Showcase 2.0".to_vec(),
b"Classic Macintosh Fat-App Fixture".to_vec(),
b"Running 68K and PowerPC slices".to_vec(),
]
);
}
#[test]
fn is_dialog_event_routes_front_dialog_input_and_rejects_foreign_updates() {
let pef = synthetic_pef_with_import(b"IsDialogEvent");
let mut loaded = load_pef_application(&pef).unwrap();
let event_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(event_ptr, vec![0; 16]);
loaded
.memory
.write_u16_be(PPC_MAIN_GWORLD + PPC_CWINDOW_WINDOW_KIND_OFFSET, 2)
.unwrap();
loaded
.memory
.write_u8(PPC_MAIN_GWORLD + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
ppc_write_event_record(&mut loaded.memory, event_ptr, 3, b'G' as u32, 0, 20, 30, 0);
loaded.cpu.gpr[3] = event_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
ppc_write_event_record(
&mut loaded.memory,
event_ptr,
6,
PPC_MAIN_GWORLD + 0x100,
0,
20,
30,
0,
);
loaded.cpu.gpr[3] = event_ptr;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn dialog_select_reports_enabled_item_hit_in_front_dialog() {
let pef = synthetic_pef_with_import(b"DialogSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let event_ptr = scratch;
let dialog_out_ptr = scratch + 16;
let item_hit_ptr = scratch + 20;
loaded.memory.add_region(scratch, vec![0; 32]);
loaded
.memory
.write_u16_be(PPC_MAIN_GWORLD + PPC_CWINDOW_WINDOW_KIND_OFFSET, 2)
.unwrap();
loaded
.memory
.write_u8(PPC_MAIN_GWORLD + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
let mut ditl = vec![0; 18];
ditl[6..8].copy_from_slice(&10i16.to_be_bytes());
ditl[8..10].copy_from_slice(&20i16.to_be_bytes());
ditl[10..12].copy_from_slice(&40i16.to_be_bytes());
ditl[12..14].copy_from_slice(&90i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_BUTTON;
ditl[15] = 2;
ditl[16..18].copy_from_slice(b"OK");
let items = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&ditl,
);
loaded
.memory
.write_u32_be(PPC_MAIN_GWORLD + PPC_DIALOG_ITEMS_OFFSET, items)
.unwrap();
ppc_write_event_record(&mut loaded.memory, event_ptr, 1, 0, 0, 20, 30, 0);
loaded.cpu.gpr[3] = event_ptr;
loaded.cpu.gpr[4] = dialog_out_ptr;
loaded.cpu.gpr[5] = item_hit_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(
loaded.memory.read_u32_be(dialog_out_ptr),
Some(PPC_MAIN_GWORLD)
);
assert_eq!(loaded.memory.read_u16_be(item_hit_ptr), Some(1));
}
#[test]
fn draw_dialog_calls_native_user_item_procedure_with_dialog_and_item_number() {
let pef = synthetic_pef_with_import(b"GetNewDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let mut dlog = vec![0; 22];
dlog[4..6].copy_from_slice(&100i16.to_be_bytes());
dlog[6..8].copy_from_slice(&200i16.to_be_bytes());
dlog[10] = 1;
dlog[18..20].copy_from_slice(&128i16.to_be_bytes());
let mut ditl = vec![0; 16];
ditl[6..8].copy_from_slice(&10i16.to_be_bytes());
ditl[8..10].copy_from_slice(&12i16.to_be_bytes());
ditl[10..12].copy_from_slice(&40i16.to_be_bytes());
ditl[12..14].copy_from_slice(&80i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_USER_ITEM;
for (res_type, data) in [(*b"DLOG", dlog), (*b"DITL", ditl)] {
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: String::new(),
res_type: u32::from_be_bytes(res_type),
res_id: 128,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
loaded.cpu.gpr[3] = 128;
loaded.run_with_hle_imports(64);
let dialog = loaded.cpu.gpr[3];
let items_handle = loaded
.memory
.read_u32_be(dialog + PPC_DIALOG_ITEMS_OFFSET)
.unwrap();
let items_ptr = loaded.memory.read_u32_be(items_handle).unwrap();
let callback = PPC_CODE_BASE + 0x1000;
let result = PPC_DATA_BASE + 0x1000;
let mut callback_code = Vec::new();
for word in [
d_form_u(15, 5, 0, (result >> 16) as u16), // lis r5, result@h
d_form_u(24, 5, 5, result as u16), // ori r5, r5, result@l
d_form_u(36, 3, 5, 0), // stw r3, 0(r5)
d_form_u(36, 4, 5, 4), // stw r4, 4(r5)
BLR,
] {
callback_code.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(callback, callback_code);
loaded.memory.add_region(result, vec![0; 8]);
loaded.memory.write_u32_be(items_ptr + 2, callback).unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DrawDialog;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = dialog;
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_MAIN_GWORLD);
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(result), Some(dialog));
assert_eq!(loaded.memory.read_u32_be(result + 4), Some(1));
assert_eq!(*loaded.current_gworld, dialog);
assert!(loaded.dialog_callback_stack.is_empty());
}
#[test]
fn hle_import_runner_handles_get_new_dialog_allocation() {
let pef = synthetic_pef_with_import(b"GetNewDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let mut dlog = vec![0; 22];
dlog[4..6].copy_from_slice(&100i16.to_be_bytes());
dlog[6..8].copy_from_slice(&200i16.to_be_bytes());
dlog[10] = 1;
dlog[12] = 1;
dlog[14..18].copy_from_slice(&0x1234_5678u32.to_be_bytes());
dlog[18..20].copy_from_slice(&128i16.to_be_bytes());
dlog[20] = 1;
dlog[21] = b'T';
let mut ditl = vec![0; 22];
ditl[6..8].copy_from_slice(&10i16.to_be_bytes());
ditl[8..10].copy_from_slice(&10i16.to_be_bytes());
ditl[10..12].copy_from_slice(&26i16.to_be_bytes());
ditl[12..14].copy_from_slice(&190i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_STATIC_TEXT;
ditl[15] = 5;
ditl[16..21].copy_from_slice(b"Hello");
for (res_type, data) in [(*b"DLOG", dlog), (*b"DITL", ditl)] {
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: String::new(),
res_type: u32::from_be_bytes(res_type),
res_id: 128,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
loaded.cpu.gpr[3] = 128;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let dialog = loaded.cpu.gpr[3];
assert_ne!(dialog, 0);
assert_eq!(*loaded.current_gworld, dialog);
assert!(loaded.heap_cursor() > dialog);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
assert_ne!(
loaded.memory.read_u32_be(dialog + PPC_DIALOG_ITEMS_OFFSET),
Some(0)
);
assert_eq!(
loaded
.memory
.read_u32_be(dialog + PPC_CGRAF_PORT_WINDOW_REF_CON_OFFSET),
Some(0x1234_5678)
);
}
#[test]
fn hle_import_runner_constructs_new_dialog_from_native_arguments() {
let pef = synthetic_pef_with_import(b"NewDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let bounds_ptr = scratch;
let title_ptr = scratch + 8;
loaded.memory.add_region(scratch, vec![0; 64]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 40, 60, 180, 300).unwrap();
write_ppc_pstring(&mut loaded.memory, title_ptr, b"Pilot");
let items = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&[0xff, 0xff],
);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = title_ptr;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 5;
loaded.cpu.gpr[8] = u32::MAX;
loaded.cpu.gpr[9] = 1;
loaded.cpu.gpr[10] = 0x1234_5678;
loaded
.memory
.write_u32_be(
ppc_parameter_area_slot_addr(loaded.cpu.gpr[1], PPC_NATIVE_PARAMETER_GPR_COUNT)
.unwrap(),
items,
)
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let dialog = loaded.cpu.gpr[3];
assert_ne!(dialog, 0);
assert_eq!(*loaded.current_gworld, dialog);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(
loaded
.memory
.read_u16_be(dialog + PPC_CWINDOW_WINDOW_KIND_OFFSET),
Some(2)
);
assert_eq!(
loaded.memory.read_u8(dialog + PPC_CWINDOW_VISIBLE_OFFSET),
Some(1)
);
assert_eq!(
loaded
.memory
.read_u32_be(dialog + PPC_CGRAF_PORT_WINDOW_REF_CON_OFFSET),
Some(0x1234_5678)
);
assert_eq!(
loaded.memory.read_u32_be(dialog + PPC_DIALOG_ITEMS_OFFSET),
Some(items)
);
assert_eq!(
loaded
.memory
.read_u16_be(dialog + PPC_DIALOG_EDIT_FIELD_OFFSET),
Some(u16::MAX)
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, dialog + 16),
Some((0, 0, 140, 240))
);
}
#[test]
fn new_dialog_keeps_missing_resource_items_nil_without_failing_the_dialog() {
let pef = synthetic_pef_with_import(b"NewDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let bounds_ptr = scratch;
let title_ptr = scratch + 8;
loaded.memory.add_region(scratch, vec![0; 64]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 40, 60, 180, 300).unwrap();
write_ppc_pstring(&mut loaded.memory, title_ptr, b"Missing system icon");
let mut ditl = vec![0; 18];
ditl[6..8].copy_from_slice(&12i16.to_be_bytes());
ditl[8..10].copy_from_slice(&20i16.to_be_bytes());
ditl[10..12].copy_from_slice(&44i16.to_be_bytes());
ditl[12..14].copy_from_slice(&52i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_ICON;
ditl[15] = 2;
ditl[16..18].copy_from_slice(&2i16.to_be_bytes());
let items = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&ditl,
);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = title_ptr;
loaded.cpu.gpr[6] = 1;
loaded.cpu.gpr[7] = 1;
loaded.cpu.gpr[8] = u32::MAX;
loaded
.memory
.write_u32_be(
ppc_parameter_area_slot_addr(loaded.cpu.gpr[1], PPC_NATIVE_PARAMETER_GPR_COUNT)
.unwrap(),
items,
)
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
let dialog = loaded.cpu.gpr[3];
assert_ne!(dialog, 0);
assert_eq!(*loaded.current_gworld, dialog);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
let items_ptr = loaded.memory.read_u32_be(items).unwrap();
assert_eq!(loaded.memory.read_u32_be(items_ptr + 2), Some(0));
}
#[test]
fn get_new_dialog_installs_owned_control_records_in_the_live_ditl() {
let pef = synthetic_pef_with_import(b"GetNewDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let mut dlog = vec![0; 22];
dlog[4..6].copy_from_slice(&100i16.to_be_bytes());
dlog[6..8].copy_from_slice(&200i16.to_be_bytes());
dlog[10] = 1;
dlog[18..20].copy_from_slice(&128i16.to_be_bytes());
let mut ditl = vec![0; 18];
ditl[6..8].copy_from_slice(&12i16.to_be_bytes());
ditl[8..10].copy_from_slice(&20i16.to_be_bytes());
ditl[10..12].copy_from_slice(&32i16.to_be_bytes());
ditl[12..14].copy_from_slice(&90i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_BUTTON;
ditl[15] = 2;
ditl[16..18].copy_from_slice(b"OK");
for (res_type, data) in [(*b"DLOG", dlog), (*b"DITL", ditl)] {
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: String::new(),
res_type: u32::from_be_bytes(res_type),
res_id: 128,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
loaded.cpu.gpr[3] = 128;
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.unsupported_import_index, None);
let dialog = loaded.cpu.gpr[3];
let items_handle = loaded
.memory
.read_u32_be(dialog + PPC_DIALOG_ITEMS_OFFSET)
.unwrap();
let items_ptr = loaded.memory.read_u32_be(items_handle).unwrap();
let control_handle = loaded.memory.read_u32_be(items_ptr + 2).unwrap();
let control = loaded.memory.read_u32_be(control_handle).unwrap();
assert_ne!(control_handle, 0);
assert_eq!(
loaded
.memory
.read_u32_be(dialog + PPC_CWINDOW_CONTROL_LIST_OFFSET),
Some(control_handle)
);
assert_eq!(
loaded
.memory
.read_u32_be(control + PPC_CONTROL_OWNER_OFFSET),
Some(dialog)
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, control + PPC_CONTROL_RECT_OFFSET),
Some((12, 20, 32, 90))
);
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, control + PPC_CONTROL_TITLE_OFFSET),
Some(b"OK".to_vec())
);
assert_eq!(
loaded.controls.records(),
vec![PpcControlRecord {
handle: control_handle,
pointer: control,
proc_id: 0,
popup_menu_id: 0,
popup_title_width: None,
}]
);
}
#[test]
fn selecting_active_dialog_preserves_its_contents() {
let pef = synthetic_pef_with_import(b"GetNewDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let mut dlog = vec![0; 22];
dlog[0..2].copy_from_slice(&40i16.to_be_bytes());
dlog[2..4].copy_from_slice(&60i16.to_be_bytes());
dlog[4..6].copy_from_slice(&140i16.to_be_bytes());
dlog[6..8].copy_from_slice(&260i16.to_be_bytes());
dlog[8..10].copy_from_slice(&1i16.to_be_bytes());
dlog[10] = 1;
dlog[18..20].copy_from_slice(&128i16.to_be_bytes());
let mut ditl = vec![0; 32];
ditl[6..8].copy_from_slice(&12i16.to_be_bytes());
ditl[8..10].copy_from_slice(&20i16.to_be_bytes());
ditl[10..12].copy_from_slice(&32i16.to_be_bytes());
ditl[12..14].copy_from_slice(&190i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_CHECKBOX;
ditl[15] = 13;
ditl[16..29].copy_from_slice(b"Sound Effects");
for (res_type, data) in [(*b"DLOG", dlog), (*b"DITL", ditl)] {
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: String::new(),
res_type: u32::from_be_bytes(res_type),
res_id: 128,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
loaded.cpu.gpr[3] = 128;
loaded.run_with_hle_imports(128);
let dialog = loaded.cpu.gpr[3];
run_test_import(&mut loaded, PpcImportDispatcherTarget::SelectWindow);
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, dialog).unwrap();
let marker =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK).unwrap();
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
surface.front_buffer,
(200, 110),
marker,
));
loaded.cpu.gpr[3] = dialog;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SelectWindow);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (200, 110)),
Some(marker),
"selecting an already-active dialog erased its contents"
);
}
#[test]
fn draw_dialog_uses_live_checkbox_control_instead_of_button_fallback() {
let pef = synthetic_pef_with_import(b"GetNewDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let mut dlog = vec![0; 22];
dlog[0..2].copy_from_slice(&40i16.to_be_bytes());
dlog[2..4].copy_from_slice(&60i16.to_be_bytes());
dlog[4..6].copy_from_slice(&140i16.to_be_bytes());
dlog[6..8].copy_from_slice(&260i16.to_be_bytes());
dlog[10] = 1;
dlog[18..20].copy_from_slice(&128i16.to_be_bytes());
let mut ditl = vec![0; 32];
ditl[6..8].copy_from_slice(&12i16.to_be_bytes());
ditl[8..10].copy_from_slice(&20i16.to_be_bytes());
ditl[10..12].copy_from_slice(&32i16.to_be_bytes());
ditl[12..14].copy_from_slice(&190i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_CHECKBOX;
ditl[15] = 13;
ditl[16..29].copy_from_slice(b"Sound Effects");
for (res_type, data) in [(*b"DLOG", dlog), (*b"DITL", ditl)] {
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: String::new(),
res_type: u32::from_be_bytes(res_type),
res_id: 128,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
loaded.cpu.gpr[3] = 128;
loaded.run_with_hle_imports(128);
let dialog = loaded.cpu.gpr[3];
let items_handle = loaded
.memory
.read_u32_be(dialog + PPC_DIALOG_ITEMS_OFFSET)
.unwrap();
let items_ptr = loaded.memory.read_u32_be(items_handle).unwrap();
let control_handle = loaded.memory.read_u32_be(items_ptr + 2).unwrap();
let control = loaded.memory.read_u32_be(control_handle).unwrap();
loaded
.memory
.write_u16_be(control + PPC_CONTROL_VALUE_OFFSET, 1)
.unwrap();
// Supply an existing surface; this test exercises item redraw, not
// window-background initialization.
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert!(ppc_fill_front_rect(
&mut loaded.memory,
front,
(40, 60, 140, 260),
PPC_RGB_WHITE,
));
// Application drawing outside standard items survives DrawDialog.
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, dialog).unwrap();
let marker =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK).unwrap();
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
surface.front_buffer,
(200, 110),
marker,
));
assert!(ppc_draw_dialog(
&mut loaded.memory,
&test_handle_records!(loaded),
&loaded.controls.records(),
&loaded.gworlds,
&loaded.screen_clut,
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
dialog,
));
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, dialog).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (200, 110)),
Some(marker),
"DrawDialog erased application drawing outside its items"
);
let black =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK).unwrap();
let white =
ppc_quickdraw_surface_color_pixel(&mut loaded.memory, surface, PPC_RGB_WHITE).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (82, 56)),
Some(black),
"live checkbox indicator was not drawn"
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (87, 61)),
Some(black),
"live checkbox value did not draw its checkmark"
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (249, 52)),
Some(white),
"checkbox title area retained the rectangular button frame"
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, surface.front_buffer, (77, 49)),
Some(white),
"the first checkbox incorrectly received the default-button outline"
);
}
#[test]
fn dialog_popup_controls_use_ditl_bounds_and_menu_resource_items() {
let pef = synthetic_pef_with_import(b"GetNewDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let mut dlog = vec![0; 22];
dlog[4..6].copy_from_slice(&180i16.to_be_bytes());
dlog[6..8].copy_from_slice(&320i16.to_be_bytes());
dlog[10] = 1;
dlog[18..20].copy_from_slice(&128i16.to_be_bytes());
let mut ditl = vec![0; 18];
ditl[6..8].copy_from_slice(&38i16.to_be_bytes());
ditl[8..10].copy_from_slice(&226i16.to_be_bytes());
ditl[10..12].copy_from_slice(&58i16.to_be_bytes());
ditl[12..14].copy_from_slice(&326i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_RESOURCE_CONTROL;
ditl[15] = 2;
ditl[16..18].copy_from_slice(&200i16.to_be_bytes());
let mut cntl = vec![0; 23];
cntl[4..6].copy_from_slice(&20i16.to_be_bytes());
cntl[6..8].copy_from_slice(&100i16.to_be_bytes());
cntl[10] = 1;
cntl[14..16].copy_from_slice(&300i16.to_be_bytes());
cntl[16..18].copy_from_slice(&1008i16.to_be_bytes());
let mut menu = vec![0; 15];
menu[0..2].copy_from_slice(&300i16.to_be_bytes());
menu[10..14].copy_from_slice(&u32::MAX.to_be_bytes());
for title in [b"Red".as_slice(), b"Orange".as_slice()] {
menu.push(title.len() as u8);
menu.extend_from_slice(title);
menu.extend_from_slice(&[0; 4]);
}
menu.push(0);
for (res_type, res_id, data) in [
(*b"DLOG", 128, dlog),
(*b"DITL", 128, ditl),
(*b"CNTL", 200, cntl),
(*b"MENU", 300, menu),
] {
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: String::new(),
res_type: u32::from_be_bytes(res_type),
res_id,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
loaded.cpu.gpr[3] = 128;
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.unsupported_import_index, None);
let dialog = loaded.cpu.gpr[3];
let items_handle = loaded
.memory
.read_u32_be(dialog + PPC_DIALOG_ITEMS_OFFSET)
.unwrap();
let items_ptr = loaded.memory.read_u32_be(items_handle).unwrap();
let control_handle = loaded.memory.read_u32_be(items_ptr + 2).unwrap();
let control = loaded.memory.read_u32_be(control_handle).unwrap();
assert_eq!(
ppc_read_rect(&mut loaded.memory, control + PPC_CONTROL_RECT_OFFSET),
Some((38, 226, 58, 326))
);
assert_eq!(loaded.controls.records()[0].popup_menu_id, 300);
assert_eq!(loaded.memory.read_u16_be(control + PPC_CONTROL_VALUE_OFFSET), Some(1));
assert_eq!(loaded.memory.read_u16_be(control + PPC_CONTROL_MIN_OFFSET), Some(1));
assert_eq!(loaded.memory.read_u16_be(control + PPC_CONTROL_MAX_OFFSET), Some(2));
assert_eq!(loaded.controls.records()[0].popup_title_width, Some(0));
assert_eq!(
ppc_popup_control_selected_text(
&mut loaded.memory,
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
300,
2,
),
b"Orange"
);
loaded
.memory
.write_u16_be(control + PPC_CONTROL_VALUE_OFFSET, 1)
.unwrap();
assert!(ppc_track_dialog_popup(
&mut loaded.memory,
&loaded.controls.records(),
&loaded.gworlds,
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
dialog,
(38, 226, 58, 326),
PpcInputSnapshot {
mouse_button: true,
mouse_v: 54,
mouse_h: 250,
..PpcInputSnapshot::default()
},
));
assert_eq!(
loaded
.memory
.read_u16_be(control + PPC_CONTROL_VALUE_OFFSET),
Some(2)
);
// A control placed below its dialog must not draw onto the desktop.
let dialog_bounds =
ppc_dialog_global_bounds(&mut loaded.memory, &loaded.gworlds, dialog).unwrap();
let top = dialog_bounds.2 - dialog_bounds.0 + 10;
ppc_write_rect(
&mut loaded.memory,
control + PPC_CONTROL_RECT_OFFSET,
top, 10, top + 20, 120,
).unwrap();
let front =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap().front_buffer;
let length = front.row_bytes * front.height;
let before = ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, length).unwrap();
let handles = loaded.handles();
ppc_draw_control_inner(
&mut loaded.memory,
&handles,
&loaded.controls.records(),
&loaded.gworlds,
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
control_handle,
true,
);
let after = ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, length).unwrap();
assert!(before == after, "off-dialog popups must be clipped by their owning port");
}
#[test]
fn popup_control_selected_title_reads_live_programmatic_menu_items() {
let mut loaded =
load_pef_application(&synthetic_pef_with_import(b"NewMenu")).unwrap();
install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
305,
b"Theme",
b"Classic;High Contrast;-;Night Operations",
);
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
assert_eq!(
ppc_popup_control_selected_text(
&mut loaded.memory,
&loaded.process_file_system.vfs_resources,
current_resource_refnum,
305,
1,
),
b"Classic"
);
assert_eq!(
ppc_popup_control_selected_text(
&mut loaded.memory,
&loaded.process_file_system.vfs_resources,
current_resource_refnum,
305,
4,
),
b"Night Operations"
);
}
#[test]
fn popup_control_display_title_clips_to_fixed_width() {
let title = b"Night Operations: Deep Field Archive";
let clipped = ppc_popup_control_display_title(
title,
52,
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
);
assert!(clipped.ends_with(b"..."));
assert_ne!(clipped, title);
assert!(
ppc_text_bytes_advance_for_font(
&clipped,
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
) <= 52,
"fixed-width popup title must fit the reserved content width"
);
}
#[test]
fn hle_import_runner_popup_menu_select_tracks_flashes_and_preserves_abi() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
300,
b"Popup",
b"Red;Orange",
);
let front =
ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).expect("main buffer");
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(framebuffer_len).unwrap())
.map(|index| (index as u8).wrapping_mul(37) ^ 0xa5)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
loaded
.memory
.write_u16_be(PPC_THE_MENU_ADDR, 0x2468)
.unwrap();
let menu_bar_len = 20 * front.row_bytes;
let menu_bar_before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_len).unwrap();
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 50;
loaded.cpu.gpr[6] = 2;
let original_sp = loaded.cpu.gpr[1];
let original_args = [loaded.cpu.gpr[4], loaded.cpu.gpr[5], loaded.cpu.gpr[6]];
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 0,
mouse_h: 0,
..PpcInputSnapshot::default()
});
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.cpu.pc, PPC_GUEST_CALL_RETURN_PC);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(loaded.cpu.gpr[3], menu_handle);
assert_eq!(
[loaded.cpu.gpr[4], loaded.cpu.gpr[5], loaded.cpu.gpr[6]],
original_args
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
let parked_lr = loaded.cpu.lr;
assert_eq!(tracking.kind, MenuTrackingKind::PopUp);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_popup(),
Some(MenuTrackingCall {
request: MenuTrackingRequest::PopUp(PopupMenuRequest {
menu_handle,
anchor: (100, 50),
requested_item: 2,
}),
origin: MenuTrackingOrigin::PowerPc { stack_pointer: original_sp, return_address: parked_lr },
})
);
assert_eq!(tracking.popup_left, 50);
assert_eq!(tracking.popup_top + 16, 100);
assert_eq!(tracking.highlighted_item, 2);
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(tracking.popup_left + 4), 100),
),
Some(black),
"requested item did not begin at Top"
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(tracking.popup_left + 4), 99),
),
Some(white),
"row above requested item was also highlighted"
);
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before.clone())
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x2468));
let item_one = PpcInputSnapshot {
mouse_button: true,
mouse_v: tracking.popup_top + 6,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
};
loaded.set_input_snapshot(item_one);
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.cpu.lr, parked_lr);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.highlighted_item,
1
);
let item_two_release = PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 16 + 4,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
};
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 1)
.unwrap();
loaded.set_input_snapshot(item_two_release);
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let flash = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
assert_eq!(flash.flash_remaining, 2);
assert_eq!(flash.highlighted_item, 2);
assert_eq!(flash.flash_result, (300u32 << 16) | 2);
let flash_probe = (
i32::from(tracking.popup_left + 4),
i32::from(tracking.popup_top + 16 + 4),
);
let mut flash_pixels =
vec![ppc_quickdraw_read_pixel(&mut loaded.memory, front, flash_probe).unwrap()];
let mut final_probe = None;
for _ in 0..32 {
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(64);
if loaded.toolbox_startup.execution.menu().is_some() {
flash_pixels.push(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, flash_probe).unwrap(),
);
} else {
final_probe = Some(probe);
break;
}
}
let final_probe = final_probe.expect("popup flash completed");
assert!(matches!(
final_probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.cpu.gpr[3], (300u32 << 16) | 2);
assert!(flash_pixels.contains(&black));
assert!(flash_pixels.contains(&white));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before)
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_len),
Some(menu_bar_before)
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x2468));
}
#[test]
fn hle_import_runner_popup_menu_select_no_hit_paths_are_atomic() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
300,
b"Popup",
b"First;Second",
);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
loaded
.memory
.write_u16_be(PPC_THE_MENU_ADDR, 0x1357)
.unwrap();
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 50;
loaded.cpu.gpr[6] = 1;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_v: 100,
mouse_h: 50,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before)
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x1357));
let mut miss = load_pef_application(&pef).unwrap();
let regular_menu =
install_test_menu(&mut miss, PPC_DATA_BASE + 0x1000, 304, b"Regular", b"First");
let front = ppc_front_buffer_for_gworld(&miss.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut miss.memory, front.base_addr, framebuffer_len).unwrap();
for (label, menu_handle) in [
("invalid handle", 0xdead_beef),
("menu outside hierarchical list", regular_menu),
] {
miss.cpu.pc = miss.entry_pc;
miss.cpu.lr = PPC_HALT_PC;
miss.cpu.gpr[3] = menu_handle;
miss.cpu.gpr[4] = 100;
miss.cpu.gpr[5] = 50;
miss.cpu.gpr[6] = 1;
miss.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 100,
mouse_h: 50,
..PpcInputSnapshot::default()
});
let probe = miss.run_with_hle_imports(64);
assert!(
matches!(probe.result, PpcRunResult::Halted { .. }),
"{label}"
);
assert_eq!(miss.cpu.gpr[3], 0, "{label}");
assert!(miss.toolbox_startup.execution.menu().is_none(), "{label}");
assert_eq!(
ppc_memory_read_bytes(&mut miss.memory, front.base_addr, framebuffer_len),
Some(before.clone()),
"{label}"
);
}
for (label, item_specs) in [
("disabled item", b"First;Disabled(".as_slice()),
("separator", b"First;-".as_slice()),
] {
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
301,
b"Popup",
item_specs,
);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
loaded
.memory
.write_u16_be(PPC_THE_MENU_ADDR, 0x1357)
.unwrap();
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 50;
loaded.cpu.gpr[6] = 1;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 0,
mouse_h: 0,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 16 + 4,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(
matches!(probe.result, PpcRunResult::Halted { .. }),
"{label}"
);
assert_eq!(loaded.cpu.gpr[3], 0, "{label}");
assert!(loaded.toolbox_startup.execution.menu().is_none(), "{label}");
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before),
"{label}"
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x1357));
}
}
#[test]
fn hle_import_runner_popup_menu_select_round_trips_supported_depths_and_clamps() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
302,
b"Popup",
b"One;Two;Three",
);
loaded.toolbox_startup.host_menu_bar_hidden = true;
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(framebuffer_len).unwrap())
.map(|index| (index as u8).wrapping_mul(29).wrapping_add(depth as u8) ^ 0x96)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
loaded
.memory
.write_u16_be(PPC_THE_MENU_ADDR, 0x55aa)
.unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::PopUpMenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = i16::MAX as u32;
loaded.cpu.gpr[5] = i16::MAX as u32;
loaded.cpu.gpr[6] = 3;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 0,
mouse_h: 0,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(tracking.kind, MenuTrackingKind::PopUp);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_popup(),
Some(ppc_popup_menu_call(&loaded.cpu))
);
assert_eq!(
i32::from(tracking.popup_left) + i32::from(tracking.saved_width),
i32::try_from(front.width).unwrap() - 3,
"{depth}bpp popup did not clamp its right shadow to the screen"
);
assert_eq!(
i32::from(tracking.popup_top) + i32::from(tracking.saved_height),
i32::try_from(front.height).unwrap(),
"{depth}bpp popup did not clamp its shadow to the screen"
);
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(pattern.clone()),
"{depth}bpp popup did not draw"
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 4,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(pattern),
"{depth}bpp popup did not restore framebuffer and row padding"
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x55aa));
}
}
#[test]
fn hle_import_runner_popup_menu_select_tracks_oversized_content_from_shared_layout() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let description = (0..40).map(|_| "A").collect::<Vec<_>>().join(";");
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
303,
b"Popup",
description.as_bytes(),
);
loaded.toolbox_startup.host_menu_bar_hidden = true;
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 120;
loaded.cpu.gpr[6] = 20;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 100,
mouse_h: 124,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
assert_eq!(tracking.popup_top, 4);
assert_eq!(tracking.popup_height, 576);
assert_eq!(tracking.content_top, -204);
assert_eq!(tracking.highlighted_item, 20);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::TOP_MENU_ITEM)
.map(|value| value as i16),
Some(-204),
);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::AT_MENU_BOTTOM)
.map(|value| value as i16),
Some(436),
);
let indicator_point = (
i32::from(tracking.popup_left + tracking.popup_width / 2),
i32::from(tracking.popup_top + 4),
);
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, indicator_point),
Some(black),
"the hidden upper content must replace the first visible row with an indicator"
);
assert_eq!(
ppc_menu_tracking_item(
&mut loaded.memory,
tracking,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 100,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
},
),
20,
);
let popup_left = tracking.popup_left;
for (mouse_v, expected_item, expected_top, expected_bottom) in [
(28, 15, -204, 436),
(12, 0, -204, 436),
(12, 0, -188, 452),
(3, 0, -172, 468),
] {
let action = ppc_dispatch_pop_up_menu_select(
&loaded.cpu,
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_button: true,
mouse_v,
mouse_h: popup_left + 4,
..PpcInputSnapshot::default()
},
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
);
assert!(matches!(action, PpcImportAction::Yield(_)));
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
assert_eq!(tracking.highlighted_item, expected_item);
assert_eq!(tracking.content_top, expected_top);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::AT_MENU_BOTTOM)
.map(|value| value as i16),
Some(expected_bottom),
);
}
}
pub(crate) fn native_menu_hook_fixture() -> (PpcLoadedApp, u32, u32) {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Open;Close",
);
let menu_record = loaded.memory.read_u32_be(menu).unwrap();
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let marker = PPC_DATA_BASE + 0x7400;
loaded.memory.add_region(marker, vec![0; 4]);
let mut set_port = compatibility_binding(
"InterfaceLib",
"SetPort",
PpcImportDispatcherTarget::SetPort,
);
set_port.symbol_index = 1;
set_port.trap_pc = PPC_IMPORT_TRAP_BASE + 4;
loaded
.memory
.add_region(PPC_IMPORT_TRAP_BASE + 4, vec![0; 4]);
loaded.imports.push(set_port);
loaded.import_count = 2;
let callback_entry = PPC_CODE_BASE + 0x4000;
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(PPC_PROCINFO_SIZE_NONE, &[]),
&[
0x7fe8_02a6,
d_form_u(15, 3, 0, (PPC_DSP_BACK_GWORLD >> 16) as u16),
d_form_u(24, 3, 3, PPC_DSP_BACK_GWORLD as u16),
0x4800_0000
| ((PPC_IMPORT_TRAP_BASE + 4).wrapping_sub(callback_entry + 3 * 4)
& 0x03ff_fffc)
| 1,
0x7fe8_03a6,
d_form_u(15, 7, 0, (menu_record >> 16) as u16),
d_form_u(24, 7, 7, menu_record as u16),
d_form_u(40, 10, 7, 2),
d_form_u(14, 10, 10, 1),
d_form_u(44, 10, 7, 2),
d_form_u(15, 8, 0, (marker >> 16) as u16),
d_form_u(24, 8, 8, marker as u16),
d_form_u(32, 9, 8, 0),
d_form_u(14, 9, 9, 1),
d_form_u(36, 9, 8, 0),
d_form_u(14, 3, 0, 77),
BLR,
],
);
loaded.memory.write_u32_be(0x0a30, descriptor).unwrap();
(loaded, marker, menu_record)
}
#[test]
fn native_menu_tracking_invokes_menu_hook_while_held() {
let (mut loaded, marker, menu_record) = native_menu_hook_fixture();
let original_menu_width = loaded.memory.read_u16_be(menu_record + 2).unwrap();
let original_sp = loaded.cpu.gpr[1];
let original_return = loaded.cpu.lr;
let original_port = (*loaded.current_gworld, *loaded.current_gdevice);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
let initial_point =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
loaded.cpu.gpr[3] = initial_point;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..4 {
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert!(loaded.toolbox_startup.execution.menu().is_some());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_port,
Some(original_port),
);
assert_eq!(*loaded.current_gworld, PPC_DSP_BACK_GWORLD);
assert_ne!(
(*loaded.current_gworld, *loaded.current_gdevice),
original_port
);
assert!(
loaded.memory.read_u32_be(marker).unwrap() > 0,
"MenuSelect must invoke MenuHook while held"
);
assert!(loaded.memory.read_u16_be(menu_record + 2).unwrap() > original_menu_width);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..8 {
let probe = loaded.run_with_hle_imports(128);
if matches!(probe.result, PpcRunResult::Halted { .. }) {
break;
}
}
assert_eq!(loaded.cpu.pc, original_return);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
assert_eq!(
(*loaded.current_gworld, *loaded.current_gdevice),
original_port
);
assert!(loaded.guest_calls().is_empty());
assert!(loaded.toolbox_startup.execution.menu().is_none());
}
#[test]
fn refused_native_menu_hook_leaves_no_receipt_or_port_and_retries() {
let (mut loaded, marker, _) = native_menu_hook_fixture();
let descriptor = loaded.memory.read_u32_be(0x0a30).unwrap();
loaded.memory.write_u32_be(0x0a30, 0).unwrap();
loaded.cpu.gpr[3] =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.guest_calls().depth(), 0);
assert_eq!(loaded.toolbox_startup.execution.menu().menu_hook_key(), None);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_port,
None
);
assert_eq!(loaded.memory.read_u32_be(marker), Some(0));
loaded.memory.write_u32_be(0x0a30, descriptor).unwrap();
loaded
.memory
.write_u32_be(descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE, 1)
.unwrap();
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.guest_calls().depth(), 0);
assert_eq!(loaded.toolbox_startup.execution.menu().menu_hook_key(), None);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_port,
None
);
assert_eq!(loaded.memory.read_u32_be(marker), Some(0));
loaded
.memory
.write_u32_be(descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE, 0)
.unwrap();
for _ in 0..4 {
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert!(loaded.memory.read_u32_be(marker).unwrap() > 0);
assert!(loaded
.toolbox_startup
.execution.menu()
.context()
.native_port
.is_some());
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 500,
mouse_h: 500,
..PpcInputSnapshot::default()
});
for _ in 0..8 {
if matches!(
loaded.run_with_hle_imports(128).result,
PpcRunResult::Halted { .. }
) {
break;
}
}
assert!(loaded.guest_calls().is_empty());
assert!(loaded.toolbox_startup.execution.menu().is_none());
}
#[test]
fn native_menu_hook_host_selection_restores_port_and_retires_its_root() {
let (mut loaded, marker, _) = native_menu_hook_fixture();
let original_port = (*loaded.current_gworld, *loaded.current_gdevice);
loaded.cpu.gpr[3] =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..4 {
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert!(loaded.memory.read_u32_be(marker).unwrap() > 0);
assert!(loaded
.toolbox_startup
.pending_native_menu_selection
.stage((128, 1)));
for _ in 0..8 {
if matches!(
loaded.run_with_hle_imports(128).result,
PpcRunResult::Halted { .. }
) {
break;
}
}
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
assert_eq!(
(*loaded.current_gworld, *loaded.current_gdevice),
original_port
);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert!(loaded.guest_calls().is_empty());
}
#[test]
fn native_menu_hook_flash_completion_restores_port_and_retires_its_root() {
let (mut loaded, marker, _) = native_menu_hook_fixture();
let original_port = (*loaded.current_gworld, *loaded.current_gdevice);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 1)
.unwrap();
loaded.cpu.gpr[3] =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..4 {
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert!(loaded.memory.read_u32_be(marker).unwrap() > 0);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let flash_start = loaded.current_tick();
for elapsed in 0..16 {
loaded.set_tick_count(flash_start.wrapping_add(elapsed));
if matches!(
loaded.run_with_hle_imports(128).result,
PpcRunResult::Halted { .. }
) {
break;
}
}
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
assert_eq!(
(*loaded.current_gworld, *loaded.current_gdevice),
original_port
);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert!(loaded.guest_calls().is_empty());
}
#[test]
fn native_menu_wait_resumes_without_repeating_public_import() {
for popup in [false, true] {
let symbol: &[u8] = if popup {
b"PopUpMenuSelect"
} else {
b"MenuSelect"
};
let pef = synthetic_pef_with_import(symbol);
let mut loaded = load_pef_application(&pef).unwrap();
let install = if popup { install_test_popup_menu } else { install_test_menu };
let menu = install(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Open;Close",
);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
loaded.cpu.lr = PPC_HALT_PC;
let original_sp = loaded.cpu.gpr[1];
loaded.cpu.gpr[3] =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
if popup {
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 20;
loaded.cpu.gpr[5] = 12;
loaded.cpu.gpr[6] = 1;
}
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let first = loaded.run_with_hle_imports(64);
assert_eq!(first.handled_import_count, 1);
assert!(loaded.toolbox_startup.execution.menu().is_some(), "popup={popup}, result={:?}, r3={:08x}", first.result, loaded.cpu.gpr[3]);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let pointer = (tracking.popup_top + 4, tracking.popup_left + 4);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: pointer.0,
mouse_h: pointer.1,
..PpcInputSnapshot::default()
});
let waiting = loaded.run_with_hle_imports(64);
assert_eq!(
waiting.handled_import_count, 0,
"waiting resumes the operation, not its public import"
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: pointer.0,
mouse_h: pointer.1,
..PpcInputSnapshot::default()
});
let released = loaded.run_with_hle_imports(64);
assert_eq!(released.handled_import_count, 0);
assert_eq!(loaded.cpu.pc, PPC_HALT_PC);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert!(loaded.guest_calls().is_empty());
// Returning to the public gateway is a new call and is counted again.
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = if popup {
menu
} else {
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16)
};
let fresh = loaded.run_with_hle_imports(64);
assert_eq!(fresh.handled_import_count, 1);
}
}
#[test]
fn hle_import_runner_menu_select_initial_release_uses_retained_rows() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Icon row;Second",
);
let icon = ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 0).unwrap();
loaded.memory.write_u8(icon, 1).unwrap();
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
let title_left = STANDARD_MENU_BAR_FIRST_TITLE_LEFT;
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let expected =
ppc_begin_menu_bar_tracking(&mut loaded.memory, front, menu, title_left).unwrap();
assert_eq!(expected.item_appearances[0].height, 34);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = (10u32 << 16) | u32::from((title_left + 2) as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: expected.popup_top + 20,
mouse_h: expected.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], (128u32 << 16) | 1);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
}
#[test]
fn hle_import_runner_menu_select_switches_titles_and_restores_supported_depths() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let file_menu =
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
let edit_menu =
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1400, 129, b"Edit", b"Cut");
let disabled_menu =
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1800, 130, b"View", b"Zoom");
ppc_set_menu_item_enabled(
&mut loaded.memory,
&test_handle_records!(loaded),
disabled_menu,
0,
false,
);
let file_left = STANDARD_MENU_BAR_FIRST_TITLE_LEFT;
let edit_left = file_left
.saturating_add(standard_menu_title_advance(b"File"))
.saturating_add(STANDARD_MENU_BAR_TITLE_SPACING);
let disabled_left = edit_left
.saturating_add(standard_menu_title_advance(b"Edit"))
.saturating_add(STANDARD_MENU_BAR_TITLE_SPACING);
let point = |v: i16, h: i16| (u32::from(v as u16) << 16) | u32::from(h as u16);
let menu_list = ppc_current_menu_list(&mut loaded.memory);
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list, point(10, edit_left + 2),),
Some((edit_menu, edit_left)),
);
assert_eq!(
ppc_menu_handle_at_title_point(
&mut loaded.memory,
menu_list,
point(10, disabled_left + 2),
),
Some((disabled_menu, disabled_left)),
"a disabled title remains available for examination",
);
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(framebuffer_len).unwrap())
.map(|index| (index as u8).wrapping_mul(31).wrapping_add(depth as u8) ^ 0x6d)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = point(10, file_left + 2);
let original_sp = loaded.cpu.gpr[1];
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: file_left + 2,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.menu_handle),
Some(file_menu),
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: edit_left + 2,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.menu_handle),
Some(edit_menu),
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(129));
for (mouse_h, expected_menu, expected_id) in [
(file_left + 2, file_menu, 128),
(edit_left + 2, edit_menu, 129),
] {
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.menu_handle),
Some(expected_menu),
);
assert_eq!(
loaded.memory.read_u16_be(PPC_THE_MENU_ADDR),
Some(expected_id),
);
}
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: disabled_left + 2,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.menu_handle),
Some(disabled_menu),
"{depth}bpp disabled title did not open",
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(130));
let disabled_tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(
disabled_tracking.highlighted_item, 0,
"{depth}bpp disabled menu item became highlighted",
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: disabled_tracking.popup_top + 8,
mouse_h: disabled_tracking.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_DISABLE),
Some(menu_choice_value(130, 1)),
"{depth}bpp disabled menu did not expose its raw hovered row",
);
loaded.cpu.gpr[3] = 0xDEAD_BEEF;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuChoice);
assert_eq!(
loaded.cpu.gpr[3],
menu_choice_value(130, 1),
"{depth}bpp MenuChoice did not return the disabled menu row",
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before),
"{depth}bpp switched dropdowns did not restore the framebuffer",
);
}
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = point(10, file_left + 2);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: file_left + 2,
..PpcInputSnapshot::default()
});
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: edit_left + 2,
..PpcInputSnapshot::default()
});
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
let switched = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 1)
.unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: switched.popup_top + 6,
mouse_h: switched.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.flash_remaining),
Some(2)
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 0,
mouse_h: 0,
..PpcInputSnapshot::default()
});
loaded
.toolbox_startup
.execution
.with_menu_state_mut(|state| state.flash_deadline = state.flash_tick.unwrap_or(0))
.unwrap();
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
loaded
.toolbox_startup
.execution
.with_menu_state_mut(|state| state.flash_deadline = state.flash_tick.unwrap_or(0))
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], (129u32 << 16) | 1);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(129));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = point(10, file_left + 2);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: file_left + 2,
..PpcInputSnapshot::default()
});
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 6,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], (128u32 << 16) | 1);
assert!(loaded.toolbox_startup.execution.menu().is_none());
}
#[test]
fn hle_import_runner_handles_get_dialog_item_outputs() {
let pef = synthetic_pef_with_import(b"GetDialogItem");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let item_type_ptr = scratch;
let item_handle_ptr = scratch + 4;
let item_rect_ptr = scratch + 8;
loaded.memory.add_region(scratch, vec![0xaa; 32]);
let text_handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
b"Hello",
);
let mut ditl = vec![0; 22];
ditl[2..6].copy_from_slice(&text_handle.to_be_bytes());
ditl[6..8].copy_from_slice(&10i16.to_be_bytes());
ditl[8..10].copy_from_slice(&10i16.to_be_bytes());
ditl[10..12].copy_from_slice(&26i16.to_be_bytes());
ditl[12..14].copy_from_slice(&220i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_STATIC_TEXT;
ditl[15] = 5;
ditl[16..21].copy_from_slice(b"Hello");
let items_handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&ditl,
);
let dialog = PPC_HEAP_BASE + 0x1000;
loaded
.memory
.write_u32_be(dialog + PPC_DIALOG_ITEMS_OFFSET, items_handle)
.unwrap();
loaded.cpu.gpr[3] = dialog;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = item_type_ptr;
loaded.cpu.gpr[6] = item_handle_ptr;
loaded.cpu.gpr[7] = item_rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], dialog);
assert_eq!(
loaded.memory.read_u16_be(item_type_ptr),
Some(u16::from(PPC_DIALOG_ITEM_STATIC_TEXT))
);
assert_eq!(
loaded.memory.read_u32_be(item_handle_ptr),
Some(text_handle)
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, item_rect_ptr),
Some((10, 10, 26, 220))
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn hle_import_runner_get_dialog_item_outputs_are_all_or_nothing() {
let pef = synthetic_pef_with_import(b"GetDialogItem");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let item_type_ptr = scratch;
let item_handle_ptr = scratch + 4;
let item_rect_ptr = scratch + 8;
loaded.memory.add_region(scratch, vec![0xee; 12]);
loaded.set_last_mem_error(PPC_MEM_FULL_ERR);
let heap_cursor = loaded.heap_cursor();
loaded.cpu.gpr[3] = PPC_HEAP_BASE + 0x100;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = item_type_ptr;
loaded.cpu.gpr[6] = item_handle_ptr;
loaded.cpu.gpr[7] = item_rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(item_type_ptr), Some(0xeeee));
assert_eq!(
loaded.memory.read_u32_be(item_handle_ptr),
Some(0xeeee_eeee)
);
assert_eq!(loaded.memory.read_u32_be(item_rect_ptr), Some(0xeeee_eeee));
assert_eq!(test_handle_records!(loaded).len(), 0);
assert_eq!(loaded.heap_cursor(), heap_cursor);
assert_eq!(loaded.last_mem_error(), PPC_MEM_FULL_ERR);
let pef = synthetic_pef_with_import(b"ModalDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let item_hit_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(item_hit_ptr, vec![0xab; 1]);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = item_hit_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(item_hit_ptr), Some(0xab));
}
#[test]
fn hle_import_runner_handles_dialog_text_and_modal_defaults() {
let pef = synthetic_pef_with_import(b"GetDialogItemText");
let mut loaded = load_pef_application(&pef).unwrap();
let text_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(text_ptr, vec![0xaa; 256]);
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
loaded.cpu.gpr[4] = text_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE);
assert_eq!(loaded.memory.read_u8(text_ptr), Some(0));
let pef = synthetic_pef_with_import(b"SetDialogItemText");
let mut loaded = load_pef_application(&pef).unwrap();
let text_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(text_ptr, vec![0; 256]);
write_ppc_pstring(&mut loaded.memory, text_ptr, b"Gridz");
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
b"old",
);
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = text_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], handle);
assert_eq!(
ppc_handle_bytes(&mut loaded.memory, &test_handle_records!(loaded), handle),
Some(b"Gridz".to_vec())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let pef = synthetic_pef_with_import(b"ModalDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let item_hit_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(item_hit_ptr, vec![0; 2]);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = item_hit_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(item_hit_ptr), Some(0));
assert!(matches!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
}
#[test]
fn hle_import_runner_creates_and_disposes_native_styled_textedit_records() {
let pef = synthetic_pef_with_import(b"TEStyleNew");
let mut loaded = load_pef_application(&pef).unwrap();
let rects = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rects, vec![0; 16]);
for (offset, value) in [10u16, 20, 110, 220].into_iter().enumerate() {
loaded
.memory
.write_u16_be(rects + offset as u32 * 2, value)
.unwrap();
}
for (offset, value) in [12u16, 22, 108, 218].into_iter().enumerate() {
loaded
.memory
.write_u16_be(rects + 8 + offset as u32 * 2, value)
.unwrap();
}
loaded.cpu.gpr[3] = rects;
loaded.cpu.gpr[4] = rects + 8;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let te_handle = loaded.cpu.gpr[3];
let te_ptr = loaded.memory.read_u32_be(te_handle).unwrap();
assert_ne!(te_handle, 0);
assert_eq!(
ppc_te_read_rect(&mut loaded.memory, te_ptr + PPC_TE_DEST_RECT_OFFSET),
Some([10, 20, 110, 220])
);
assert_eq!(
ppc_te_read_rect(&mut loaded.memory, te_ptr + PPC_TE_VIEW_RECT_OFFSET),
Some([12, 22, 108, 218])
);
assert_eq!(
loaded
.memory
.read_u16_be(te_ptr + PPC_TE_LINE_HEIGHT_OFFSET),
Some(0xffff)
);
assert_eq!(
loaded
.memory
.read_u16_be(te_ptr + PPC_TE_FONT_ASCENT_OFFSET),
Some(0xffff)
);
assert_eq!(
loaded.memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET),
Some(0xffff)
);
let text_handle = loaded
.memory
.read_u32_be(te_ptr + PPC_TE_HTEXT_OFFSET)
.unwrap();
let style_handle = loaded
.memory
.read_u32_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap();
assert_ne!(text_handle, 0);
assert_ne!(style_handle, 0);
assert_eq!(test_handle_records!(loaded).len(), 7);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::TEGetText;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = te_handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], text_handle);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::TEDispose;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = te_handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.memory.read_u32_be(te_handle), Some(0));
assert!(test_handle_records!(loaded).is_empty());
}
#[test]
fn te_use_style_scrap_applies_the_first_scrap_style_to_the_requested_range() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"TEStyleNew")).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 0x100]);
ppc_write_rect(&mut loaded.memory, scratch, 10, 20, 80, 220).unwrap();
ppc_write_rect(&mut loaded.memory, scratch + 8, 10, 20, 80, 220).unwrap();
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = scratch + 8;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TEStyleNew);
let te_handle = loaded.cpu.gpr[3];
loaded.memory.write_bytes(scratch + 0x20, b"Styled").unwrap();
loaded.cpu.gpr[3] = scratch + 0x20;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetText);
loaded.cpu.gpr[3] = 22;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::NewHandle { clear: true },
);
let scrap_handle = loaded.cpu.gpr[3];
let scrap_ptr = loaded.memory.read_u32_be(scrap_handle).unwrap();
let element = scrap_ptr + PPC_TE_SCRAP_STYLE_TAB_OFFSET;
loaded
.memory
.write_u16_be(scrap_ptr + PPC_TE_SCRAP_N_STYLES_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u16_be(element + PPC_TE_SCRAP_STYLE_FONT_OFFSET, 4)
.unwrap();
loaded
.memory
.write_u8(element + PPC_TE_SCRAP_STYLE_FACE_OFFSET, 0x04)
.unwrap();
loaded
.memory
.write_u16_be(element + PPC_TE_SCRAP_STYLE_SIZE_OFFSET, 11)
.unwrap();
loaded
.memory
.write_u16_be(element + PPC_TE_SCRAP_STYLE_COLOR_OFFSET + 2, 0xffff)
.unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 3;
loaded.cpu.gpr[5] = scrap_handle;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TEUseStyleScrap);
let runs = ppc_te_style_runs(
&mut loaded.memory,
&test_handle_records!(loaded),
te_handle,
6,
);
assert_eq!(runs[0].start, 0);
assert_eq!(runs[0].style.font, 4);
assert_eq!(runs[0].style.face, 0x04);
assert_eq!(runs[0].style.size, 11);
assert_eq!(runs[0].style.color.green, 0xffff);
assert_eq!(runs[1].start, 3);
}
#[test]
fn native_styled_textedit_styles_runs_and_reports_real_measurements() {
let pef = synthetic_pef_with_import(b"TEStyleNew");
let mut loaded = load_pef_application(&pef).unwrap();
let rects = PPC_DATA_BASE + 0x1000;
let text_ptr = PPC_DATA_BASE + 0x1020;
let style_ptr = PPC_DATA_BASE + 0x1040;
let mode_ptr = PPC_DATA_BASE + 0x1060;
let result_style_ptr = PPC_DATA_BASE + 0x1064;
let locations_ptr = PPC_DATA_BASE + 0x1080;
let name_ptr = PPC_DATA_BASE + 0x10a0;
loaded
.memory
.add_region(PPC_DATA_BASE + 0x1000, vec![0; 0x100]);
ppc_write_rect(&mut loaded.memory, rects, 10, 20, 80, 220).unwrap();
ppc_write_rect(&mut loaded.memory, rects + 8, 10, 20, 80, 220).unwrap();
loaded.cpu.gpr[3] = rects;
loaded.cpu.gpr[4] = rects + 8;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TEStyleNew);
let te_handle = loaded.cpu.gpr[3];
let constructor_te_ptr = loaded.memory.read_u32_be(te_handle).unwrap();
let style_handle = loaded
.memory
.read_u32_be(constructor_te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap();
loaded.memory.write_bytes(text_ptr, b"Styled").unwrap();
loaded.cpu.gpr[3] = text_ptr;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetText);
let write_style =
|memory: &mut PpcSectionMem, font: i16, face: u8, size: i16, color: PpcRgbColor| {
memory.write_u16_be(style_ptr, font as u16).unwrap();
memory.write_u8(style_ptr + 2, face).unwrap();
memory.write_u16_be(style_ptr + 4, size as u16).unwrap();
memory.write_u16_be(style_ptr + 6, color.red).unwrap();
memory.write_u16_be(style_ptr + 8, color.green).unwrap();
memory.write_u16_be(style_ptr + 10, color.blue).unwrap();
};
write_style(
&mut loaded.memory,
3,
0x01,
14,
PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
},
);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 3;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetSelect);
loaded.cpu.gpr[3] = 0x000f;
loaded.cpu.gpr[4] = style_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetStyle);
write_style(
&mut loaded.memory,
4,
0x02,
10,
PpcRgbColor {
red: 0,
green: 0,
blue: 0xffff,
},
);
loaded.cpu.gpr[3] = 3;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetSelect);
loaded.cpu.gpr[3] = 0x000f;
loaded.cpu.gpr[4] = style_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetStyle);
let runs = ppc_te_style_runs(
&mut loaded.memory,
&test_handle_records!(loaded),
te_handle,
6,
);
assert_eq!(
runs.iter().map(|run| run.start).collect::<Vec<_>>(),
vec![0, 3]
);
assert_eq!(runs[0].style.font, 3);
assert_eq!(runs[0].style.face, 0x01);
assert_eq!(runs[0].style.size, 14);
assert_eq!(runs[0].style.color.red, 0xffff);
assert_eq!(runs[1].style.font, 4);
assert_eq!(runs[1].style.face, 0x02);
assert_eq!(runs[1].style.size, 10);
assert_eq!(runs[1].style.color.blue, 0xffff);
loaded.cpu.gpr[3] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TECalText);
let te_ptr = loaded.memory.read_u32_be(te_handle).unwrap();
let n_lines = usize::from(
loaded
.memory
.read_u16_be(te_ptr + PPC_TE_N_LINES_OFFSET)
.unwrap(),
);
assert!(n_lines > 0);
assert_eq!(
loaded
.memory
.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + n_lines as u32 * 2),
Some(6)
);
assert_eq!(
loaded.memory.read_u16_be(
te_ptr + PPC_TE_LINE_STARTS_OFFSET + n_lines.saturating_add(1) as u32 * 2,
),
Some(0)
);
let style_record_ptr = loaded.memory.read_u32_be(style_handle).unwrap();
let n_runs = usize::from(
loaded
.memory
.read_u16_be(style_record_ptr + PPC_TE_STYLE_N_RUNS_OFFSET)
.unwrap(),
);
assert_eq!(
loaded.memory.read_u16_be(
style_record_ptr + PPC_TE_STYLE_RUNS_OFFSET + n_runs as u32 * 4,
),
Some(7)
);
let lh_handle = loaded
.memory
.read_u32_be(style_record_ptr + PPC_TE_STYLE_LH_TABLE_OFFSET)
.unwrap();
let handle_records = test_handle_records!(loaded);
let lh_record = handle_records
.iter()
.find(|record| record.handle == lh_handle)
.unwrap();
assert!(lh_record.size >= (n_lines.saturating_add(1) * 4) as u32);
let lh_ptr = loaded.memory.read_u32_be(lh_handle).unwrap();
assert!(loaded.memory.read_u16_be(lh_ptr + n_lines as u32 * 4).unwrap() > 0);
// Text 1993, p. 2-102: a mixed face selection reports the bits
// common to every face, so bold plus bold-italic reports bold.
write_style(
&mut loaded.memory,
4,
0x03,
10,
PpcRgbColor {
red: 0,
green: 0,
blue: 0xffff,
},
);
loaded.cpu.gpr[3] = 3;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetSelect);
loaded.cpu.gpr[3] = 0x0002;
loaded.cpu.gpr[4] = style_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetStyle);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetSelect);
loaded.memory.write_u16_be(mode_ptr, 0x0002).unwrap();
loaded.cpu.gpr[3] = mode_ptr;
loaded.cpu.gpr[4] = result_style_ptr;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TEContinuousStyle);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u16_be(mode_ptr), Some(0x0002));
assert_eq!(loaded.memory.read_u8(result_style_ptr + 2), Some(0x01));
// TESetStyle at an insertion point updates the null scrap used by
// later TEInsert/TEStyleInsert calls instead of changing no runs.
write_style(
&mut loaded.memory,
4,
0x04,
11,
PpcRgbColor {
red: 0,
green: 0xffff,
blue: 0,
},
);
loaded.cpu.gpr[3] = 3;
loaded.cpu.gpr[4] = 3;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetSelect);
loaded.cpu.gpr[3] = 0x000f;
loaded.cpu.gpr[4] = style_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetStyle);
let style_record_ptr = loaded.memory.read_u32_be(style_handle).unwrap();
let null_style_handle = loaded
.memory
.read_u32_be(style_record_ptr + PPC_TE_STYLE_NULL_STYLE_OFFSET)
.unwrap();
let null_style_ptr = loaded.memory.read_u32_be(null_style_handle).unwrap();
let null_scrap_handle = loaded
.memory
.read_u32_be(null_style_ptr + PPC_TE_NULL_STYLE_SCRAP_OFFSET)
.unwrap();
let null_scrap_ptr = loaded.memory.read_u32_be(null_scrap_handle).unwrap();
let null_element = null_scrap_ptr + PPC_TE_SCRAP_STYLE_TAB_OFFSET;
assert_eq!(
loaded
.memory
.read_u16_be(null_scrap_ptr + PPC_TE_SCRAP_N_STYLES_OFFSET),
Some(1)
);
assert_eq!(
loaded
.memory
.read_u16_be(null_element + PPC_TE_SCRAP_STYLE_FONT_OFFSET),
Some(4)
);
assert_eq!(
loaded
.memory
.read_u8(null_element + PPC_TE_SCRAP_STYLE_FACE_OFFSET),
Some(0x04)
);
assert_eq!(
loaded
.memory
.read_u16_be(null_element + PPC_TE_SCRAP_STYLE_SIZE_OFFSET),
Some(11)
);
assert_eq!(
loaded
.memory
.read_u16_be(null_element + PPC_TE_SCRAP_STYLE_COLOR_OFFSET + 2),
Some(0xffff)
);
loaded.memory.write_u16_be(mode_ptr, 0x000f).unwrap();
loaded.cpu.gpr[3] = mode_ptr;
loaded.cpu.gpr[4] = result_style_ptr;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TEContinuousStyle);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u16_be(mode_ptr), Some(0x000f));
assert_eq!(loaded.memory.read_u8(result_style_ptr + 2), Some(0x04));
assert_eq!(loaded.memory.read_u16_be(result_style_ptr + 4), Some(11));
loaded.memory.write_u16_be(mode_ptr, 0x000f).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 6;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetSelect);
loaded.cpu.gpr[3] = mode_ptr;
loaded.cpu.gpr[4] = result_style_ptr;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TEContinuousStyle);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u16_be(mode_ptr), Some(0x0002));
loaded.memory.write_u16_be(mode_ptr, 0x000f).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 3;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TESetSelect);
loaded.cpu.gpr[3] = mode_ptr;
loaded.cpu.gpr[4] = result_style_ptr;
loaded.cpu.gpr[5] = te_handle;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TEContinuousStyle);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u16_be(mode_ptr), Some(0x000f));
assert_eq!(loaded.memory.read_u16_be(result_style_ptr + 4), Some(14));
loaded.cpu.gpr[3] = 3;
loaded.cpu.gpr[4] = 10;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TextSize);
loaded.cpu.gpr[3] = 6;
loaded.cpu.gpr[4] = text_ptr;
loaded.cpu.gpr[5] = locations_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MeasureText);
let measure_width = loaded.memory.read_u16_be(locations_ptr + 12).unwrap();
assert!(measure_width > 0);
loaded.cpu.gpr[3] = text_ptr;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 6;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TextWidth);
let text_width = loaded.cpu.gpr[3];
assert!(text_width > 0);
assert!((text_width as i32 - measure_width as i32).abs() <= 6);
write_ppc_pstring(&mut loaded.memory, name_ptr, b"Geneva");
loaded.cpu.gpr[3] = name_ptr;
loaded.cpu.gpr[4] = result_style_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetFNum);
assert_eq!(loaded.memory.read_u16_be(result_style_ptr), Some(3));
loaded.cpu.gpr[3] = 3;
loaded.cpu.gpr[4] = 9;
run_test_import(&mut loaded, PpcImportDispatcherTarget::RealFont);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 12;
run_test_import(&mut loaded, PpcImportDispatcherTarget::RealFont);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = 12;
run_test_import(&mut loaded, PpcImportDispatcherTarget::RealFont);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn native_textedit_key_and_click_update_the_public_edit_record() {
let pef = synthetic_pef_with_import(b"TEKey");
let mut loaded = load_pef_application(&pef).unwrap();
let rects = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rects, vec![0; 16]);
ppc_write_rect(&mut loaded.memory, rects, 10, 20, 80, 220).unwrap();
ppc_write_rect(&mut loaded.memory, rects + 8, 10, 20, 80, 220).unwrap();
let mut last_mem_error = PPC_NO_ERR;
let te_handle = ppc_te_initialize_record(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
rects,
rects + 8,
PPC_MAIN_GWORLD,
1,
PPC_QD_TEXT_MODE_SRC_OR,
12,
PpcRgbColor {
red: 0,
green: 0,
blue: 0,
},
false,
);
assert_eq!(
ppc_te_set_text(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
te_handle,
b"abc",
),
PPC_NO_ERR
);
loaded.cpu.gpr[3] = 0x08;
loaded.cpu.gpr[4] = te_handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_te_text_bytes(&mut loaded.memory, &test_handle_records!(loaded), te_handle),
Some(b"ab".to_vec())
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = u32::from(b'Z');
loaded.run_with_hle_imports(64);
assert_eq!(
ppc_te_text_bytes(&mut loaded.memory, &test_handle_records!(loaded), te_handle),
Some(b"abZ".to_vec())
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0x1c;
loaded.run_with_hle_imports(64);
let te_ptr = loaded.memory.read_u32_be(te_handle).unwrap();
assert_eq!(
loaded.memory.read_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET),
Some(2)
);
assert_eq!(
loaded.memory.read_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET),
Some(2)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0x1d;
loaded.run_with_hle_imports(64);
assert_eq!(
loaded.memory.read_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET),
Some(3)
);
assert_eq!(
ppc_te_text_bytes(&mut loaded.memory, &test_handle_records!(loaded), te_handle),
Some(b"abZ".to_vec())
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::TEClick;
loaded.set_tick_count(100);
loaded.cpu.gpr[3] = (12u32 << 16) | 20;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = te_handle;
loaded.run_with_hle_imports(64);
assert_eq!(
loaded.memory.read_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET),
Some(0)
);
assert_eq!(
loaded.memory.read_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET),
Some(0)
);
let click_time = loaded
.memory
.read_u32_be(te_ptr + PPC_TE_CLICK_TIME_OFFSET)
.unwrap();
assert!((100..=164).contains(&click_time));
}
#[test]
fn native_textedit_line_starts_follow_shared_word_boundaries() {
// Inside Macintosh: Text (1993), pp. 5-24--5-27: prefer a word
// boundary over splitting the next word at the overflowing glyph.
let pef = synthetic_pef_with_import(b"TECalText");
let mut loaded = load_pef_application(&pef).unwrap();
let rects = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rects, vec![0; 16]);
let font = PPC_QD_TEXT_FONT_DEFAULT;
let size = PPC_QD_TEXT_SIZE_SYSTEM;
let first_line_width = ppc_text_bytes_advance_for_font(b"one two", font, size);
ppc_write_rect(&mut loaded.memory, rects, 10, 20, 80, 20 + first_line_width).unwrap();
ppc_write_rect(
&mut loaded.memory,
rects + 8,
10,
20,
80,
20 + first_line_width,
)
.unwrap();
let mut last_mem_error = PPC_NO_ERR;
let te_handle = ppc_te_initialize_record(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
rects,
rects + 8,
PPC_MAIN_GWORLD,
1,
PPC_QD_TEXT_MODE_SRC_OR,
size,
PPC_RGB_BLACK,
false,
);
assert_eq!(
ppc_te_set_text(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
te_handle,
b"one two three",
),
PPC_NO_ERR
);
let te_ptr = loaded.memory.read_u32_be(te_handle).unwrap();
assert_eq!(
loaded.memory.read_u16_be(te_ptr + PPC_TE_N_LINES_OFFSET),
Some(2)
);
assert_eq!(
loaded
.memory
.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET),
Some(0)
);
assert_eq!(
loaded
.memory
.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + 2),
Some(8)
);
}
#[test]
fn te_text_box_replaces_contents_and_erases_empty_text() {
let pef = synthetic_pef_with_import(b"TETextBox");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let rect = scratch + 0x20;
loaded.memory.add_region(scratch, vec![0; 0x40]);
loaded.memory.write_u8(scratch, b'0').unwrap();
ppc_write_rect(&mut loaded.memory, rect, 10, 10, 40, 100).unwrap();
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
for y in 9..41 {
for x in 9..101 {
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
front,
(x, y),
103
));
}
}
let clip = loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_CLIP_RGN_OFFSET)
.unwrap();
ppc_set_rect_rgn(&mut loaded.memory, clip, 0, 0, 80, 100).unwrap();
loaded.quickdraw_fore_indices.insert(PPC_MAIN_GWORLD, 99);
loaded
.toolbox_startup
.quickdraw_back_indices
.insert(PPC_MAIN_GWORLD, 17);
loaded.cpu.gpr[3] = scratch;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = rect;
loaded.cpu.gpr[6] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TETextBox);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (70, 35)),
Some(17)
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (90, 35)),
Some(103)
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (9, 9)),
Some(103)
);
assert!((10..40).any(|y| (10..80)
.any(|x| { ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, y)) == Some(99) })));
// An empty replacement still removes every previous glyph inside
// the box, while the portion outside clipRgn stays untouched.
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = rect;
loaded.cpu.gpr[6] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TETextBox);
for y in 10..40 {
for x in 10..100 {
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, y)),
Some(if x < 80 { 17 } else { 103 }),
"replacement pixel ({x}, {y})",
);
}
}
}
#[test]
fn textedit_and_te_text_box_use_explicit_foreground_index() {
let pef = synthetic_pef_with_import(b"TETextBox");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let text = scratch;
let text_box_rect = scratch + 0x20;
let te_rects = scratch + 0x40;
loaded.memory.add_region(scratch, vec![0; 0x60]);
loaded.memory.write_u8(text, b'0').unwrap();
ppc_write_rect(&mut loaded.memory, text_box_rect, 10, 10, 40, 100).unwrap();
loaded.quickdraw_fore_indices.insert(PPC_MAIN_GWORLD, 103);
loaded.cpu.gpr[3] = text;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = text_box_rect;
loaded.cpu.gpr[6] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert!((10..40).any(|y| {
(10..100)
.any(|x| ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, y)) == Some(103))
}));
ppc_write_rect(&mut loaded.memory, te_rects, 60, 10, 100, 100).unwrap();
ppc_write_rect(&mut loaded.memory, te_rects + 8, 60, 10, 100, 100).unwrap();
let mut last_mem_error = PPC_NO_ERR;
let te_handle = ppc_te_initialize_record(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
te_rects,
te_rects + 8,
PPC_MAIN_GWORLD,
0,
PPC_QD_TEXT_MODE_SRC_OR,
12,
loaded.quickdraw_fore_color,
false,
);
assert_eq!(
ppc_te_set_text(
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
te_handle,
b"0",
),
PPC_NO_ERR
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::TEUpdate;
loaded.cpu.gpr[3] = te_rects;
loaded.cpu.gpr[4] = te_handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert!((60..100).any(|y| {
(10..100)
.any(|x| ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, y)) == Some(103))
}));
}
mod scrap_manager;
#[test]
fn native_list_manager_stores_cells_rows_selection_and_geometry_in_public_records() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LScroll"),
PpcImportDispatcherTarget::LScroll
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LSize"),
PpcImportDispatcherTarget::LSize
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LSetDrawingMode"),
PpcImportDispatcherTarget::LSetDrawingMode
);
let pef = synthetic_pef_with_import(b"LNew");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let view_ptr = scratch;
let bounds_ptr = scratch + 8;
let text_ptr = scratch + 20;
let output_ptr = scratch + 32;
let length_ptr = scratch + 48;
let cell_ptr = scratch + 52;
loaded.memory.add_region(scratch, vec![0; 64]);
ppc_write_rect(&mut loaded.memory, view_ptr, 10, 20, 90, 220).unwrap();
ppc_write_rect(&mut loaded.memory, bounds_ptr, 0, 0, 2, 2).unwrap();
loaded.memory.write_bytes(text_ptr, b"Pilot").unwrap();
loaded.cpu.gpr[3] = view_ptr;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = (20u32 << 16) | 100;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = PPC_MAIN_GWORLD;
loaded.cpu.gpr[8] = 0;
loaded.cpu.gpr[9] = 0;
loaded.cpu.gpr[10] = 0;
loaded
.memory
.write_u32_be(
ppc_parameter_area_slot_addr(loaded.cpu.gpr[1], PPC_NATIVE_PARAMETER_GPR_COUNT)
.unwrap(),
1,
)
.unwrap();
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.unsupported_import_index, None);
let list = loaded.cpu.gpr[3];
let list_ptr = loaded.memory.read_u32_be(list).unwrap();
assert_ne!(list, 0);
assert_eq!(
ppc_read_rect(&mut loaded.memory, list_ptr + PPC_LIST_DATA_BOUNDS_OFFSET),
Some((0, 0, 2, 2))
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, list_ptr + PPC_LIST_VISIBLE_OFFSET),
Some((0, 0, 2, 2))
);
assert_eq!(
loaded
.memory
.read_u16_be(list_ptr + PPC_LIST_MAX_INDEX_OFFSET),
Some(8)
);
assert_eq!(
loaded
.list_manager
.get_record(list)
.map(|record| record.cell_size),
Some((20, 100))
);
let vertical_scroll = loaded
.memory
.read_u32_be(list_ptr + PPC_LIST_VSCROLL_OFFSET)
.unwrap();
assert_ne!(vertical_scroll, 0);
assert_eq!(
loaded
.memory
.read_u32_be(list_ptr + PPC_LIST_HSCROLL_OFFSET),
Some(0)
);
let vertical_scroll_ptr = ppc_control_ptr(&mut loaded.memory, vertical_scroll).unwrap();
assert_eq!(
ppc_read_rect(
&mut loaded.memory,
vertical_scroll_ptr + PPC_CONTROL_RECT_OFFSET,
),
Some((9, 220, 91, 236))
);
assert_eq!(
loaded
.memory
.read_u8(vertical_scroll_ptr + PPC_CONTROL_VISIBLE_OFFSET),
Some(0)
);
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LSetDrawingMode);
assert!(loaded.list_manager.get_record(list).unwrap().draw_enabled);
assert_eq!(
loaded
.memory
.read_u8(vertical_scroll_ptr + PPC_CONTROL_VISIBLE_OFFSET),
Some(0xff)
);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LSetDrawingMode);
assert!(!loaded.list_manager.get_record(list).unwrap().draw_enabled);
assert_eq!(loaded.memory.read_u8(vertical_scroll_ptr + PPC_CONTROL_VISIBLE_OFFSET), Some(0xff));
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LSetDrawingMode);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LSetCell;
loaded.cpu.gpr[3] = text_ptr;
loaded.cpu.gpr[4] = 5;
loaded.cpu.gpr[5] = (1u32 << 16) | 1;
loaded.cpu.gpr[6] = list;
loaded.run_with_hle_imports(128);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LGetCell;
loaded.memory.write_u16_be(length_ptr, 16).unwrap();
loaded.cpu.gpr[3] = output_ptr;
loaded.cpu.gpr[4] = length_ptr;
loaded.cpu.gpr[5] = (1u32 << 16) | 1;
loaded.cpu.gpr[6] = list;
loaded.run_with_hle_imports(128);
assert_eq!(loaded.memory.read_u16_be(length_ptr), Some(5));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, output_ptr, 5),
Some(b"Pilot".to_vec())
);
loaded.memory.write_bytes(output_ptr, b"XXXXX").unwrap();
loaded.memory.write_u16_be(length_ptr, 3).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.run_with_hle_imports(128);
assert_eq!(loaded.memory.read_u16_be(length_ptr), Some(3));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, output_ptr, 5),
Some(b"XXXXX".to_vec())
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LSetSelect;
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = (1u32 << 16) | 1;
loaded.cpu.gpr[5] = list;
loaded.run_with_hle_imports(128);
loaded.memory.write_u16_be(cell_ptr, 0).unwrap();
loaded.memory.write_u16_be(cell_ptr + 2, 0).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LGetSelect;
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = cell_ptr;
loaded.cpu.gpr[5] = list;
loaded.run_with_hle_imports(128);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u16_be(cell_ptr), Some(1));
assert_eq!(loaded.memory.read_u16_be(cell_ptr + 2), Some(1));
let selected_before_rejected_clicks = loaded.list_manager.get_record(list).unwrap().selected;
loaded.cpu.gpr[3] = (9u32 << 16) | 20;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LClick);
assert_eq!(
loaded.list_manager.get_record(list).unwrap().selected, selected_before_rejected_clicks,
"LClick must ignore points outside rView",
);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LActivate);
assert_eq!(
loaded
.memory
.read_u8(vertical_scroll_ptr + PPC_CONTROL_HILITE_OFFSET),
Some(0xfe)
);
loaded.cpu.gpr[3] = (10u32 << 16) | 20;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LClick);
assert_eq!(
loaded.list_manager.get_record(list).unwrap().selected, selected_before_rejected_clicks,
"LClick must ignore inactive lists",
);
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LActivate);
assert_eq!(
loaded
.memory
.read_u8(vertical_scroll_ptr + PPC_CONTROL_HILITE_OFFSET),
Some(0)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LAddRow;
loaded.cpu.gpr[3] = 3;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = list;
loaded.run_with_hle_imports(128);
let list_ptr = loaded.memory.read_u32_be(list).unwrap();
assert_eq!(
ppc_read_rect(&mut loaded.memory, list_ptr + PPC_LIST_DATA_BOUNDS_OFFSET),
Some((0, 0, 5, 2))
);
assert_eq!(
loaded.list_manager.get_record(list).map(|record| record.visible),
Some((0, 0, 4, 2))
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, list_ptr + PPC_LIST_VISIBLE_OFFSET),
Some((0, 0, 4, 2))
);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LScroll);
let list_ptr = loaded.memory.read_u32_be(list).unwrap();
assert_eq!(
loaded.list_manager.get_record(list).map(|record| record.visible),
Some((1, 0, 5, 2))
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, list_ptr + PPC_LIST_VISIBLE_OFFSET),
Some((1, 0, 5, 2))
);
assert_eq!(
loaded
.memory
.read_u16_be(vertical_scroll_ptr + PPC_CONTROL_VALUE_OFFSET),
Some(1)
);
loaded.cpu.gpr[3] = 100;
loaded.cpu.gpr[4] = 40;
loaded.cpu.gpr[5] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LSize);
let list_ptr = loaded.memory.read_u32_be(list).unwrap();
assert_eq!(
loaded
.list_manager
.get_record(list)
.map(|record| record.view_rect),
Some((10, 20, 50, 120))
);
assert_eq!(
loaded.list_manager.get_record(list).map(|record| record.visible),
Some((1, 0, 3, 1))
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, list_ptr + PPC_LIST_VIEW_OFFSET),
Some((10, 20, 50, 120))
);
assert_eq!(
ppc_read_rect(&mut loaded.memory, list_ptr + PPC_LIST_VISIBLE_OFFSET),
Some((1, 0, 3, 1))
);
assert_eq!(
ppc_read_rect(
&mut loaded.memory,
vertical_scroll_ptr + PPC_CONTROL_RECT_OFFSET,
),
Some((9, 120, 51, 136))
);
assert_eq!(
loaded
.memory
.read_u16_be(vertical_scroll_ptr + PPC_CONTROL_MAX_OFFSET),
Some(3)
);
loaded.cpu.gpr[3] = list;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LDispose);
assert_eq!(loaded.memory.read_u32_be(vertical_scroll), Some(0));
assert!(!loaded.controls.contains_handle(vertical_scroll));
}
#[test]
fn native_list_manager_draws_cell_backgrounds_in_port_coordinates() {
let pef = synthetic_pef_with_import(b"LNew");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x2200;
let view_ptr = scratch;
let bounds_ptr = scratch + 8;
loaded.memory.add_region(scratch, vec![0; 24]);
ppc_write_rect(&mut loaded.memory, view_ptr, 10, 20, 50, 120).unwrap();
ppc_write_rect(&mut loaded.memory, bounds_ptr, 0, 0, 3, 1).unwrap();
loaded.cpu.gpr[3] = view_ptr;
loaded.cpu.gpr[4] = bounds_ptr;
loaded.cpu.gpr[5] = (20u32 << 16) | 100;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = PPC_MAIN_GWORLD;
loaded.cpu.gpr[8] = 0;
loaded.cpu.gpr[9] = 0;
loaded.cpu.gpr[10] = 0;
loaded
.memory
.write_u32_be(
ppc_parameter_area_slot_addr(loaded.cpu.gpr[1], PPC_NATIVE_PARAMETER_GPR_COUNT)
.unwrap(),
0,
)
.unwrap();
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.unsupported_import_index, None);
let list = loaded.cpu.gpr[3];
loaded
.list_manager
.with_record_mut(list, |record| {
record.selected.insert((0, 0));
})
.unwrap();
// NewCWindow gives an on-screen window a negative PixMap origin so
// its local port coordinates map to its global screen position.
ppc_set_port_origin(&mut loaded.memory, PPC_MAIN_GWORLD, -150, -40).unwrap();
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
assert_eq!((surface.top, surface.left), (-40, -150));
let front = surface.front_buffer;
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
assert!(ppc_fill_front_rect(
&mut loaded.memory,
front,
(0, 0, front.height as i16, front.width as i16),
PPC_RGB_WHITE,
));
let record = loaded.list_manager.get_record(list).unwrap();
ppc_list_draw(&mut loaded.memory, &loaded.gworlds, &record);
// Row 0, column 0 is local (10,20)-(30,120), which maps to
// screen (50,170)-(70,270) for this window origin.
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (260, 65)),
Some(black),
"selected list background must follow the port origin"
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (110, 25)),
Some(white),
"selected list background must not remain at port-local screen coordinates"
);
}
#[test]
fn attached_list_manager_mutations_and_lifetime_cross_isa_immediately() {
let mut native = load_pef_application(&synthetic_pef_with_import(b"LNew")).unwrap();
let (mut classic, _classic_cpu, _classic_bus) = setup_with_port();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let scratch = PPC_DATA_BASE + 0x1800;
let view_ptr = scratch;
let bounds_ptr = scratch + 8;
let classic_text_ptr = scratch + 20;
let native_text_ptr = scratch + 32;
let output_ptr = scratch + 48;
let length_ptr = scratch + 64;
native.memory.add_region(scratch, vec![0; 80]);
ppc_write_rect(&mut native.memory, view_ptr, 10, 20, 50, 220).unwrap();
ppc_write_rect(&mut native.memory, bounds_ptr, 0, 0, 2, 2).unwrap();
native
.memory
.write_bytes(classic_text_ptr, b"Classic")
.unwrap();
native
.memory
.write_bytes(native_text_ptr, b"Native")
.unwrap();
native.cpu.gpr[3] = view_ptr;
native.cpu.gpr[4] = bounds_ptr;
native.cpu.gpr[5] = (20u32 << 16) | 100;
native.cpu.gpr[6] = 0;
native.cpu.gpr[7] = PPC_MAIN_GWORLD;
native.cpu.gpr[8] = 0;
native.cpu.gpr[9] = 0;
native.cpu.gpr[10] = 0;
native
.memory
.write_u32_be(
ppc_parameter_area_slot_addr(native.cpu.gpr[1], PPC_NATIVE_PARAMETER_GPR_COUNT)
.unwrap(),
0,
)
.unwrap();
native.run_with_hle_imports(128);
let first_list = native.cpu.gpr[3];
assert!(classic.list_states.contains_handle(first_list));
assert_eq!(
native
.list_manager
.get_record(first_list)
.map(|record| record.cell_size),
Some((20, 100))
);
classic
.list_states
.with_record_mut(first_list, |classic_state| {
classic_state.cells.insert((1, 1), b"Classic".to_vec());
classic_state.selected.insert((1, 1));
classic_state.draw_enabled = true;
})
.unwrap();
native.memory.write_u16_be(length_ptr, 16).unwrap();
native.cpu.gpr[3] = output_ptr;
native.cpu.gpr[4] = length_ptr;
native.cpu.gpr[5] = (1u32 << 16) | 1;
native.cpu.gpr[6] = first_list;
run_test_import(&mut native, PpcImportDispatcherTarget::LGetCell);
assert_eq!(native.memory.read_u16_be(length_ptr), Some(7));
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, output_ptr, 7),
Some(b"Classic".to_vec())
);
native.cpu.gpr[3] = native_text_ptr;
native.cpu.gpr[4] = 6;
native.cpu.gpr[5] = 0;
native.cpu.gpr[6] = first_list;
run_test_import(&mut native, PpcImportDispatcherTarget::LSetCell);
assert_eq!(
classic
.list_states
.get_record(first_list)
.and_then(|record| record.cells.get(&(0, 0)).cloned())
.as_deref(),
Some(b"Native".as_slice())
);
native.cpu.gpr[3] = view_ptr;
native.cpu.gpr[4] = bounds_ptr;
native.cpu.gpr[5] = (20u32 << 16) | 100;
native.cpu.gpr[6] = 0;
native.cpu.gpr[7] = PPC_MAIN_GWORLD;
native.cpu.gpr[8] = 0;
native.cpu.gpr[9] = 0;
native.cpu.gpr[10] = 0;
run_test_import(&mut native, PpcImportDispatcherTarget::LNew);
let second_list = native.cpu.gpr[3];
assert_ne!(first_list, second_list);
assert_eq!(classic.list_states.len(), 2);
assert_eq!(
native
.list_manager
.get_record(second_list)
.map(|record| record.cell_size),
Some((20, 100))
);
native.cpu.gpr[3] = first_list;
run_test_import(&mut native, PpcImportDispatcherTarget::LDispose);
assert!(!classic.list_states.contains_handle(first_list));
assert!(classic.list_states.contains_handle(second_list));
}
#[test]
fn cloned_native_adapter_detaches_list_manager_state() {
let original = load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
original.list_manager.insert_record(
0x0032_1000,
PpcListRecord {
handle: 0x0032_1000,
cells_handle: 0x0032_2000,
view_rect: (0, 0, 40, 100),
data_bounds: (0, 0, 2, 1),
cell_size: (20, 100),
visible: (0, 0, 2, 1),
port: PPC_MAIN_GWORLD,
draw_enabled: true,
active: true,
cells: [((0, 0), b"Original".to_vec())].into(),
selected: [(0, 0)].into(),
last_click: (0, 0),
last_click_tick: 10,
},
);
let detached = original.clone();
detached
.list_manager
.with_record_mut(0x0032_1000, |detached_record| {
detached_record.cells.insert((0, 0), b"Detached".to_vec());
detached_record.selected.clear();
})
.unwrap();
detached.list_manager.insert_record(
0x0032_3000,
PpcListRecord {
handle: 0x0032_3000,
cells_handle: 0x0032_4000,
view_rect: (0, 0, 20, 100),
data_bounds: (0, 0, 1, 1),
cell_size: (20, 100),
visible: (0, 0, 1, 1),
port: PPC_MAIN_GWORLD,
draw_enabled: false,
active: true,
cells: Default::default(),
selected: Default::default(),
last_click: (-1, -1),
last_click_tick: 0,
},
);
assert_eq!(
original
.list_manager
.get_record(0x0032_1000)
.unwrap()
.cells[&(0, 0)],
b"Original"
);
assert!(original
.list_manager
.get_record(0x0032_1000)
.unwrap()
.selected
.contains(&(0, 0)));
assert!(!original.list_manager.contains_handle(0x0032_3000));
}
#[test]
fn native_menu_manager_mutates_items_dimensions_and_the_current_menu_list() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
let title = scratch;
let definitions = scratch + 0x40;
let replacement = scratch + 0x80;
loaded.memory.add_region(scratch, vec![0; 0x100]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, title, b"Game"));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
definitions,
b"Start/S;Disabled(;About/A",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
replacement,
b"New Game"
));
let menu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
128,
title,
);
assert_ne!(menu, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu,
definitions,
i16::MAX,
),
PPC_NO_ERR
);
assert_eq!(ppc_count_menu_items(&mut loaded.memory, menu), 3);
assert!(ppc_menu_item_enabled(&mut loaded.memory, menu, 1));
assert!(!ppc_menu_item_enabled(&mut loaded.memory, menu, 2));
let mut cpu = PpcCpu::new();
cpu.gpr[3] = menu;
cpu.gpr[4] = 1;
cpu.gpr[5] = replacement;
assert_eq!(
ppc_set_menu_item_text(
&cpu,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
),
PPC_NO_ERR
);
assert_eq!(
ppc_menu_item(&mut loaded.memory, menu, 1).and_then(|(address, length)| {
ppc_memory_read_bytes(&mut loaded.memory, address + 1, u32::from(length))
}),
Some(b"New Game".to_vec())
);
assert_eq!(
ppc_delete_menu_item(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu,
2,
),
PPC_NO_ERR
);
ppc_calc_menu_size(&mut loaded.memory, menu);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(ppc_count_menu_items(&mut loaded.memory, menu), 2);
assert!(loaded.memory.read_u16_be(menu_ptr + 2).unwrap() >= 32);
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(32));
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
0,
),
PPC_NO_ERR
);
let menu_list = ppc_current_menu_list(&mut loaded.memory);
assert_eq!(
ppc_get_menu_handle(&mut loaded.memory, menu_list, 128,),
menu
);
assert_eq!(
ppc_delete_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu_list,
128,
),
PPC_NO_ERR
);
assert_eq!(ppc_get_menu_handle(&mut loaded.memory, menu_list, 128,), 0);
}
#[test]
fn get_new_dialog_opens_its_first_edit_text_item_with_a_borrowed_text_handle() {
let pef = synthetic_pef_with_import(b"GetNewDialog");
let mut loaded = load_pef_application(&pef).unwrap();
let mut dlog = vec![0; 22];
dlog[4..6].copy_from_slice(&100i16.to_be_bytes());
dlog[6..8].copy_from_slice(&260i16.to_be_bytes());
dlog[10] = 1;
dlog[18..20].copy_from_slice(&128i16.to_be_bytes());
let mut ditl = vec![0; 22];
ditl[6..8].copy_from_slice(&12i16.to_be_bytes());
ditl[8..10].copy_from_slice(&20i16.to_be_bytes());
ditl[10..12].copy_from_slice(&32i16.to_be_bytes());
ditl[12..14].copy_from_slice(&220i16.to_be_bytes());
ditl[14] = PPC_DIALOG_ITEM_EDIT_TEXT;
ditl[15] = 5;
ditl[16..21].copy_from_slice(b"Pilot");
for (res_type, data) in [(*b"DLOG", dlog), (*b"DITL", ditl)] {
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded
.process_file_system
.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: String::new(),
res_type: u32::from_be_bytes(res_type),
res_id: 128,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
loaded.cpu.gpr[3] = 128;
let probe = loaded.run_with_hle_imports(128);
assert_eq!(probe.unsupported_import_index, None);
let dialog = loaded.cpu.gpr[3];
let items_handle = loaded
.memory
.read_u32_be(dialog + PPC_DIALOG_ITEMS_OFFSET)
.unwrap();
let items_ptr = loaded.memory.read_u32_be(items_handle).unwrap();
let item_text_handle = loaded.memory.read_u32_be(items_ptr + 2).unwrap();
let te_handle = loaded
.memory
.read_u32_be(dialog + PPC_DIALOG_TEXT_HANDLE_OFFSET)
.unwrap();
let te_ptr = loaded.memory.read_u32_be(te_handle).unwrap();
assert_ne!(te_handle, 0);
assert!(loaded
.event_queue()
.iter()
.any(|event| event.what == 6 && event.message == dialog));
assert_eq!(
loaded.memory.read_u32_be(te_ptr + PPC_TE_HTEXT_OFFSET),
Some(item_text_handle)
);
assert_eq!(
ppc_te_text_bytes(&mut loaded.memory, &test_handle_records!(loaded), te_handle),
Some(b"Pilot".to_vec())
);
assert_eq!(
loaded
.memory
.read_u16_be(dialog + PPC_DIALOG_EDIT_FIELD_OFFSET),
Some(0)
);
assert_eq!(
loaded
.memory
.read_u16_be(dialog + PPC_DIALOG_EDIT_OPEN_OFFSET),
Some(1)
);
assert_eq!(
loaded.memory.read_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET),
Some(0)
);
assert_eq!(
loaded.memory.read_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET),
Some(5)
);
let item_hit_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(item_hit_ptr, vec![0; 2]);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::ModalDialog;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[4] = item_hit_ptr;
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = dialog);
loaded.set_event_queue([PpcQueuedEvent {
what: 3,
message: (2 << 8) | u32::from(b'D'),
when: 0,
where_v: 20,
where_h: 30,
modifiers: 0,
}]);
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
ppc_te_text_bytes(&mut loaded.memory, &test_handle_records!(loaded), te_handle),
Some(b"D".to_vec())
);
assert_eq!(loaded.memory.read_u16_be(item_hit_ptr), Some(0));
loaded.set_event_queue([PpcQueuedEvent {
what: 3,
message: (u32::from(PPC_KEY_RETURN) << 8) | 0x0d,
when: 0,
where_v: 20,
where_h: 30,
modifiers: 0,
}]);
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(
probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.memory.read_u16_be(item_hit_ptr), Some(1));
}
#[test]
fn pbh_get_v_info_enumerates_and_selects_mounted_volumes() {
let pef = synthetic_pef_with_import(b"PBGetVInfoSync");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.seed_vfs_volumes(vec![PpcVfsVolumeRecord {
ref_num: -2,
name: "Gridz™ CD".to_string(),
root_dir_id: 42,
attributes: 0x8080,
file_count: 38,
allocation_block_count: 400,
allocation_block_size: 2048,
clump_size: 4096,
free_blocks: 12,
bitmap_start: 3,
allocation_pointer: 4,
allocation_start: 5,
next_catalog_id: 81,
created_date: 0x1234_5678,
modified_date: 0x2345_6789,
}]);
let pb = PPC_DATA_BASE + 0x1000;
let name_ptr = pb + 0x100;
loaded.memory.add_region(pb, vec![0; 0x200]);
loaded.memory.write_u32_be(pb + 18, name_ptr).unwrap();
loaded.memory.write_u16_be(pb + 28, 2).unwrap();
loaded.cpu.gpr[3] = pb;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u16_be(pb + 22), Some((-2i16) as u16));
assert_eq!(loaded.memory.read_u16_be(pb + 38), Some(0x8080));
assert_eq!(loaded.memory.read_u16_be(pb + 40), Some(38));
assert_eq!(loaded.memory.read_u32_be(pb + 48), Some(2048));
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, name_ptr),
Some(encode_mac_roman_lossy("Gridz™ CD"))
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = pb;
loaded.memory.write_u16_be(pb + 28, 3).unwrap();
let _ = loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NSV_ERR));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = pb;
loaded.memory.write_u16_be(pb + 22, 0).unwrap();
loaded.memory.write_u16_be(pb + 28, 0).unwrap();
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
name_ptr,
&encode_mac_roman_lossy("Gridz™ CD:ToolBot Power Supply"),
));
let _ = loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u16_be(pb + 22), Some((-2i16) as u16));
}
#[test]
fn pbh_get_v_info_keeps_relative_paths_on_the_default_volume() {
let pef = synthetic_pef_with_import(b"PBHGetVInfoSync");
let mut loaded = load_pef_application(&pef).unwrap();
let pb = PPC_DATA_BASE + 0x1000;
let name_ptr = pb + 0x100;
loaded.memory.add_region(pb, vec![0; 0x200]);
loaded.memory.write_u32_be(pb + 18, name_ptr).unwrap();
loaded.memory.write_u16_be(pb + 22, 0).unwrap();
loaded.memory.write_u16_be(pb + 28, (-1i16) as u16).unwrap();
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
name_ptr,
b":data:title.phd",
));
loaded.cpu.gpr[3] = pb;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u16_be(pb + 22),
Some(PPC_BOOT_VOLUME_REF_NUM as u16)
);
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, name_ptr).as_deref(),
Some(crate::trap::TrapDispatcher::boot_volume_name().as_bytes())
);
}
#[test]
fn hle_import_runner_updates_control_titles_and_values() {
let pef = synthetic_pef_with_import(b"SetControlTitle");
let mut loaded = load_pef_application(&pef).unwrap();
let title_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(title_ptr, vec![0; 256]);
write_ppc_pstring(&mut loaded.memory, title_ptr, b"Continue");
let control_handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&[0],
);
loaded.cpu.gpr[3] = control_handle;
loaded.cpu.gpr[4] = title_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let control = loaded.memory.read_u32_be(control_handle).unwrap();
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, control + PPC_CONTROL_TITLE_OFFSET),
Some(b"Continue".to_vec())
);
loaded
.memory
.write_u16_be(control + PPC_CONTROL_MAX_OFFSET, 1)
.unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetControlValue;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = control_handle;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let control = loaded.memory.read_u32_be(control_handle).unwrap();
assert_eq!(
loaded
.memory
.read_u16_be(control + PPC_CONTROL_VALUE_OFFSET),
Some(1)
);
}
#[test]
fn hle_import_runner_gets_and_sets_cur_dir_store_low_memory_global() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMSetCurDirStore"),
PpcImportDispatcherTarget::LMSetCurDirStore
);
let pef = synthetic_pef_with_import(b"LMSetCurDirStore");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.seed_vfs_directories(initial_ppc_vfs_directories(), 0x1122_3344, 18);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::CUR_DIR_STORE),
Some(0x1122_3344)
);
loaded.cpu.gpr[3] = 0x5566_7788;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::CUR_DIR_STORE),
Some(0x5566_7788)
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LMGetCurDirStore;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x5566_7788);
}
#[test]
fn hle_import_runner_gets_and_sets_sf_save_disk_low_memory_global() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMSetSFSaveDisk"),
PpcImportDispatcherTarget::LMSetSFSaveDisk
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMGetSFSaveDisk"),
PpcImportDispatcherTarget::LMGetSFSaveDisk
);
let pef = synthetic_pef_with_import(b"LMSetSFSaveDisk");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = (-7_i16) as u16 as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::SF_SAVE_DISK),
Some((-7_i16) as u16)
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LMGetSFSaveDisk;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], (-7_i16) as u32);
}
#[test]
fn hle_import_runner_gets_and_sets_gray_region_low_memory_handle() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMSetGrayRgn"),
PpcImportDispatcherTarget::LMSetGrayRgn
);
let pef = synthetic_pef_with_import(b"LMSetGrayRgn");
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded.memory.read_u32_be(PPC_GRAY_RGN_ADDR),
Some(PPC_GRAY_RGN_HANDLE)
);
loaded.cpu.gpr[3] = 0x0300_1234;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.memory.read_u32_be(PPC_GRAY_RGN_ADDR),
Some(0x0300_1234)
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetGrayRgn;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x0300_1234);
}
#[test]
fn hle_import_runner_exposes_sound_driver_in_unit_table() {
let pef = synthetic_pef_with_import(b"LMGetUTableBase");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_UNIT_TABLE);
assert_eq!(
loaded.memory.read_u32_be(PPC_UNIT_TABLE + 3 * 4),
Some(PPC_SOUND_DCE_HANDLE)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_SOUND_DCE_HANDLE),
Some(PPC_SOUND_DCE)
);
assert_eq!(
loaded.memory.read_u16_be(PPC_SOUND_DCE + 24),
Some((-4i16) as u16)
);
}
#[test]
fn hle_import_runner_get_adb_info_exposes_standard_devices() {
for (address, expected) in [(2, [2, 2]), (3, [1, 3])] {
let pef = synthetic_pef_with_import(b"GetADBInfo");
let mut loaded = load_pef_application(&pef).unwrap();
let info_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(info_ptr, vec![0xaa; 12]);
loaded.cpu.gpr[3] = info_ptr;
loaded.cpu.gpr[4] = address;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u8(info_ptr), Some(expected[0]));
assert_eq!(loaded.memory.read_u8(info_ptr + 1), Some(expected[1]));
assert_eq!(loaded.memory.read_u32_be(info_ptr + 2), Some(0));
assert_eq!(loaded.memory.read_u32_be(info_ptr + 6), Some(0));
assert_eq!(loaded.memory.read_u16_be(info_ptr + 10), Some(0xaaaa));
}
let pef = synthetic_pef_with_import(b"GetADBInfo");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 4;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(-1));
}
#[test]
fn hle_import_runner_gets_and_sets_random_seed_low_memory_global() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMSetRndSeed"),
PpcImportDispatcherTarget::LMSetRndSeed
);
let pef = synthetic_pef_with_import(b"LMSetRndSeed");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.memory.read_u32_be(PPC_RAND_SEED_ADDR),
Some(0x1234_5678)
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LMGetRndSeed;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x1234_5678);
}
#[test]
fn hle_import_runner_handles_keyboard_time_and_text_width_utilities() {
assert_eq!(
ppc_virtual_microseconds(100, 100, 25, 50),
100 * PPC_MICROSECONDS_PER_TICK + 3 * PPC_MICROSECONDS_PER_TICK / 4
);
let pef = synthetic_pef_with_import(b"GetKeys");
let mut loaded = load_pef_application(&pef).unwrap();
let key_map_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(key_map_ptr, vec![0xaa; PPC_KEY_MAP_SIZE as usize]);
loaded.cpu.gpr[3] = key_map_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
for offset in 0..PPC_KEY_MAP_SIZE {
assert_eq!(loaded.memory.read_u8(key_map_ptr + offset), Some(0));
}
let pef = synthetic_pef_with_import(b"GetKeys");
let mut loaded = load_pef_application(&pef).unwrap();
let key_map_ptr = PPC_DATA_BASE + 0x1000;
let mut input = PpcInputSnapshot::default();
input.key_map[(PPC_KEY_LEFT / 8) as usize] |= 1u8 << (PPC_KEY_LEFT % 8);
loaded.set_input_snapshot(input);
loaded
.memory
.add_region(key_map_ptr, vec![0; PPC_KEY_MAP_SIZE as usize]);
loaded.cpu.gpr[3] = key_map_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_ne!(
loaded
.memory
.read_u8(key_map_ptr + u32::from(PPC_KEY_LEFT / 8))
.unwrap()
& (1u8 << (PPC_KEY_LEFT % 8)),
0
);
let pef = synthetic_pef_with_import(b"GetDateTime");
let mut loaded = load_pef_application(&pef).unwrap();
let secs_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(secs_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = secs_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.memory.read_u32_be(secs_ptr),
Some(PPC_FIXED_MAC_TIME)
);
let pef = synthetic_pef_with_import(b"LMGetTime");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_FIXED_MAC_TIME);
let pef = synthetic_pef_with_import(b"Delay");
let mut loaded = load_pef_application(&pef).unwrap();
let final_ticks_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(final_ticks_ptr, vec![0xaa; 4]);
loaded.set_clock_cycle_timing(1_000_000, 0);
loaded.set_tick_count(42);
loaded.cpu.gpr[3] = 2;
loaded.cpu.gpr[4] = final_ticks_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.result, PpcRunResult::CycleLimit { cycles: 64 });
assert_eq!(loaded.cpu.pc, loaded.import_trap_base);
assert_eq!(
loaded.memory.read_u32_be(final_ticks_ptr),
Some(0xaaaa_aaaa)
);
loaded.set_tick_count(43);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.result, PpcRunResult::CycleLimit { cycles: 64 });
loaded.set_tick_count(44);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(final_ticks_ptr), Some(44));
assert_eq!(loaded.toolbox_startup.delay_deadline, None);
for (seconds, expected) in [
(0, [1904, 1, 1, 0, 0, 0, 6]),
(
59 * 86_400 + 23 * 3_600 + 59 * 60 + 58,
[1904, 2, 29, 23, 59, 58, 2],
),
(366 * 86_400, [1905, 1, 1, 0, 0, 0, 1]),
] {
let pef = synthetic_pef_with_import(b"SecondsToDate");
let mut loaded = load_pef_application(&pef).unwrap();
let date_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(date_ptr, vec![0xaa; 14]);
loaded.cpu.gpr[3] = seconds;
loaded.cpu.gpr[4] = date_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
for (index, field) in expected.into_iter().enumerate() {
assert_eq!(
loaded.memory.read_u16_be(date_ptr + index as u32 * 2),
Some(field),
"field {index} for {seconds} seconds"
);
}
}
let pef = synthetic_pef_with_import(b"Microseconds");
let mut loaded = load_pef_application(&pef).unwrap();
let microseconds_ptr = PPC_DATA_BASE + 0x1000;
let tick_count = 100u32;
let cycles_per_tick = 64;
let expected_usecs = ppc_virtual_microseconds(tick_count, cycles_per_tick, 0, 4);
loaded.memory.add_region(microseconds_ptr, vec![0xaa; 8]);
loaded.cpu.gpr[3] = microseconds_ptr;
loaded.set_tick_count(tick_count);
loaded.set_clock_cycle_timing(cycles_per_tick, 0);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.memory.read_u32_be(microseconds_ptr),
Some((expected_usecs >> 32) as u32)
);
assert_eq!(
loaded.memory.read_u32_be(microseconds_ptr + 4),
Some(expected_usecs as u32)
);
let pef = synthetic_pef_with_import(b"TickCount");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_tick_count(0x1234_5678);
loaded.set_clock_cycle_timing(64, 0);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x1234_5678);
let pef = synthetic_pef_with_import(b"SysEnvirons");
let mut loaded = load_pef_application(&pef).unwrap();
let sys_env_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(sys_env_ptr, vec![0xaa; 16]);
loaded.cpu.gpr[3] = 2;
loaded.cpu.gpr[4] = sys_env_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u16_be(sys_env_ptr), Some(2));
assert_eq!(
loaded.memory.read_u16_be(sys_env_ptr + 2),
Some(REFERENCE_MACHINE_PROFILE.gestalt_machine_type)
);
assert_eq!(
loaded.memory.read_u16_be(sys_env_ptr + 4),
Some(REFERENCE_MACHINE_PROFILE.system_version_bcd)
);
assert_eq!(
loaded.memory.read_u16_be(sys_env_ptr + 6),
Some(REFERENCE_MACHINE_PROFILE.gestalt_processor_type as u16)
);
assert_eq!(
loaded.memory.read_u8(sys_env_ptr + 8),
Some(u8::from(REFERENCE_MACHINE_PROFILE.has_fpu()))
);
assert_eq!(loaded.memory.read_u8(sys_env_ptr + 9), Some(1));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[4] = 0x30;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3] as i32, i32::from(PPC_PARAM_ERR));
let pef = synthetic_pef_with_import(b"TextWidth");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_DATA_BASE;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 7;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 42);
}
#[test]
fn hle_import_runner_handles_quickdraw_color_and_control_defaults() {
let pef = synthetic_pef_with_import(b"GetForeColor");
let mut loaded = load_pef_application(&pef).unwrap();
let color_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(color_ptr, vec![0xaa; 6]);
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], color_ptr);
assert_eq!(
ppc_read_rgb_color(&mut loaded.memory, color_ptr),
Some(PpcRgbColor {
red: 0,
green: 0,
blue: 0,
})
);
let pef = synthetic_pef_with_import(b"SetControlValue");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_HEAP_BASE + 0x100;
loaded.cpu.gpr[4] = 7;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE + 0x100);
assert_eq!(loaded.cpu.gpr[4], 7);
}
#[test]
fn hle_import_runner_op_color_records_the_arithmetic_transfer_operand() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "OpColor"),
PpcImportDispatcherTarget::OpColor
);
let pef = synthetic_pef_with_import(b"OpColor");
let mut loaded = load_pef_application(&pef).unwrap();
let color_ptr = PPC_DATA_BASE + 0x1000;
let color = PpcRgbColor {
red: 0x1234,
green: 0x5678,
blue: 0x9abc,
};
loaded.memory.add_region(color_ptr, vec![0; 6]);
ppc_write_rgb_color(&mut loaded.memory, color_ptr, color).unwrap();
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.quickdraw_op_colors.quickdraw_op_color(PPC_MAIN_GWORLD),
Some((color.red, color.green, color.blue))
);
}
#[test]
fn hle_import_runner_hilite_color_records_the_highlight_operand() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "HiliteColor"),
PpcImportDispatcherTarget::HiliteColor
);
let pef = synthetic_pef_with_import(b"HiliteColor");
let mut loaded = load_pef_application(&pef).unwrap();
let color_ptr = PPC_DATA_BASE + 0x1000;
let color = PpcRgbColor {
red: 0x1234,
green: 0x5678,
blue: 0x9abc,
};
loaded.memory.add_region(color_ptr, vec![0; 6]);
ppc_write_rgb_color(&mut loaded.memory, color_ptr, color).unwrap();
loaded.cpu.gpr[3] = color_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteColor);
assert_eq!(
loaded
.quickdraw_hilite_colors
.quickdraw_hilite_color(PPC_MAIN_GWORLD),
Some((color.red, color.green, color.blue))
);
assert_eq!(
ppc_current_hilite_color(
&mut loaded.memory,
PPC_MAIN_GWORLD,
&loaded.quickdraw_hilite_colors,
),
color
);
}
#[test]
fn classic_hilite_color_is_immediately_visible_to_attached_native_get_ctable() {
let pef = synthetic_pef_with_import(b"GetCTable");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(0x2000);
classic_bus.attach_guest_address_space(native.memory.shared_view());
context.attach_classic_memory_bus(&mut classic_bus);
let mut classic_cpu = MockCpu::new();
let sp = 0x0100;
let color_ptr = 0x0120;
classic_cpu.write_reg(Register::A7, sp);
classic_bus.write_long(sp, color_ptr);
classic_bus.write_word(color_ptr, 0x1357);
classic_bus.write_word(color_ptr + 2, 0x2468);
classic_bus.write_word(color_ptr + 4, 0x369a);
assert!(classic
.dispatch_quickdraw(true, 0x222, &mut classic_cpu, &mut classic_bus)
.expect("HiliteColor trap")
.is_ok());
assert_eq!(classic_cpu.read_reg(Register::A7), sp + 4);
assert_eq!(
native
.quickdraw_hilite_colors
.quickdraw_hilite_color(PPC_MAIN_GWORLD),
Some((0x1357, 0x2468, 0x369a))
);
native.cpu.gpr[3] = 66;
run_test_import(&mut native, PpcImportDispatcherTarget::GetCTable);
let ctable = native.cpu.gpr[3];
let ctable_ptr = native
.memory
.read_u32_be(ctable)
.expect("native enhanced ColorTable handle");
assert_eq!(native.memory.read_u16_be(ctable_ptr + 6), Some(3));
assert_eq!(native.memory.read_u16_be(ctable_ptr + 8 + 2 * 8 + 2), Some(0x1357));
assert_eq!(native.memory.read_u16_be(ctable_ptr + 8 + 2 * 8 + 4), Some(0x2468));
assert_eq!(native.memory.read_u16_be(ctable_ptr + 8 + 2 * 8 + 6), Some(0x369a));
}
#[test]
fn native_hilite_color_is_immediately_visible_to_attached_classic_grafvars() {
let pef = synthetic_pef_with_import(b"HiliteColor");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let base = PPC_HEAP_BASE + 0x15_000;
let port = base;
let graf_vars_handle = base + 0x100;
let graf_vars = base + 0x110;
let color_ptr = base + 0x120;
native.memory.add_region(base, vec![0; 0x140]);
native.memory.write_u16_be(port + 6, 0xc000).unwrap();
native
.memory
.write_u32_be(port + PPC_CGRAF_PORT_GRAF_VARS_OFFSET, graf_vars_handle)
.unwrap();
native.memory.write_u32_be(graf_vars_handle, graf_vars).unwrap();
let color = PpcRgbColor {
red: 0x1357,
green: 0x2468,
blue: 0x369a,
};
ppc_write_rgb_color(&mut native.memory, color_ptr, color).unwrap();
native
.current_gworld
.with_mut(|current_gworld| *current_gworld = port);
native.cpu.gpr[3] = color_ptr;
run_test_import(&mut native, PpcImportDispatcherTarget::HiliteColor);
let mut classic_bus = MacMemoryBus::new(0x2000);
classic_bus.attach_guest_address_space(native.memory.shared_view());
context.attach_classic_memory_bus(&mut classic_bus);
assert_eq!(*classic.current_port, port);
assert_eq!(classic_bus.read_word(graf_vars + 6), color.red);
assert_eq!(classic_bus.read_word(graf_vars + 8), color.green);
assert_eq!(classic_bus.read_word(graf_vars + 10), color.blue);
assert_eq!(classic.current_hilite_color(&classic_bus), (color.red, color.green, color.blue));
}
#[test]
fn hilite_color_keeps_distinct_values_when_switching_between_ports() {
let pef = synthetic_pef_with_import(b"HiliteColor");
let mut loaded = load_pef_application(&pef).unwrap();
let base = PPC_HEAP_BASE + 0x16_000;
let first_port = base;
let second_port = base + 0x40;
let basic_port = base + 0x80;
let first_color_ptr = base + 0x100;
let second_color_ptr = base + 0x110;
let basic_color_ptr = base + 0x120;
loaded.memory.add_region(base, vec![0; 0x140]);
for port in [first_port, second_port] {
loaded.memory.write_u16_be(port + 6, 0xc000).unwrap();
}
loaded.memory.write_u16_be(basic_port + 6, 0).unwrap();
let first_color = PpcRgbColor {
red: 0x1111,
green: 0x2222,
blue: 0x3333,
};
let second_color = PpcRgbColor {
red: 0xaaaa,
green: 0xbbbb,
blue: 0xcccc,
};
let basic_color = PpcRgbColor {
red: 0xdddd,
green: 0xeeee,
blue: 0xffff,
};
ppc_write_rgb_color(&mut loaded.memory, first_color_ptr, first_color).unwrap();
ppc_write_rgb_color(&mut loaded.memory, second_color_ptr, second_color).unwrap();
ppc_write_rgb_color(&mut loaded.memory, basic_color_ptr, basic_color).unwrap();
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = first_port);
loaded.cpu.gpr[3] = first_color_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteColor);
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = second_port);
loaded.cpu.gpr[3] = second_color_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteColor);
assert_eq!(
ppc_current_hilite_color(
&mut loaded.memory,
first_port,
&loaded.quickdraw_hilite_colors,
),
first_color
);
assert_eq!(
ppc_current_hilite_color(
&mut loaded.memory,
second_port,
&loaded.quickdraw_hilite_colors,
),
second_color
);
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = basic_port);
loaded.cpu.gpr[3] = basic_color_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteColor);
assert_eq!(
loaded
.quickdraw_hilite_colors
.quickdraw_hilite_color(basic_port),
None
);
let (red, green, blue) = DEFAULT_QUICKDRAW_HILITE_COLOR;
assert_eq!(
ppc_current_hilite_color(
&mut loaded.memory,
basic_port,
&loaded.quickdraw_hilite_colors,
),
PpcRgbColor { red, green, blue }
);
}
#[test]
fn detached_ppc_clone_has_independent_quickdraw_hilite_colors() {
let pef = synthetic_pef_with_import(b"HiliteColor");
let loaded = load_pef_application(&pef).unwrap();
let port = PPC_HEAP_BASE + 0x17_000;
loaded
.quickdraw_hilite_colors
.set_quickdraw_hilite_color(port, (0x1111, 0x2222, 0x3333));
let detached = loaded.clone();
loaded
.quickdraw_hilite_colors
.set_quickdraw_hilite_color(port, (0xaaaa, 0xbbbb, 0xcccc));
assert_eq!(
loaded
.quickdraw_hilite_colors
.quickdraw_hilite_color(port),
Some((0xaaaa, 0xbbbb, 0xcccc))
);
assert_eq!(
detached
.quickdraw_hilite_colors
.quickdraw_hilite_color(port),
Some((0x1111, 0x2222, 0x3333))
);
}
#[test]
fn classic_op_color_is_consumed_by_attached_native_copybits() {
// The native CopyBits implementation is the current arithmetic-mode
// consumer. Exercise the actual 68K -> process state -> PPC path.
let pef = synthetic_pef_with_import(b"CopyBits");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(0x2000);
classic_bus.attach_guest_address_space(native.memory.shared_view());
context.attach_classic_memory_bus(&mut classic_bus);
let mut classic_cpu = MockCpu::new();
let sp = 0x0100;
let color_ptr = 0x0120;
classic_cpu.write_reg(Register::A7, sp);
classic_bus.write_long(sp, color_ptr);
classic_bus.write_word(color_ptr, 0x8000);
classic_bus.write_word(color_ptr + 2, 0x8000);
classic_bus.write_word(color_ptr + 4, 0x8000);
assert!(classic
.dispatch_quickdraw(true, 0x221, &mut classic_cpu, &mut classic_bus)
.expect("OpColor trap")
.is_ok());
assert_eq!(classic_cpu.read_reg(Register::A7), sp + 4);
assert_eq!(
native.quickdraw_op_colors.quickdraw_op_color(PPC_MAIN_GWORLD),
Some((0x8000, 0x8000, 0x8000))
);
let scratch = PPC_HEAP_BASE + 0x11600;
let src_pixels = scratch;
let dst_pixels = scratch + 4;
let src_pixmap = scratch + 8;
let dst_pixmap = scratch + 64;
let rect = scratch + 120;
native.memory.add_region(scratch, vec![0; 128]);
ppc_write_pixmap(
&mut native.memory,
src_pixmap,
src_pixels,
2,
0,
0,
1,
1,
16,
)
.unwrap();
ppc_write_pixmap(
&mut native.memory,
dst_pixmap,
dst_pixels,
2,
0,
0,
1,
1,
16,
)
.unwrap();
native.memory.write_u16_be(src_pixels, 0x7c00).unwrap();
native.memory.write_u16_be(dst_pixels, 0x001f).unwrap();
ppc_write_rect(&mut native.memory, rect, 0, 0, 1, 1).unwrap();
native.cpu.gpr[3] = src_pixmap;
native.cpu.gpr[4] = dst_pixmap;
native.cpu.gpr[5] = rect;
native.cpu.gpr[6] = rect;
native.cpu.gpr[7] = 32;
native.cpu.gpr[8] = 0;
run_test_import(&mut native, PpcImportDispatcherTarget::CopyBits);
assert_eq!(native.memory.read_u16_be(dst_pixels), Some(0x3c0f));
}
#[test]
fn native_op_color_is_immediately_visible_to_attached_classic_grafvars() {
let pef = synthetic_pef_with_import(b"OpColor");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let base = PPC_HEAP_BASE + 0x12_000;
let port = base;
let graf_vars_handle = base + 0x100;
let graf_vars = base + 0x110;
let color_ptr = base + 0x120;
native.memory.add_region(base, vec![0; 0x140]);
native.memory.write_u16_be(port + 6, 0xc000).unwrap();
native
.memory
.write_u32_be(port + PPC_CGRAF_PORT_GRAF_VARS_OFFSET, graf_vars_handle)
.unwrap();
native.memory.write_u32_be(graf_vars_handle, graf_vars).unwrap();
let color = PpcRgbColor {
red: 0x1234,
green: 0x5678,
blue: 0x9abc,
};
ppc_write_rgb_color(&mut native.memory, color_ptr, color).unwrap();
native
.current_gworld
.with_mut(|current_gworld| *current_gworld = port);
native.cpu.gpr[3] = color_ptr;
run_test_import(&mut native, PpcImportDispatcherTarget::OpColor);
let mut classic_bus = MacMemoryBus::new(0x2000);
classic_bus.attach_guest_address_space(native.memory.shared_view());
context.attach_classic_memory_bus(&mut classic_bus);
assert_eq!(*classic.current_port, port);
assert_eq!(classic_bus.read_word(graf_vars), color.red);
assert_eq!(classic_bus.read_word(graf_vars + 2), color.green);
assert_eq!(classic_bus.read_word(graf_vars + 4), color.blue);
}
#[test]
fn op_color_keeps_distinct_values_when_switching_between_ports() {
let pef = synthetic_pef_with_import(b"OpColor");
let mut loaded = load_pef_application(&pef).unwrap();
let base = PPC_HEAP_BASE + 0x13_000;
let first_port = base;
let second_port = base + 0x40;
let first_color_ptr = base + 0x80;
let second_color_ptr = base + 0x90;
loaded.memory.add_region(base, vec![0; 0xa0]);
for port in [first_port, second_port] {
loaded.memory.write_u16_be(port + 6, 0xc000).unwrap();
}
let first_color = PpcRgbColor {
red: 0x1111,
green: 0x2222,
blue: 0x3333,
};
let second_color = PpcRgbColor {
red: 0xaaaa,
green: 0xbbbb,
blue: 0xcccc,
};
ppc_write_rgb_color(&mut loaded.memory, first_color_ptr, first_color).unwrap();
ppc_write_rgb_color(&mut loaded.memory, second_color_ptr, second_color).unwrap();
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = first_port);
loaded.cpu.gpr[3] = first_color_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::OpColor);
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = second_port);
loaded.cpu.gpr[3] = second_color_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::OpColor);
assert_eq!(
ppc_current_op_color(&mut loaded.memory, first_port, &loaded.quickdraw_op_colors),
first_color
);
assert_eq!(
ppc_current_op_color(&mut loaded.memory, second_port, &loaded.quickdraw_op_colors),
second_color
);
}
#[test]
fn detached_ppc_clone_has_independent_quickdraw_op_colors() {
let pef = synthetic_pef_with_import(b"OpColor");
let loaded = load_pef_application(&pef).unwrap();
let port = PPC_HEAP_BASE + 0x14_000;
loaded
.quickdraw_op_colors
.set_quickdraw_op_color(port, (0x1111, 0x2222, 0x3333));
let detached = loaded.clone();
loaded
.quickdraw_op_colors
.set_quickdraw_op_color(port, (0xaaaa, 0xbbbb, 0xcccc));
assert_eq!(
loaded.quickdraw_op_colors.quickdraw_op_color(port),
Some((0xaaaa, 0xbbbb, 0xcccc))
);
assert_eq!(
detached.quickdraw_op_colors.quickdraw_op_color(port),
Some((0x1111, 0x2222, 0x3333))
);
}
#[test]
fn hle_import_runner_lm_get_sys_map_returns_the_hle_fallback_refnum() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMGetSysMap"),
PpcImportDispatcherTarget::LMGetSysMap
);
let pef = synthetic_pef_with_import(b"LMGetSysMap");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0xdead_beef;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn hle_import_runner_tracks_quickdraw_cursor_level() {
let pef = synthetic_pef_with_import(b"HideCursor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0x1234_5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x1234_5678);
assert_eq!(loaded.cursor_level(), -1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HideCursor;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cursor_level(), -2);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::ShowCursor;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cursor_level(), -1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::ShowCursor;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cursor_level(), 0);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::ShowCursor;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cursor_level(), 0);
loaded.cursor_state.set_level_for_test(-3);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::InitCursor;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cursor_level(), 0);
}
#[test]
fn hle_import_runner_obscure_cursor_preserves_cursor_level() {
let pef = synthetic_pef_with_import(b"ObscureCursor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cursor_state.set_level_for_test(-2);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cursor_level(), -2);
}
#[test]
fn hle_import_runner_shield_cursor_hides_until_show_cursor() {
let pef = synthetic_pef_with_import(b"ShieldCursor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 12;
loaded.cpu.gpr[4] = 34;
loaded.cpu.gpr[5] = PPC_HEAP_BASE + 0x40;
loaded.cursor_state.set_level_for_test(-2);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 12);
assert_eq!(loaded.cpu.gpr[4], 34);
assert_eq!(loaded.cpu.gpr[5], PPC_HEAP_BASE + 0x40);
assert_eq!(loaded.cursor_level(), -3);
}
#[test]
fn attached_resource_policy_mutations_cross_isa_immediately() {
let mut native =
load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
classic_bus.write_word(TEST_SP, 0x00ff);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_toolbox(true, 0x19b, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert!(!native.policy.res_load());
native.cpu.gpr[3] = 1;
run_test_import(&mut native, PpcImportDispatcherTarget::SetResLoad);
assert!(classic.policy.res_load());
classic_bus.write_word(TEST_SP, 0x0100);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_toolbox(true, 0x193, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert!(native.policy.res_purge());
}
#[test]
fn attached_application_limit_mutations_cross_isa_immediately() {
// Inside Macintosh: Memory (1992), pp. 2-83--2-85: SetApplLimit
// changes the guest-visible application boundary without changing
// the allocator's physical heap ceiling.
let mut native =
load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
let low_memory = classic_bus
.shared_ram_region(0, 0x0010_0000)
.expect("classic adapter owns low memory");
context.attach_memory(0, low_memory, &mut native.memory);
native.attach_unconverted_process_services(&mut context);
let native_heap_ceiling = native.heap_limit();
assert_eq!(
classic_bus.read_long(crate::memory::globals::addr::APPL_LIMIT),
native.application_heap_limit(),
"native attachment must synchronize the initial low-memory projection"
);
let requested = native.heap_cursor() + 0x1000;
assert!(requested < native_heap_ceiling);
native.cpu.gpr[3] = requested;
run_test_import(&mut native, PpcImportDispatcherTarget::SetApplLimit);
assert_eq!(native.application_heap_limit(), requested);
assert_eq!(
classic_bus.read_long(crate::memory::globals::addr::APPL_LIMIT),
requested,
"native SetApplLimit must publish the process value through low memory"
);
let classic_requested = requested + 0x1000;
classic_bus.write_long(crate::memory::globals::addr::HEAP_END, native.heap_cursor());
classic_bus.write_long(
crate::memory::globals::addr::APPL_LIMIT,
requested,
);
classic_cpu.write_reg(Register::A0, classic_requested);
assert!(classic
.dispatch_memory(false, 0x2D, &mut classic_cpu, &mut classic_bus)
.expect("SetApplLimit should be handled")
.is_ok());
// The immediately following native import is the nested cross-ISA
// observation point: it must read process state, not a stale adapter
// snapshot or the native allocator ceiling.
assert_eq!(native.application_heap_limit(), classic_requested);
native.cpu.gpr[3] = 0;
run_test_import(&mut native, PpcImportDispatcherTarget::GetApplLimit);
assert_eq!(native.cpu.gpr[3], classic_requested);
assert_eq!(native.heap_limit(), native_heap_ceiling);
}
#[test]
fn attached_resource_errors_use_canonical_low_memory_cross_isa() {
let mut native =
load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let low_memory = classic_bus
.shared_ram_region(0, 0x0010_0000)
.expect("classic adapter owns low memory");
context.attach_memory(0, low_memory, &mut native.memory);
classic_bus.write_word(
crate::memory::globals::addr::RES_ERR,
PPC_RES_NOT_FOUND_ERR as u16,
);
run_test_import(&mut native, PpcImportDispatcherTarget::ResError);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_RES_NOT_FOUND_ERR));
native.cpu.gpr[3] = 0xdead_beef;
run_test_import(&mut native, PpcImportDispatcherTarget::LoadResource);
assert_eq!(
classic_bus.read_word(crate::memory::globals::addr::RES_ERR) as i16,
PPC_RES_NOT_FOUND_ERR
);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_resource(true, 0x1af, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_word(TEST_SP) as i16, PPC_RES_NOT_FOUND_ERR);
}
#[test]
fn cloned_native_adapter_detaches_resource_policy_and_error_state() {
let mut original =
load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
original.policy.set_res_load(false);
original.policy.set_res_purge(true);
original.set_test_resource_error(PPC_RES_NOT_FOUND_ERR);
let mut detached = original.clone();
detached.policy.set_res_load(true);
detached.policy.set_res_purge(false);
detached.set_test_resource_error(PPC_RES_F_NOT_FOUND_ERR);
assert!(!original.policy.res_load());
assert!(original.policy.res_purge());
assert_eq!(original.test_resource_error(), PPC_RES_NOT_FOUND_ERR);
assert!(detached.policy.res_load());
assert!(!detached.policy.res_purge());
assert_eq!(
detached.test_resource_error(),
PPC_RES_F_NOT_FOUND_ERR
);
}
#[test]
fn cloned_native_adapter_detaches_process_cursor_state() {
let loaded = load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
let detached = loaded.clone();
let mut data = [0; 32];
data[0] = 0x80;
let mut mask = [0; 32];
mask[0] = 0xc0;
detached.cursor_state.hide();
detached
.cursor_state
.install(crate::display::CursorImage::mono(data, mask, 3, 4));
assert_eq!(loaded.cursor_level(), 0);
assert_eq!(loaded.cursor_data(), Some(TrapDispatcher::default_arrow_cursor()));
assert_eq!(detached.cursor_level(), -1);
assert_eq!(detached.cursor_data(), Some((data, mask, 3, 4)));
}
#[test]
fn attached_cursor_visibility_mutations_cross_isa_immediately() {
let pef = synthetic_pef_with_import(b"HideCursor");
let mut native = load_pef_application(&pef).unwrap();
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let probe = native.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(classic.cursor_level(), -1);
assert!(!classic.cursor_visible());
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_dialog(true, 0x053, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(native.cursor_level(), 0);
}
#[test]
fn attached_cursor_image_mutations_cross_isa_immediately() {
let pef = synthetic_pef_with_import(b"SetCursor");
let mut native = load_pef_application(&pef).unwrap();
let (mut classic, mut classic_cpu, mut classic_bus) = setup_with_port();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let native_cursor = PPC_DATA_BASE + 0x1000;
let mut native_data = [0; 32];
native_data[0] = 0x80;
let mut native_mask = [0; 32];
native_mask[0] = 0xc0;
let mut cursor = vec![0; 68];
cursor[..32].copy_from_slice(&native_data);
cursor[32..64].copy_from_slice(&native_mask);
cursor[64..66].copy_from_slice(&3u16.to_be_bytes());
cursor[66..68].copy_from_slice(&4u16.to_be_bytes());
native.memory.add_region(native_cursor, cursor);
native.cpu.gpr[3] = native_cursor;
let probe = native.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(classic.cursor_data(), Some((native_data, native_mask, 3, 4)));
let classic_cursor = 0x0002_0000;
let mut classic_data = [0; 32];
classic_data[0] = 0x40;
let mut classic_mask = [0; 32];
classic_mask[0] = 0xe0;
for (index, byte) in classic_data.iter().enumerate() {
classic_bus.write_byte(classic_cursor + index as u32, *byte);
}
for (index, byte) in classic_mask.iter().enumerate() {
classic_bus.write_byte(classic_cursor + 32 + index as u32, *byte);
}
classic_bus.write_word(classic_cursor + 64, 5);
classic_bus.write_word(classic_cursor + 66, 6);
classic_bus.write_long(TEST_SP, classic_cursor);
classic_cpu.write_reg(Register::A7, TEST_SP);
assert!(classic
.dispatch_dialog(true, 0x051, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(native.cursor_data(), Some((classic_data, classic_mask, 5, 6)));
}
#[test]
fn attached_control_manager_metadata_crosses_isa_immediately() {
let mut native =
load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
let (mut classic, _classic_cpu, mut classic_bus) = setup_with_port();
let mut context = ProcessContext::default();
classic.attach_unconverted_process_services(&mut context);
native.attach_unconverted_process_services(&mut context);
let window = classic_bus.alloc(180);
let (classic_handle, classic_pointer) = classic.create_control_record(
&mut classic_bus,
window,
(10, 20, 30, 140),
b"Mode",
true,
1,
300,
96,
1009,
0,
);
let classic_record = native
.controls
.records()
.into_iter()
.find(|record| record.handle == classic_handle)
.unwrap();
assert_eq!(classic_record.pointer, classic_pointer);
assert_eq!(classic_record.proc_id, 1009);
assert_eq!(classic_record.popup_menu_id, 300);
assert_eq!(classic_record.popup_title_width, Some(96));
native.controls.register(0x0030_1000, 0x0030_2000, 16, 0);
assert_eq!(classic.control_manager.proc_id(0x0030_2000), 16);
classic.dispose_control_handle(&mut classic_bus, classic_handle);
assert!(!native.controls.contains_handle(classic_handle));
native.controls.remove_handle(0x0030_1000);
assert!(!classic.control_manager.contains_pointer(0x0030_2000));
}
#[test]
fn cloned_native_adapter_detaches_control_manager_metadata() {
let original =
load_pef_application(&synthetic_pef_with_import(b"TestImport")).unwrap();
original
.controls
.register(0x0031_1000, 0x0031_2000, 1, 0);
let detached = original.clone();
detached.controls.set_proc_id(0x0031_2000, 2);
detached
.controls
.register(0x0031_3000, 0x0031_4000, 16, 0);
assert_eq!(original.controls.proc_id(0x0031_2000), 1);
assert_eq!(detached.controls.proc_id(0x0031_2000), 2);
assert!(!original.controls.contains_handle(0x0031_3000));
}
#[test]
fn hle_import_runner_handles_color_cursor_resources() {
let pef = synthetic_pef_with_import(b"GetCCursor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_current_resource_refnum(5);
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: 5,
path: "Gridz Demo/Gridz Demo".to_string(),
res_type: u32::from_be_bytes(*b"crsr"),
res_id: 128,
name: b"Gridz Cursor".to_vec(),
data: (0..96).map(|value| value as u8).collect(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 128;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let handle = loaded.cpu.gpr[3];
assert_ne!(handle, 0);
assert_eq!(loaded.process_file_system.vfs_resources[0].handle, handle);
let cursor_ptr = loaded.memory.read_u32_be(handle).unwrap();
assert_eq!(loaded.memory.read_u8(cursor_ptr + 20), Some(20));
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 128;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], handle);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 999;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.test_resource_error(), PPC_RES_NOT_FOUND_ERR);
}
#[test]
fn hle_import_runner_handles_cursor_resources_and_system_fallbacks() {
let pef = synthetic_pef_with_import(b"GetCursor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_current_resource_refnum(5);
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: 5,
path: "Gridz Demo/Gridz Demo".to_string(),
res_type: u32::from_be_bytes(*b"CURS"),
res_id: 128,
name: b"Gridz Cursor".to_vec(),
data: (0..68).map(|value| value as u8).collect(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 128;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let handle = loaded.cpu.gpr[3];
assert_ne!(handle, 0);
assert_eq!(loaded.process_file_system.vfs_resources[0].handle, handle);
let cursor_ptr = loaded.memory.read_u32_be(handle).unwrap();
assert_eq!(loaded.memory.read_u8(cursor_ptr + 20), Some(20));
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let system_handle = loaded.cpu.gpr[3];
assert_ne!(system_handle, 0);
let system_cursor_ptr = loaded.memory.read_u32_be(system_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(system_cursor_ptr + 64), Some(7));
assert_eq!(loaded.memory.read_u16_be(system_cursor_ptr + 66), Some(7));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], system_handle);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 999;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.test_resource_error(), PPC_RES_NOT_FOUND_ERR);
}
#[test]
fn hle_import_runner_gets_plots_and_disposes_color_icons() {
let pef = synthetic_pef_with_import(b"GetCIcon");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_current_resource_refnum(5);
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: 5,
path: "Escape Velocity".to_string(),
res_type: u32::from_be_bytes(*b"cicn"),
res_id: 128,
name: b"Pilot".to_vec(),
data: test_one_bit_cicon(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 128;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let icon_handle = loaded.cpu.gpr[3];
let icon_ptr = loaded.memory.read_u32_be(icon_handle).unwrap();
let color_table_handle = loaded.memory.read_u32_be(icon_ptr + 42).unwrap();
let pixel_data_handle = loaded.memory.read_u32_be(icon_ptr + 78).unwrap();
assert_ne!(icon_handle, 0);
assert_ne!(color_table_handle, 0);
assert_ne!(pixel_data_handle, 0);
assert_eq!(
loaded.memory.read_u32_be(icon_ptr + 50),
Some(icon_ptr + 82)
);
assert_eq!(
loaded.memory.read_u32_be(icon_ptr + 64),
Some(icon_ptr + 83)
);
assert_eq!(test_handle_records!(loaded).len(), 3);
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 1, 2, 2, 10).unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::PlotCIcon;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = icon_handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, *loaded.current_gworld).unwrap();
let red_index = pict::closest_clut_index(0xffff, 0, 0, &loaded.screen_clut);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (2, 1)),
Some(u16::from(red_index))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (5, 1)),
Some(u16::from(red_index))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (6, 1)),
Some(0)
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeCIcon;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = icon_handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(icon_handle), Some(0));
assert!(test_handle_records!(loaded).is_empty());
assert_eq!(loaded.free_handle_blocks().len(), 3);
}
#[test]
fn hle_import_runner_handles_color_cursor_procedures() {
let pef = synthetic_pef_with_import(b"SetCCursor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE);
let pef = synthetic_pef_with_import(b"DisposeCCursor");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE);
let pef = synthetic_pef_with_import(b"SetCursor");
let mut loaded = load_pef_application(&pef).unwrap();
let cursor_ptr = PPC_DATA_BASE + 0x1000;
let mut cursor = vec![0; 68];
cursor[0] = 0x80;
cursor[32] = 0xc0;
cursor[64..66].copy_from_slice(&3u16.to_be_bytes());
cursor[66..68].copy_from_slice(&4u16.to_be_bytes());
loaded.memory.add_region(cursor_ptr, cursor);
loaded.cpu.gpr[3] = cursor_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], cursor_ptr);
let (data, mask, hot_v, hot_h) = loaded.cursor_data().expect("installed cursor");
assert_eq!(data[0], 0x80);
assert_eq!(mask[0], 0xc0);
assert_eq!(hot_v, 3);
assert_eq!(hot_h, 4);
}
#[test]
fn hle_import_runner_handles_color2_index() {
let pef = synthetic_pef_with_import(b"Color2Index");
let mut loaded = load_pef_application(&pef).unwrap();
let color_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(color_ptr, vec![0; 8]);
ppc_write_rgb_color(&mut loaded.memory, color_ptr, PPC_RGB_BLACK).unwrap();
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 255);
ppc_write_rgb_color(&mut loaded.memory, color_ptr, PPC_RGB_WHITE).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
let teal = PpcRgbColor {
red: 0,
green: 0x8000,
blue: 0x8000,
};
ppc_write_rgb_color(&mut loaded.memory, color_ptr, teal).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.cpu.gpr[3],
u32::from(pict::closest_clut_index(
teal.red,
teal.green,
teal.blue,
&TrapDispatcher::standard_mac_8bpp_clut(),
))
);
loaded
.memory
.write_u16_be(PPC_MAIN_PIXMAP + 32, 16)
.unwrap();
ppc_write_rgb_color(&mut loaded.memory, color_ptr, PPC_RGB_WHITE).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x7fff);
}
#[test]
fn hle_import_runner_handles_index2_color() {
let pef = synthetic_pef_with_import(b"Index2Color");
let mut loaded = load_pef_application(&pef).unwrap();
let color_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(color_ptr, vec![0; 8]);
loaded.cpu.gpr[3] = 255;
loaded.cpu.gpr[4] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let [red, green, blue] = TrapDispatcher::standard_mac_8bpp_clut()[255];
assert_eq!(
ppc_read_rgb_color(&mut loaded.memory, color_ptr),
Some(PpcRgbColor { red, green, blue })
);
}
#[test]
fn hle_import_runner_converts_one_bit_bitmaps_to_regions() {
let pef = synthetic_pef_with_import(b"BitMapToRegion");
let mut loaded = load_pef_application(&pef).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let bitmap = PPC_DATA_BASE + 0x1000;
let pixels = bitmap + 0x40;
loaded.memory.add_region(bitmap, vec![0; 0x80]);
loaded.memory.write_u32_be(bitmap, pixels).unwrap();
loaded.memory.write_u16_be(bitmap + 4, 1).unwrap();
ppc_write_rect(&mut loaded.memory, bitmap + 6, 0, 0, 1, 8).unwrap();
loaded.memory.write_u8(pixels, 0b1011_0000).unwrap();
let region = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
loaded.cpu.gpr[3] = region;
loaded.cpu.gpr[4] = bitmap;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, region),
Some((0, 0, 1, 4))
);
let storage = ppc_region_storage(&mut loaded.memory, region).unwrap();
assert_eq!(
ppc_region_rows_for_band(&storage, 0, 1),
Some(vec![vec![0, 1, 2, 4]])
);
loaded.memory.write_u16_be(bitmap + 4, 0x8001).unwrap();
loaded.memory.write_u16_be(bitmap + 32, 8).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = region;
loaded.cpu.gpr[4] = bitmap;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PIXMAP_TOO_DEEP_ERR));
}
#[test]
fn hle_import_runner_handles_region_basics() {
let pef = synthetic_pef_with_import(b"NewRgn");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let rgn_handle = loaded.cpu.gpr[3];
assert_ne!(rgn_handle, 0);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let rgn_ptr = loaded.memory.read_u32_be(rgn_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(rgn_ptr), Some(10));
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, rgn_handle),
Some((0, 0, 0, 0))
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyRgn;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = rgn_handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetRectRgn;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = rgn_handle;
loaded.cpu.gpr[4] = 10;
loaded.cpu.gpr[5] = 20;
loaded.cpu.gpr[6] = 110;
loaded.cpu.gpr[7] = 220;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, rgn_handle),
Some((20, 10, 220, 110))
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyRgn;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = rgn_handle;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn open_and_close_rgn_record_guest_outline_bounds() {
let pef = synthetic_pef_with_import(b"NewRgn");
let mut loaded = load_pef_application(&pef).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let destination = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
assert_ne!(destination, 0);
let mut handle_states = loaded.handle_states();
ppc_open_rgn(
None,
&mut loaded.memory,
PPC_MAIN_GWORLD,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
Some(&mut handle_states),
&mut loaded.toolbox_startup,
);
loaded.replace_handle_states(handle_states);
assert_ne!(loaded.toolbox_startup.open_region_save_handle, 0);
assert_eq!(
loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_RGN_SAVE_OFFSET),
Some(loaded.toolbox_startup.open_region_save_handle)
);
assert_eq!(
loaded
.memory
.read_u16_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_PN_VIS_OFFSET),
Some(u16::MAX)
);
for (h, v) in [(10, 20), (110, 20), (110, 70), (10, 70), (10, 20)] {
ppc_open_region_include_point(&mut loaded.toolbox_startup, h, v);
}
let mut handle_states = loaded.handle_states();
ppc_close_rgn(
None,
&mut loaded.memory,
destination,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
Some(&mut handle_states),
&mut loaded.toolbox_startup,
);
loaded.replace_handle_states(handle_states);
assert_eq!(last_mem_error, PPC_NO_ERR);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, destination),
Some((20, 10, 70, 110))
);
assert_eq!(
loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_RGN_SAVE_OFFSET),
Some(0)
);
assert_eq!(
loaded
.memory
.read_u16_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_PN_VIS_OFFSET),
Some(0)
);
assert_eq!(loaded.toolbox_startup.open_region_port, 0);
}
#[test]
fn open_and_close_rgn_preserve_powerpc_curved_shape_rows() {
let pef = synthetic_pef_with_import(b"FrameOval");
let mut loaded = load_pef_application(&pef).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 16]);
ppc_write_rect(&mut loaded.memory, scratch, 10, 10, 30, 30).unwrap();
ppc_write_rect(&mut loaded.memory, scratch + 8, 40, 10, 60, 50).unwrap();
let oval = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
let mut handle_states = loaded.handle_states();
ppc_open_rgn(
None,
&mut loaded.memory,
PPC_MAIN_GWORLD,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
Some(&mut handle_states),
&mut loaded.toolbox_startup,
);
loaded.replace_handle_states(handle_states);
loaded.cpu.gpr[3] = scratch;
loaded.run_with_hle_imports(64);
let mut handle_states = loaded.handle_states();
ppc_close_rgn(
None,
&mut loaded.memory,
oval,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
Some(&mut handle_states),
&mut loaded.toolbox_startup,
);
loaded.replace_handle_states(handle_states);
assert!(ppc_point_in_region(&mut loaded.memory, oval, 20, 20));
assert!(!ppc_point_in_region(&mut loaded.memory, oval, 10, 10));
assert!(
loaded
.memory
.read_u32_be(oval)
.and_then(|ptr| loaded.memory.read_u16_be(ptr))
.unwrap()
> 10
);
let rounded = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
let mut handle_states = loaded.handle_states();
ppc_open_rgn(
None,
&mut loaded.memory,
PPC_MAIN_GWORLD,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
Some(&mut handle_states),
&mut loaded.toolbox_startup,
);
loaded.replace_handle_states(handle_states);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::FrameRoundRect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = scratch + 8;
loaded.cpu.gpr[4] = 12;
loaded.cpu.gpr[5] = 12;
loaded.run_with_hle_imports(64);
let mut handle_states = loaded.handle_states();
ppc_close_rgn(
None,
&mut loaded.memory,
rounded,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
Some(&mut handle_states),
&mut loaded.toolbox_startup,
);
loaded.replace_handle_states(handle_states);
assert!(ppc_point_in_region(&mut loaded.memory, rounded, 50, 10));
assert!(!ppc_point_in_region(&mut loaded.memory, rounded, 40, 10));
assert!(
loaded
.memory
.read_u32_be(rounded)
.and_then(|ptr| loaded.memory.read_u16_be(ptr))
.unwrap()
> 10
);
}
#[test]
fn powerpc_openpicture_records_and_replays_dynamic_commands() {
// Imaging With QuickDraw (1994), pp. 7-39--7-45: commands issued
// between OpenPicture and ClosePicture are hidden, retained, and replayed.
let pef = synthetic_pef_with_import(b"OpenPicture");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1800;
let frame = scratch;
let color = scratch + 8;
let text = scratch + 16;
let destination = scratch + 32;
loaded.memory.add_region(scratch, vec![0; 64]);
ppc_write_rect(&mut loaded.memory, frame, 0, 0, 40, 40).unwrap();
ppc_write_rgb_color(
&mut loaded.memory,
color,
PpcRgbColor {
red: 0xEEEE,
green: 0x7777,
blue: 0x1111,
},
)
.unwrap();
loaded.memory.write_bytes(text, b"\x04PICT").unwrap();
ppc_write_rect(&mut loaded.memory, destination, 50, 50, 90, 90).unwrap();
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, *loaded.current_gworld)
.unwrap();
let before = ppc_quickdraw_read_pixel(
&mut loaded.memory,
surface.front_buffer,
surface.local_point((20, 20)),
);
loaded.cpu.gpr[3] = frame;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::OpenPicture,
),
);
let handle = loaded.cpu.gpr[3];
assert_ne!(handle, 0);
loaded.cpu.gpr[3] = color;
run_test_import(&mut loaded, PpcImportDispatcherTarget::RGBForeColor);
loaded.cpu.gpr[3] = frame;
loaded.cpu.gpr[4] = 10;
loaded.cpu.gpr[5] = 10;
run_test_import(&mut loaded, PpcImportDispatcherTarget::PaintRoundRect);
loaded.cpu.gpr[3] = frame;
loaded.cpu.gpr[4] = 10;
loaded.cpu.gpr[5] = 10;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FrameRoundRect);
loaded.cpu.gpr[3] = 3;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TextFont);
loaded.cpu.gpr[3] = 9;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TextSize);
loaded.cpu.gpr[3] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::TextFace);
loaded.cpu.gpr[3] = 6;
loaded.cpu.gpr[4] = 25;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MoveTo);
loaded.cpu.gpr[3] = text;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawString);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
surface.front_buffer,
surface.local_point((20, 20)),
),
before,
"recording must not paint into the live port"
);
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::ClosePicture,
),
);
let picture =
ppc_handle_bytes(&mut loaded.memory, &test_handle_records!(loaded), handle).unwrap();
for opcode in [[0x00, 0x41], [0x00, 0x40], [0x00, 0x28]] {
assert!(picture.windows(2).any(|word| word == opcode));
}
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = destination;
assert!(with_test_color_manager_clut!(
loaded,
|color_manager_clut| ppc_draw_picture(
&mut loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
&loaded.process_file_system.vfs_resources,
&loaded.gworlds,
*loaded.current_gworld,
&loaded.screen_clut,
color_manager_clut,
)
));
assert_ne!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
surface.front_buffer,
surface.local_point((70, 70)),
),
before
);
}
#[test]
fn calc_vis_behind_rebuilds_visible_window_regions_below_the_menu_bar() {
let pef = synthetic_pef_with_import(b"CalcVisBehind");
let mut loaded = load_pef_application(&pef).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 10, 40, 110, 240).unwrap();
let mut window_cpu = loaded.cpu.clone();
window_cpu.gpr[3] = 0;
window_cpu.gpr[4] = bounds_ptr;
window_cpu.gpr[6] = 1;
let window = ppc_new_cwindow(
&window_cpu,
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
&mut loaded.gworlds,
&mut loaded.window_list,
*loaded.current_gdevice,
);
assert_ne!(window, 0);
let clobbered_rgn = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
ppc_write_rgn_bbox(&mut loaded.memory, clobbered_rgn, 0, 0, 200, 300).unwrap();
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = clobbered_rgn;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let vis_rgn = loaded.memory.read_u32_be(window + 24).unwrap();
assert_ne!(vis_rgn, 0);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, vis_rgn),
Some((10, 0, 100, 200))
);
}
#[test]
fn paint_behind_nil_draws_the_classic_desktop_inside_the_clobbered_region() {
let pef = synthetic_pef_with_import(b"PaintBehind");
let mut loaded = load_pef_application(&pef).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let clobbered_rgn = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
ppc_write_rgn_bbox(&mut loaded.memory, clobbered_rgn, 20, 0, 22, 2).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = clobbered_rgn;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (0, 20)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(
ppc_standard_desktop_color(&loaded.gworlds, 0, 0)
)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (1, 20)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(
ppc_standard_desktop_color(&loaded.gworlds, 1, 0)
)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (0, 21)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(
ppc_standard_desktop_color(&loaded.gworlds, 1, 0)
)))
);
}
#[test]
fn paint_one_erases_exposed_content_and_updates_the_window_region() {
let pef = synthetic_pef_with_import(b"PaintOne");
let mut loaded = load_pef_application(&pef).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let bounds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(bounds_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, bounds_ptr, 30, 40, 130, 240).unwrap();
let mut window_cpu = loaded.cpu.clone();
window_cpu.gpr[3] = 0;
window_cpu.gpr[4] = bounds_ptr;
window_cpu.gpr[6] = 1;
let window = ppc_new_cwindow(
&window_cpu,
None,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
&mut loaded.gworlds,
&mut loaded.window_list,
*loaded.current_gdevice,
);
assert_ne!(window, 0);
let clobbered_rgn = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
ppc_write_rgn_bbox(&mut loaded.memory, clobbered_rgn, 35, 45, 45, 55).unwrap();
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
ppc_quickdraw_write_pixel(&mut loaded.memory, front, (50, 40), PPC_RGB_BLACK);
loaded.cpu.gpr[3] = window;
loaded.cpu.gpr[4] = clobbered_rgn;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let update_rgn = loaded
.memory
.read_u32_be(window + PPC_CWINDOW_UPDATE_RGN_OFFSET)
.unwrap();
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, update_rgn),
Some((35, 45, 45, 55))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (50, 40)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(PPC_RGB_WHITE)))
);
}
#[test]
fn hle_import_runner_handles_rect_rgn() {
let pef = synthetic_pef_with_import(b"RectRgn");
let mut loaded = load_pef_application(&pef).unwrap();
let rgn_ptr = PPC_DATA_BASE + 0x1000;
let rgn_handle = PPC_DATA_BASE + 0x1100;
let rect_ptr = PPC_DATA_BASE + 0x1200;
loaded.memory.add_region(rgn_ptr, vec![0; 10]);
loaded.memory.add_region(rgn_handle, vec![0; 4]);
loaded.memory.add_region(rect_ptr, vec![0; 8]);
loaded.memory.write_u32_be(rgn_handle, rgn_ptr).unwrap();
ppc_write_rect(&mut loaded.memory, rect_ptr, 3, 4, 30, 40).unwrap();
loaded.cpu.gpr[3] = rgn_handle;
loaded.cpu.gpr[4] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(rgn_ptr), Some(10));
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, rgn_handle),
Some((3, 4, 30, 40))
);
}
#[test]
fn hle_import_runner_copies_complete_region_storage() {
let pef = synthetic_pef_with_import(b"NewRgn");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.run_with_hle_imports(64);
let src_rgn = loaded.cpu.gpr[3];
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.run_with_hle_imports(64);
let dst_rgn = loaded.cpu.gpr[3];
assert_eq!(
ppc_set_handle_size(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
src_rgn,
16,
),
PPC_NO_ERR
);
let src_ptr = loaded.memory.read_u32_be(src_rgn).unwrap();
let region = [0, 16, 0, 1, 0, 2, 0, 20, 0, 30, 0, 3, 0, 10, 0x7f, 0xff];
for (offset, byte) in region.into_iter().enumerate() {
loaded
.memory
.write_u8(src_ptr + offset as u32, byte)
.unwrap();
}
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::CopyRgn;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = src_rgn;
loaded.cpu.gpr[4] = dst_rgn;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let dst_ptr = loaded.memory.read_u32_be(dst_rgn).unwrap();
assert_ne!(src_ptr, dst_ptr);
let copied = (0..16)
.map(|offset| loaded.memory.read_u8(dst_ptr + offset).unwrap())
.collect::<Vec<_>>();
assert_eq!(copied, region);
loaded.memory.write_u8(src_ptr + 10, 0xaa).unwrap();
assert_eq!(loaded.memory.read_u8(dst_ptr + 10), Some(0));
}
#[test]
fn hle_import_runner_unions_disjoint_rectangles_as_complex_region() {
let pef = synthetic_pef_with_import(b"NewRgn");
let mut loaded = load_pef_application(&pef).unwrap();
let mut regions = Vec::new();
for _ in 0..3 {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.run_with_hle_imports(64);
regions.push(loaded.cpu.gpr[3]);
}
ppc_write_rgn_bbox(&mut loaded.memory, regions[0], 0, 0, 2, 2).unwrap();
ppc_write_rgn_bbox(&mut loaded.memory, regions[1], 0, 3, 2, 5).unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::UnionRgn;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = regions[0];
loaded.cpu.gpr[4] = regions[1];
loaded.cpu.gpr[5] = regions[2];
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
let storage = ppc_region_storage(&mut loaded.memory, regions[2]).unwrap();
assert!(storage.len() > 10);
assert_eq!(ppc_region_storage_bbox(&storage), Some((0, 0, 2, 5)));
assert_eq!(
ppc_region_rows_for_band(&storage, 0, 2),
Some(vec![vec![0, 2, 3, 5], vec![0, 2, 3, 5]])
);
}
#[test]
fn hle_import_runner_draws_quickdraw_color_rects_into_current_gworld() {
let pef = synthetic_pef_with_import(b"ForeColor");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let color_ptr = scratch;
let rect_ptr = scratch + 8;
loaded.memory.add_region(scratch, vec![0; 32]);
loaded.cpu.gpr[3] = 205; // redColor
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_fore_color, ppc_legacy_qd_color_to_rgb(205));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetForeColor;
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_rgb_color(&mut loaded.memory, color_ptr),
Some(ppc_legacy_qd_color_to_rgb(205))
);
let green = PpcRgbColor {
red: 0,
green: 0xffff,
blue: 0,
};
ppc_write_rgb_color(&mut loaded.memory, color_ptr, green).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::RGBForeColor;
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_fore_color, green);
ppc_write_rect(&mut loaded.memory, rect_ptr, 1, 2, 4, 5).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::PaintRect;
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (2, 1)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(green)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (4, 3)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(green)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (1, 1)),
Some(0)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::BackColor;
loaded.cpu.gpr[3] = 409; // blueColor
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_back_color, ppc_legacy_qd_color_to_rgb(409));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetBackColor;
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_rgb_color(&mut loaded.memory, color_ptr),
Some(ppc_legacy_qd_color_to_rgb(409))
);
let cyan = PpcRgbColor {
red: 0,
green: 0xffff,
blue: 0xffff,
};
ppc_write_rgb_color(&mut loaded.memory, color_ptr, cyan).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::RGBBackColor;
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_back_color, cyan);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetBackColor;
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_rgb_color(&mut loaded.memory, color_ptr),
Some(cyan)
);
ppc_write_rect(&mut loaded.memory, rect_ptr, 2, 3, 5, 6).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::EraseRect;
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (3, 2)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(cyan)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (2, 1)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(green)))
);
let red = PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
};
ppc_write_rgb_color(&mut loaded.memory, color_ptr, red).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::RGBForeColor;
loaded.cpu.gpr[3] = color_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
ppc_write_rect(&mut loaded.memory, rect_ptr, 6, 6, 9, 9).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::FrameRect;
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (6, 6)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(red)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (8, 8)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(red)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (7, 7)),
Some(0)
);
}
#[test]
fn hle_import_runner_restores_quickdraw_colors_when_switching_ports() {
let pef = synthetic_pef_with_import(b"ForeColor");
let mut loaded = load_pef_application(&pef).unwrap();
let offscreen_port = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(offscreen_port, vec![0; PPC_CGRAF_PORT_SIZE as usize]);
loaded
.memory
.write_u16_be(offscreen_port + 6, 0xc000)
.unwrap();
ppc_write_rgb_color(
&mut loaded.memory,
offscreen_port + PPC_CGRAF_PORT_RGB_FG_COLOR_OFFSET,
PPC_RGB_BLACK,
)
.unwrap();
ppc_write_rgb_color(
&mut loaded.memory,
offscreen_port + PPC_CGRAF_PORT_RGB_BK_COLOR_OFFSET,
PPC_RGB_WHITE,
)
.unwrap();
let red = ppc_legacy_qd_color_to_rgb(205);
loaded.cpu.gpr[3] = 205;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.quickdraw_fore_color, red);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetPort;
loaded.cpu.gpr[3] = offscreen_port;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.quickdraw_fore_color, PPC_RGB_BLACK);
let green = ppc_legacy_qd_color_to_rgb(341);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::ForeColor;
loaded.cpu.gpr[3] = 341;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.quickdraw_fore_color, green);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetPort;
loaded.cpu.gpr[3] = PPC_MAIN_GWORLD;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.quickdraw_fore_color, red);
assert_eq!(
ppc_read_rgb_color(
&mut loaded.memory,
offscreen_port + PPC_CGRAF_PORT_RGB_FG_COLOR_OFFSET,
),
Some(green)
);
}
#[test]
fn hle_import_runner_erases_oval_with_the_background_color() {
let pef = synthetic_pef_with_import(b"EraseOval");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 10, 20, 20, 30).unwrap();
let cyan = PpcRgbColor {
red: 0,
green: 0xffff,
blue: 0xffff,
};
loaded.quickdraw_back_color = cyan;
loaded.cpu.gpr[3] = rect_ptr;
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, *loaded.current_gworld).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (25, 15)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(cyan)))
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (20, 10)),
Some(0)
);
}
#[test]
fn hle_import_runner_inverts_quickdraw_rect_pixels() {
let pef = synthetic_pef_with_import(b"InvertRect");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 1, 2, 4, 5).unwrap();
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, *loaded.current_gworld).unwrap();
assert_eq!(front.depth, 8);
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
front,
(2, 1),
0x12,
));
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
front,
(1, 1),
0x34,
));
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (2, 1)),
Some(0xed)
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (1, 1)),
Some(0x34)
);
}
#[test]
fn hle_import_runner_inverts_one_bit_bitmap_before_region_conversion() {
let pef = synthetic_pef_with_import(b"InvertRect");
let mut loaded = load_pef_application(&pef).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 0, 0, 1, 8).unwrap();
let port = PPC_HEAP_BASE + 0x1000;
let pixels = PPC_HEAP_BASE + 0x2000;
loaded.memory.add_region(port, vec![0; 0x80]);
loaded.memory.add_region(pixels, vec![0b1011_0000]);
loaded.memory.write_u32_be(port + 2, pixels).unwrap();
loaded.memory.write_u16_be(port + 6, 1).unwrap();
ppc_write_rect(&mut loaded.memory, port + 8, 0, 0, 1, 8).unwrap();
ppc_write_rect(&mut loaded.memory, port + 16, 0, 0, 1, 8).unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle: 0,
pixmap: 0,
base_addr: pixels,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 1,
depth: 1,
row_bytes: 1,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = port);
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(pixels), Some(0b0100_1111));
let region = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::BitMapToRegion;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = region;
loaded.cpu.gpr[4] = port + 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
ppc_read_rgn_bbox(&mut loaded.memory, region),
Some((0, 1, 1, 8))
);
let storage = ppc_region_storage(&mut loaded.memory, region).unwrap();
assert_eq!(
ppc_region_rows_for_band(&storage, 0, 1),
Some(vec![vec![1, 2, 4, 8]])
);
assert!(ppc_point_in_region_storage(&storage, 0, 1));
assert!(!ppc_point_in_region_storage(&storage, 0, 0));
}
#[test]
fn hle_import_runner_inverts_only_pixels_inside_quickdraw_region() {
let pef = synthetic_pef_with_import(b"InvertRgn");
let mut loaded = load_pef_application(&pef).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let region = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
ppc_write_rgn_bbox(&mut loaded.memory, region, 1, 2, 4, 5).unwrap();
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, *loaded.current_gworld).unwrap();
assert_eq!(front.depth, 8);
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
front,
(2, 1),
0x12,
));
assert!(ppc_quickdraw_write_raw_pixel(
&mut loaded.memory,
front,
(1, 1),
0x34,
));
loaded.cpu.gpr[3] = region;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (2, 1)),
Some(0xed)
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (1, 1)),
Some(0x34)
);
}
#[test]
fn quickdraw_uses_the_live_pixmap_coordinate_origin_and_color_table() {
let pef = synthetic_pef_with_import(b"PaintRect");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let port = scratch;
let pixmap_handle = scratch + 0x100;
let pixmap = scratch + 0x200;
let stale_pixels = scratch + 0x300;
let live_pixels = scratch + 0x400;
let rect = scratch + 0x500;
let ctable_handle = scratch + 0x520;
let ctable = scratch + 0x540;
loaded.memory.add_region(scratch, vec![0; 0x600]);
loaded.memory.write_u32_be(port + 2, pixmap_handle).unwrap();
loaded.memory.write_u16_be(port + 6, 0xc000).unwrap();
loaded.memory.write_u32_be(pixmap_handle, pixmap).unwrap();
ppc_write_pixmap(
&mut loaded.memory,
pixmap,
live_pixels,
4,
320,
100,
323,
104,
8,
)
.unwrap();
loaded
.memory
.write_u32_be(pixmap + 42, ctable_handle)
.unwrap();
loaded.memory.write_u32_be(ctable_handle, ctable).unwrap();
loaded.memory.write_u16_be(ctable + 4, 0).unwrap();
loaded.memory.write_u16_be(ctable + 6, 0).unwrap();
loaded.memory.write_u16_be(ctable + 8, 77).unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle,
pixmap,
base_addr: stale_pixels,
gdevice: PPC_MAIN_GDEVICE,
width: 4,
height: 3,
depth: 8,
row_bytes: 4,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = port);
loaded.quickdraw_fore_color = PpcRgbColor {
red: 0x1234,
green: 0x5678,
blue: 0x9abc,
};
let [red, green, blue] =
ppc_rgb555_to_rgb16(ppc_rgb_color_to_rgb555(loaded.quickdraw_fore_color));
loaded.memory.write_u16_be(ctable + 10, red).unwrap();
loaded.memory.write_u16_be(ctable + 12, green).unwrap();
loaded.memory.write_u16_be(ctable + 14, blue).unwrap();
// Imaging With QuickDraw (1994), pp. 2-9 and 2-45--2-46: the
// PixMap boundary rectangle defines the port's local coordinate
// system, so these coordinates address the first two rows and
// columns even though neither coordinate begins at zero.
ppc_write_rect(&mut loaded.memory, rect, 320, 100, 322, 102).unwrap();
loaded.cpu.gpr[3] = rect;
let live =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, port).unwrap();
assert_eq!(live.base_addr, live_pixels);
assert_eq!((live.width, live.height, live.depth), (4, 3, 8));
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_ne!(ppc_rgb_color_to_8bpp_index(loaded.quickdraw_fore_color), 77);
assert_eq!(loaded.memory.read_u8(live_pixels), Some(77));
assert_eq!(loaded.memory.read_u8(live_pixels + 5), Some(77));
assert_eq!(loaded.memory.read_u8(stale_pixels), Some(0));
}
#[test]
fn onscreen_color_port_keeps_its_logical_pm_table_during_a_hardware_fade() {
let pef = synthetic_pef_with_import(b"PaintRect");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let port = scratch;
let pixmap_handle = scratch + 0x100;
let pixmap = scratch + 0x200;
let private_ctable_handle = scratch + 0x300;
let private_ctable = scratch + 0x400;
loaded.memory.add_region(scratch, vec![0; 0x1000]);
loaded.memory.write_u32_be(port + 2, pixmap_handle).unwrap();
loaded.memory.write_u16_be(port + 6, 0xc000).unwrap();
loaded.memory.write_u32_be(pixmap_handle, pixmap).unwrap();
ppc_write_pixmap(
&mut loaded.memory,
pixmap,
PPC_MAIN_SCREEN_BASE,
ppc_main_screen_row_bytes(),
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
8,
)
.unwrap();
loaded
.memory
.write_u32_be(pixmap + 42, private_ctable_handle)
.unwrap();
loaded
.memory
.write_u32_be(private_ctable_handle, private_ctable)
.unwrap();
loaded.memory.write_u16_be(private_ctable + 6, 0).unwrap();
loaded.memory.write_u16_be(private_ctable + 8, 42).unwrap();
loaded
.memory
.write_u16_be(private_ctable + 10, 0x4444)
.unwrap();
loaded
.memory
.write_u16_be(private_ctable + 12, 0x5555)
.unwrap();
loaded
.memory
.write_u16_be(private_ctable + 14, 0x6666)
.unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle,
pixmap,
base_addr: PPC_MAIN_SCREEN_BASE,
gdevice: PPC_MAIN_GDEVICE,
width: PPC_MAIN_SCREEN_WIDTH,
height: PPC_MAIN_SCREEN_HEIGHT,
depth: 8,
row_bytes: ppc_main_screen_row_bytes(),
pixels_locked: false,
pixels_no_purge: false,
});
let screen_clut = [[0; 3]; 256];
let color_manager_clut = [[0; 3]; 256];
let clut = ppc_live_gworld_clut(
&mut loaded.memory,
&loaded.gworlds,
port,
&screen_clut,
&color_manager_clut,
);
assert_eq!(clut[42], [0x4444, 0x5555, 0x6666]);
}
#[test]
fn hle_import_runner_draws_quickdraw_primitives_into_8bpp_current_gworld() {
let pef = synthetic_pef_with_import(b"PaintRect");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let port = scratch;
let rect_ptr = scratch + 0x100;
let string_ptr = scratch + 0x120;
let pixels = scratch + 0x200;
loaded.memory.add_region(scratch, vec![0; 0x400]);
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle: 0,
pixmap: 0,
base_addr: pixels,
gdevice: PPC_MAIN_GDEVICE,
width: 16,
height: 16,
depth: 8,
row_bytes: 16,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = port);
loaded
.memory
.write_u16_be(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u16_be(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2, 1)
.unwrap();
let red = PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
};
loaded.quickdraw_fore_color = red;
let red_index = ppc_rgb_color_to_8bpp_index(red);
let pixel_addr = |x: u32, y: u32| pixels + y * 16 + x;
ppc_write_rect(&mut loaded.memory, rect_ptr, 2, 3, 5, 7).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(pixel_addr(3, 2)), Some(red_index));
assert_eq!(loaded.memory.read_u8(pixel_addr(6, 4)), Some(red_index));
assert_eq!(loaded.memory.read_u8(pixel_addr(2, 2)), Some(0));
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::FrameRect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
ppc_write_rect(&mut loaded.memory, rect_ptr, 8, 8, 12, 12).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(pixel_addr(8, 8)), Some(red_index));
assert_eq!(loaded.memory.read_u8(pixel_addr(11, 11)), Some(red_index));
assert_eq!(loaded.memory.read_u8(pixel_addr(9, 9)), Some(0));
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MoveTo;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = 14;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LineTo;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 4;
loaded.cpu.gpr[4] = 14;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
for x in 1..=4 {
assert_eq!(loaded.memory.read_u8(pixel_addr(x, 14)), Some(red_index));
}
loaded.memory.write_u8(string_ptr, 1).unwrap();
loaded.memory.write_u8(string_ptr + 1, b'H').unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MoveTo;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 2;
loaded.cpu.gpr[4] = 10;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DrawString;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = string_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let (glyph, data) =
get_glyph(PPC_QD_TEXT_FONT_DEFAULT, loaded.quickdraw_text_size, 'H').unwrap();
let mut covered = false;
for row in 0..glyph.height as usize {
for col in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + col;
if index < data.len() && data[index] >= 128 {
let x = 2 + i32::from(glyph.origin_x) + col as i32;
let y = 10 + i32::from(glyph.origin_y) + row as i32;
if x >= 0
&& y >= 0
&& x < 16
&& y < 16
&& loaded.memory.read_u8(pixel_addr(x as u32, y as u32)) == Some(red_index)
{
covered = true;
}
}
}
}
assert!(covered, "8bpp DrawString should write covered glyph pixels");
}
#[test]
fn hle_import_runner_does_not_cross_short_two_bit_pixmap_rows() {
let pef = synthetic_pef_with_import(b"FillRect");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1c00;
let port = scratch;
let pixmap_handle = scratch + 0x100;
let pixmap = scratch + 0x120;
let rect = scratch + 0x180;
let pixels = scratch + 0x200;
loaded.memory.add_region(scratch, vec![0; 0x300]);
ppc_write_gworld_port(&mut loaded.memory, port, pixmap_handle, 0, 0, 2, 8).unwrap();
loaded.memory.write_u32_be(pixmap_handle, pixmap).unwrap();
ppc_write_pixmap(&mut loaded.memory, pixmap, pixels, 1, 0, 0, 2, 8, 2).unwrap();
loaded.memory.write_bytes(pixels, &[0x55, 0xa5]).unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle,
pixmap,
base_addr: pixels,
gdevice: PPC_MAIN_GDEVICE,
width: 8,
height: 2,
depth: 2,
row_bytes: 1,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = port);
loaded.quickdraw_fore_indices.insert(port, 2);
ppc_write_rect(&mut loaded.memory, rect, 0, 0, 1, 8).unwrap();
loaded.cpu.gpr[3] = rect;
assert!(ppc_read_pixmap_bits(&mut loaded.memory, pixmap).is_none());
run_test_import(&mut loaded, PpcImportDispatcherTarget::FillRect);
assert_eq!(loaded.memory.read_u8(pixels), Some(0xaa));
assert_eq!(loaded.memory.read_u8(pixels + 1), Some(0xa5));
}
#[test]
fn hle_import_runner_draws_representative_quickdraw_primitives_into_2bpp_gworld() {
const WIDTH: u32 = 9;
const HEIGHT: u32 = 32;
const ROW_BYTES: u32 = 4;
let pef = synthetic_pef_with_import(b"PaintRect");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1800;
let port = scratch;
let rect_ptr = scratch + 0x100;
let string_ptr = scratch + 0x120;
let pixels = scratch + 0x200;
loaded.memory.add_region(scratch, vec![0; 0x400]);
loaded
.memory
.write_bytes(pixels, &vec![0x55; (ROW_BYTES * HEIGHT) as usize])
.unwrap();
loaded.gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle: 0,
pixmap: 0,
base_addr: pixels,
gdevice: PPC_MAIN_GDEVICE,
width: WIDTH,
height: HEIGHT,
depth: 2,
row_bytes: ROW_BYTES,
pixels_locked: false,
pixels_no_purge: false,
});
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = port);
loaded
.memory
.write_u16_be(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u16_be(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2, 1)
.unwrap();
loaded.quickdraw_fore_color = PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
};
loaded.quickdraw_fore_indices.insert(port, 2);
loaded.quickdraw_text_size = 12;
loaded.quickdraw_text_mode = PPC_QD_TEXT_MODE_SRC_OR;
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, port).unwrap();
// Start each field at index 1. PaintRect begins at odd x=1 and must
// replace only x=1..2 within the first packed byte.
ppc_write_rect(&mut loaded.memory, rect_ptr, 0, 1, 1, 3).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::PaintRect);
assert_eq!(loaded.memory.read_u8(pixels), Some(0x69));
assert_eq!(loaded.memory.read_u8(pixels + 1), Some(0x55));
// FillRect begins at odd x=5 and spans the remaining fields of its
// byte without changing the adjacent x=4 field.
ppc_write_rect(&mut loaded.memory, rect_ptr, 1, 5, 2, 8).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FillRect);
assert_eq!(loaded.memory.read_u8(pixels + ROW_BYTES), Some(0x55));
assert_eq!(loaded.memory.read_u8(pixels + ROW_BYTES + 1), Some(0x6a));
// Inverting index 1 at odd x=1..2 produces index 2 while retaining
// both neighbouring fields.
ppc_write_rect(&mut loaded.memory, rect_ptr, 2, 1, 3, 3).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::InvertRect);
assert_eq!(loaded.memory.read_u8(pixels + 2 * ROW_BYTES), Some(0x69));
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = 3;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MoveTo);
loaded.cpu.gpr[3] = 6;
loaded.cpu.gpr[4] = 3;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LineTo);
assert_eq!(loaded.memory.read_u8(pixels + 3 * ROW_BYTES), Some(0x6a));
assert_eq!(
loaded.memory.read_u8(pixels + 3 * ROW_BYTES + 1),
Some(0xa9)
);
let first_covered_glyph_pixel = |ch: char| {
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, ch).unwrap();
for row in 0..glyph.height as usize {
for col in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + col;
if index < data.len() && data[index] >= 128 {
return (
i32::from(glyph.origin_x) + col as i32,
i32::from(glyph.origin_y) + row as i32,
);
}
}
}
panic!("glyph should contain at least one covered pixel");
};
let (glyph_dx, glyph_dy) = first_covered_glyph_pixel('H');
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = 16;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MoveTo);
loaded.cpu.gpr[3] = b'H' as u32;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawChar);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (1 + glyph_dx, 16 + glyph_dy)),
Some(2),
"DrawChar must reach the packed 2bpp destination"
);
loaded.memory.write_u8(string_ptr, 1).unwrap();
loaded.memory.write_u8(string_ptr + 1, b'H').unwrap();
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = 30;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MoveTo);
loaded.cpu.gpr[3] = string_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawString);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (1 + glyph_dx, 30 + glyph_dy)),
Some(2),
"DrawString must reach the packed 2bpp destination"
);
// Width 9 consumes only the high field of byte 2. Every operation
// above must preserve its low six tail bits, the fourth padding byte,
// and the x=0 neighbour on each touched scanline.
for y in 0..HEIGHT {
let row = pixels + y * ROW_BYTES;
assert_eq!(loaded.memory.read_u8(row + 2).unwrap() & 0x3f, 0x15);
assert_eq!(loaded.memory.read_u8(row + 3), Some(0x55));
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (0, y as i32)),
Some(1),
"left neighbour changed on row {y}"
);
}
}
#[test]
fn hle_import_runner_round_trips_quickdraw_pen_state() {
let pef = synthetic_pef_with_import(b"GetPenState");
let mut loaded = load_pef_application(&pef).unwrap();
let state_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(state_ptr, vec![0; 18]);
let expected = [
0x00, 0x0a, 0x00, 0x14, 0x00, 0x02, 0x00, 0x03, 0x00, 0x08, 0xaa, 0x55, 0xaa, 0x55,
0xaa, 0x55, 0xaa, 0x55,
];
loaded
.memory
.write_bytes(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_PN_LOC_OFFSET, &expected)
.unwrap();
loaded.cpu.gpr[3] = state_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, state_ptr, 18),
Some(expected.to_vec())
);
let replacement = [
0x00, 0x1e, 0x00, 0x28, 0x00, 0x04, 0x00, 0x05, 0x00, 0x09, 0xff, 0x00, 0xff, 0x00,
0xff, 0x00, 0xff, 0x00,
];
loaded.memory.write_bytes(state_ptr, &replacement).unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetPenState;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
PPC_MAIN_GWORLD + PPC_CGRAF_PORT_PN_LOC_OFFSET,
18,
),
Some(replacement.to_vec())
);
}
#[test]
fn hle_import_runner_tracks_quickdraw_pen_and_draws_lines_into_current_gworld() {
let pef = synthetic_pef_with_import(b"MoveTo");
let mut loaded = load_pef_application(&pef).unwrap();
let red = PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
};
loaded.quickdraw_fore_color = red;
loaded.cpu.gpr[3] = 2;
loaded.cpu.gpr[4] = 3;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_pen_h, 2);
assert_eq!(loaded.quickdraw_pen_v, 3);
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_GWORLD + 48), Some(3));
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_GWORLD + 50), Some(2));
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (2, 3)),
Some(0)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LineTo;
loaded.cpu.gpr[3] = 6;
loaded.cpu.gpr[4] = 3;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_pen_h, 6);
assert_eq!(loaded.quickdraw_pen_v, 3);
for x in 2..=6 {
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, 3)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(red)))
);
}
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (2, 4)),
Some(0)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 6;
loaded.cpu.gpr[4] = 6;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_pen_h, 6);
assert_eq!(loaded.quickdraw_pen_v, 6);
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_GWORLD + 48), Some(6));
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_GWORLD + 50), Some(6));
for y in 3..=6 {
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (6, y)),
Some(u16::from(ppc_rgb_color_to_8bpp_index(red)))
);
}
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (5, 6)),
Some(0)
);
let clip_rgn = loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_CLIP_RGN_OFFSET)
.unwrap();
ppc_write_rgn_bbox(&mut loaded.memory, clip_rgn, 8, 4, 9, 7).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MoveTo;
loaded.cpu.gpr[3] = 2;
loaded.cpu.gpr[4] = 8;
loaded.run_with_hle_imports(64);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LineTo;
loaded.cpu.gpr[3] = 9;
loaded.cpu.gpr[4] = 8;
loaded.run_with_hle_imports(64);
for x in 2..=9 {
let expected = if (4..7).contains(&x) {
u16::from(ppc_rgb_color_to_8bpp_index(red))
} else {
0
};
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, 8)),
Some(expected)
);
}
ppc_write_rgn_bbox(&mut loaded.memory, clip_rgn, 0, 0, 600, 800).unwrap();
let vis_rgn = loaded
.memory
.read_u32_be(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_VIS_RGN_OFFSET)
.unwrap();
ppc_write_rgn_bbox(&mut loaded.memory, vis_rgn, 12, 4, 13, 7).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MoveTo;
loaded.cpu.gpr[3] = 2;
loaded.cpu.gpr[4] = 12;
loaded.run_with_hle_imports(64);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LineTo;
loaded.cpu.gpr[3] = 9;
loaded.cpu.gpr[4] = 12;
loaded.run_with_hle_imports(64);
for x in 2..=9 {
let expected = if (4..7).contains(&x) {
u16::from(ppc_rgb_color_to_8bpp_index(red))
} else {
0
};
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, 12)),
Some(expected)
);
}
ppc_write_rgn_bbox(&mut loaded.memory, vis_rgn, 0, 0, 600, 800).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::HidePen;
loaded.run_with_hle_imports(64);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MoveTo;
loaded.cpu.gpr[3] = 2;
loaded.cpu.gpr[4] = 10;
loaded.run_with_hle_imports(64);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::LineTo;
loaded.cpu.gpr[3] = 6;
loaded.cpu.gpr[4] = 10;
loaded.run_with_hle_imports(64);
for x in 2..=6 {
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, 10)),
Some(0)
);
}
}
#[test]
fn hle_import_runner_records_and_fills_classic_quickdraw_polygons() {
let pef = synthetic_pef_with_import(b"OpenPoly");
let mut loaded = load_pef_application(&pef).unwrap();
let red = PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
};
loaded.quickdraw_fore_color = red;
loaded.quickdraw_fore_indices.insert(PPC_MAIN_GWORLD, 103);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
let polygon = loaded.cpu.gpr[3];
assert_ne!(polygon, 0);
assert_eq!(
loaded.memory.read_u32_be(PPC_MAIN_GWORLD + 100),
Some(polygon)
);
for (target, h, v) in [
(PpcImportDispatcherTarget::MoveTo, 2, 2),
(PpcImportDispatcherTarget::LineTo, 10, 2),
(PpcImportDispatcherTarget::LineTo, 2, 10),
(PpcImportDispatcherTarget::LineTo, 2, 2),
] {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = target;
loaded.cpu.gpr[3] = h;
loaded.cpu.gpr[4] = v;
loaded.run_with_hle_imports(64);
}
assert_eq!(
ppc_polygon_points(&mut loaded.memory, polygon),
Some(vec![(2, 2), (10, 2), (2, 10), (2, 2)])
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::ClosePoly;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.memory.read_u32_be(PPC_MAIN_GWORLD + 100), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::FillPoly;
loaded.cpu.gpr[3] = polygon;
loaded.run_with_hle_imports(64);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (3, 3)),
Some(103)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::KillPoly;
loaded.cpu.gpr[3] = polygon;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.memory.read_u32_be(polygon), Some(0));
}
#[test]
fn region_membership_and_clip_copy_use_full_region_storage() {
let pef = synthetic_pef_with_import(b"PtInRgn");
let mut loaded = load_pef_application(&pef).unwrap();
let mut last_mem_error = loaded.last_mem_error();
let region = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
ppc_write_rgn_bbox(&mut loaded.memory, region, 5, 10, 20, 30).unwrap();
loaded.cpu.gpr[3] = (6u32 << 16) | 11;
loaded.cpu.gpr[4] = region;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], 1);
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 19, 29, 25, 35).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::RectInRgn;
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = region;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], 1);
let saved = ppc_new_rgn(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
&mut last_mem_error,
test_handles!(loaded),
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetClip;
loaded.cpu.gpr[3] = region;
loaded.run_with_hle_imports(64);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetClip;
loaded.cpu.gpr[3] = saved;
loaded.run_with_hle_imports(64);
assert_eq!(
ppc_region_storage(&mut loaded.memory, saved),
ppc_region_storage(&mut loaded.memory, region)
);
}
#[test]
fn rectangle_fill_respects_disjoint_clip_spans_at_every_depth() {
for depth in [1, 2, 4, 8, 16] {
let mut loaded = load_pef_application_with_config(
&synthetic_pef(),
PpcLoadConfig {
screen_depth: depth,
..PpcLoadConfig::default()
},
)
.unwrap();
assert!(ppc_paint_rect_bounds(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
(0, 0, 8, 10),
PPC_RGB_WHITE,
None
));
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 512]);
let clip = ppc_region_storage_from_rows(2, &vec![vec![1, 3, 5, 9]; 3]).unwrap();
let vis = ppc_region_storage_from_rows(1, &vec![vec![2, 8]; 5]).unwrap();
for (handle, ptr, bytes, field) in [
(scratch, scratch + 16, clip, PPC_CGRAF_PORT_CLIP_RGN_OFFSET),
(
scratch + 4,
scratch + 128,
vis,
PPC_CGRAF_PORT_VIS_RGN_OFFSET,
),
] {
loaded.memory.write_u32_be(handle, ptr).unwrap();
loaded.memory.write_bytes(ptr, &bytes).unwrap();
loaded
.memory
.write_u32_be(PPC_MAIN_GWORLD + field, handle)
.unwrap();
}
let surface =
ppc_live_quickdraw_surface(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let front = surface.front_buffer;
let before: Vec<_> = (0..8)
.flat_map(|y| (0..10).map(move |x| (x, y)))
.map(|point| ppc_quickdraw_read_pixel(&mut loaded.memory, front, point).unwrap())
.collect();
let color =
ppc_quickdraw_surface_fore_pixel(&mut loaded.memory, surface, PPC_RGB_BLACK, None)
.unwrap();
assert!(ppc_paint_rect_bounds(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
(0, 0, 8, 10),
PPC_RGB_BLACK,
None
));
for y in 0..8 {
for x in 0..10 {
let painted = (2..5).contains(&y) && (x == 2 || (5..8).contains(&x));
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, y)),
Some(if painted {
color
} else {
before[(y * 10 + x) as usize]
}),
"depth {depth}, pixel ({x}, {y})"
);
}
}
}
}
#[test]
fn frame_round_rect_respects_the_current_port_clip_region() {
let pef = synthetic_pef_with_import(b"ClipRect");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_DATA_BASE + 0x1000;
let clip_ptr = rect_ptr + 8;
loaded.memory.add_region(rect_ptr, vec![0; 16]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 10, 10, 30, 30).unwrap();
ppc_write_rect(&mut loaded.memory, clip_ptr, 0, 20, 40, 40).unwrap();
loaded.quickdraw_fore_indices.insert(PPC_MAIN_GWORLD, 103);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let clipped_pixel_before = ppc_quickdraw_read_pixel(&mut loaded.memory, front, (10, 20));
loaded.cpu.gpr[3] = clip_ptr;
loaded.run_with_hle_imports(64);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::FrameRoundRect;
loaded.cpu.gpr[3] = rect_ptr;
loaded.cpu.gpr[4] = 8;
loaded.cpu.gpr[5] = 8;
loaded.run_with_hle_imports(64);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (10, 20)),
clipped_pixel_before,
"the rounded rectangle must not draw left of clipRgn"
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (29, 20)),
Some(103),
"the rounded rectangle must draw inside clipRgn"
);
}
#[test]
fn hle_import_runner_draws_quickdraw_text_into_current_gworld() {
let pef = synthetic_pef_with_import(b"TextSize");
let mut loaded = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let string_ptr = scratch;
loaded.memory.add_region(scratch, vec![0; 16]);
loaded.memory.write_u8(string_ptr, 2).unwrap();
loaded.memory.write_u8(string_ptr + 1, b'H').unwrap();
loaded.memory.write_u8(string_ptr + 2, b'i').unwrap();
let red = PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
};
loaded.quickdraw_fore_color = red;
loaded.cpu.gpr[3] = 12;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_text_size, 12);
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_GWORLD + 74), Some(12));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::TextMode;
loaded.cpu.gpr[3] = PPC_QD_TEXT_MODE_SRC_OR as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_text_mode, PPC_QD_TEXT_MODE_SRC_OR);
assert_eq!(
loaded.memory.read_u16_be(PPC_MAIN_GWORLD + 72),
Some(PPC_QD_TEXT_MODE_SRC_OR as u16)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MoveTo;
loaded.cpu.gpr[3] = 20;
loaded.cpu.gpr[4] = 30;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let first_covered_glyph_pixel = |ch: char| {
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, ch).unwrap();
for row in 0..glyph.height as usize {
for col in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + col;
if index < data.len() && data[index] >= 128 {
return (
i32::from(glyph.origin_x) + col as i32,
i32::from(glyph.origin_y) + row as i32,
);
}
}
}
panic!("glyph should contain at least one covered pixel");
};
let (glyph_dx, glyph_dy) = first_covered_glyph_pixel('H');
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DrawChar;
loaded.cpu.gpr[3] = b'H' as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let h_advance = ppc_text_byte_advance(b'H', 12);
assert_eq!(loaded.quickdraw_pen_h, 20 + h_advance);
assert_eq!(loaded.quickdraw_pen_v, 30);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (20 + glyph_dx, 30 + glyph_dy),),
Some(u16::from(ppc_rgb_color_to_8bpp_index(red)))
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::TextWidth;
loaded.cpu.gpr[3] = string_ptr + 1;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 2;
let probe = loaded.run_with_hle_imports(64);
let string_advance = ppc_text_bytes_advance(b"Hi", 12);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], string_advance as u32);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::StringWidth;
loaded.cpu.gpr[3] = string_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], string_advance as u32);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MoveTo;
loaded.cpu.gpr[3] = 50;
loaded.cpu.gpr[4] = 30;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DrawString;
loaded.cpu.gpr[3] = string_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.quickdraw_pen_h, 50 + string_advance);
assert_eq!(loaded.quickdraw_pen_v, 30);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (50 + glyph_dx, 30 + glyph_dy),),
Some(u16::from(ppc_rgb_color_to_8bpp_index(red)))
);
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_GWORLD + 48), Some(30));
assert_eq!(
loaded.memory.read_u16_be(PPC_MAIN_GWORLD + 50),
Some((50 + string_advance) as u16)
);
}
#[test]
fn text_face_writes_the_cgrafport_style_byte() {
let pef = synthetic_pef_with_import(b"TextFace");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.memory
.write_u8(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_TX_FACE_OFFSET + 1, 0xa5)
.unwrap();
loaded.cpu.gpr[3] = QuickDrawTextStyle::BOLD_BIT.into();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
loaded
.memory
.read_u8(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_TX_FACE_OFFSET),
Some(QuickDrawTextStyle::BOLD_BIT)
);
assert_eq!(
loaded
.memory
.read_u8(PPC_MAIN_GWORLD + PPC_CGRAF_PORT_TX_FACE_OFFSET + 1),
Some(0xa5),
"TextFace must not overwrite the adjacent filler byte"
);
loaded.quickdraw_pen_h = 20;
loaded.quickdraw_pen_v = 30;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DrawChar;
loaded.cpu.gpr[3] = b'H'.into();
loaded.run_with_hle_imports(64);
let plain_advance = ppc_text_byte_advance(b'H', loaded.quickdraw_text_size);
assert_eq!(loaded.quickdraw_pen_h, 20 + plain_advance + 1);
}
#[test]
fn input_snapshot_updates_powerpc_low_memory_device_state() {
use crate::memory::globals::addr;
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let mut key_map = [0; PPC_KEY_MAP_SIZE as usize];
key_map[3] = 0x40;
loaded.set_input_snapshot(PpcInputSnapshot {
key_map,
mouse_button: true,
mouse_v: 123,
mouse_h: 456,
});
assert_eq!(loaded.memory.read_u8(addr::MB_STATE), Some(0));
assert_eq!(loaded.memory.read_u8(addr::KEY_MAP_LM + 3), Some(0x40));
for point_addr in [addr::M_TEMP, addr::MOUSE_LOC, addr::MOUSE_LOC2] {
assert_eq!(loaded.memory.read_u16_be(point_addr), Some(123));
assert_eq!(loaded.memory.read_u16_be(point_addr + 2), Some(456));
}
loaded.set_input_snapshot(PpcInputSnapshot::default());
assert_eq!(loaded.memory.read_u8(addr::MB_STATE), Some(0x80));
}
#[test]
fn hle_import_runner_posts_events_with_the_current_mouse_position() {
let pef = synthetic_pef_with_import(b"PostEvent");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_tick_count(42);
loaded.set_clock_cycle_timing(1_000, 0);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_v: 123,
mouse_h: 456,
..PpcInputSnapshot::default()
});
loaded.cpu.gpr[3] = 3;
loaded.cpu.gpr[4] = 0x3120;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.event_queue(),
&VecDeque::from([PpcQueuedEvent {
what: 3,
message: 0x3120,
when: 42,
where_v: 123,
where_h: 456,
modifiers: 0x0080,
}])
);
}
#[test]
fn hle_post_event_uses_current_button_and_modifier_state() {
let pef = synthetic_pef_with_import(b"PostEvent");
let mut loaded = load_pef_application(&pef).unwrap();
let mut key_map = [0; PPC_KEY_MAP_SIZE as usize];
for key_code in [0x37_u8, 0x38, 0x3A, 0x3B] {
key_map[usize::from(key_code >> 3)] |= 1 << (key_code & 0x07);
}
let posted_at = 0x1020_3040;
loaded.set_tick_count(posted_at);
loaded.set_input_snapshot(PpcInputSnapshot {
key_map,
mouse_button: true,
mouse_v: 123,
mouse_h: 456,
});
loaded.cpu.gpr[3] = 3;
loaded.cpu.gpr[4] = 0xA1B2_C3D4;
run_test_import(&mut loaded, PpcImportDispatcherTarget::PostEvent);
let expected_when = posted_at.wrapping_add(4);
assert_eq!(
loaded.event_queue().front(),
Some(PpcQueuedEvent {
what: 3,
message: 0xA1B2_C3D4,
when: expected_when,
where_v: 123,
where_h: 456,
modifiers: 0x1B00,
})
);
assert_eq!(
loaded.toolbox_startup.event_queue_probe.post_result,
Some(PPC_NO_ERR)
);
loaded.set_event_queue([]);
loaded.set_input_snapshot(PpcInputSnapshot {
key_map,
mouse_button: false,
mouse_v: 123,
mouse_h: 456,
});
loaded.cpu.gpr[3] = 3;
loaded.cpu.gpr[4] = 0x0102_0304;
run_test_import(&mut loaded, PpcImportDispatcherTarget::PostEvent);
let event = loaded.event_queue().front().expect("PostEvent must enqueue");
assert_eq!(event.message, 0x0102_0304);
assert_eq!(event.modifiers, 0x1B80);
assert_eq!(event.when, expected_when);
}
#[test]
fn hle_import_runner_posts_events_through_sys_evt_mask_low_memory() {
let pef = synthetic_pef_with_import(b"PostEvent");
let mut loaded = load_pef_application(&pef).unwrap();
let mask_addr = crate::memory::globals::addr::SYS_EVT_MASK;
assert_eq!(
loaded.memory.read_u16_be(mask_addr),
Some(crate::memory::globals::DEFAULT_SYS_EVT_MASK)
);
loaded.cpu.gpr[3] = 4;
loaded.cpu.gpr[4] = 0x1234;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_EVT_NOT_ENB));
assert!(loaded.event_queue().is_empty());
loaded.memory.write_u16_be(mask_addr, 0xffff).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 4;
loaded.cpu.gpr[4] = 0x5678;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.event_queue().front().map(|event| event.what),
Some(4)
);
assert_eq!(
loaded.event_queue().front().map(|event| event.message),
Some(0x5678)
);
}
#[test]
fn hle_import_runner_handles_event_button_and_exit_utilities() {
let pef = synthetic_pef_with_import(b"GetNextEvent");
let mut loaded = load_pef_application(&pef).unwrap();
let event_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(event_ptr, vec![0xaa; 16]);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 123,
mouse_h: 456,
..PpcInputSnapshot::default()
});
loaded.set_clock_cycle_timing(1_000, 0);
loaded.cpu.gpr[3] = 0xffff;
loaded.cpu.gpr[4] = event_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u16_be(event_ptr), Some(0));
assert_eq!(loaded.memory.read_u32_be(event_ptr + 2), Some(0));
assert_eq!(loaded.memory.read_u32_be(event_ptr + 6), Some(0));
assert_eq!(loaded.memory.read_u16_be(event_ptr + 10), Some(123));
assert_eq!(loaded.memory.read_u16_be(event_ptr + 12), Some(456));
assert_eq!(loaded.memory.read_u16_be(event_ptr + 14), Some(0));
let pef = synthetic_pef_with_import(b"GetNextEvent");
let mut loaded = load_pef_application(&pef).unwrap();
let event_ptr = PPC_DATA_BASE + 0x1080;
loaded.memory.add_region(event_ptr, vec![0xaa; 16]);
loaded.set_tick_count(42);
loaded.set_clock_cycle_timing(1_000, 0);
loaded.set_event_queue([PpcQueuedEvent {
what: 3,
message: (0x31 << 8) | 0x20,
when: 42,
where_v: 240,
where_h: 320,
modifiers: 0x0080,
}]);
loaded.cpu.gpr[3] = 0x0008;
loaded.cpu.gpr[4] = event_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
assert_eq!(loaded.memory.read_u16_be(event_ptr), Some(3));
assert_eq!(loaded.memory.read_u32_be(event_ptr + 2), Some(0x3120));
assert_eq!(loaded.memory.read_u32_be(event_ptr + 6), Some(42));
assert_eq!(loaded.memory.read_u16_be(event_ptr + 10), Some(240));
assert_eq!(loaded.memory.read_u16_be(event_ptr + 12), Some(320));
assert_eq!(loaded.memory.read_u16_be(event_ptr + 14), Some(0x0080));
assert!(loaded.event_queue().is_empty());
let pef = synthetic_pef_with_import(b"GetNextEvent");
let mut loaded = load_pef_application(&pef).unwrap();
let event_ptr = PPC_DATA_BASE + 0x1090;
loaded.memory.add_region(event_ptr, vec![0xaa; 16]);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_v: 17,
mouse_h: 19,
..PpcInputSnapshot::default()
});
loaded.set_event_queue([PpcQueuedEvent {
what: 3,
message: (0x31 << 8) | 0x20,
when: 0,
where_v: 240,
where_h: 320,
modifiers: 0x0080,
}]);
loaded.cpu.gpr[3] = 0x0002;
loaded.cpu.gpr[4] = event_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u16_be(event_ptr), Some(0));
assert_eq!(loaded.memory.read_u16_be(event_ptr + 10), Some(17));
assert_eq!(loaded.memory.read_u16_be(event_ptr + 12), Some(19));
assert_eq!(loaded.event_queue().len(), 1);
let pef = synthetic_pef_with_import(b"WaitNextEvent");
let mut loaded = load_pef_application(&pef).unwrap();
let event_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(event_ptr, vec![0xaa; 16]);
loaded.imports[0].symbol_name = "GetNextEvent".to_string();
loaded.cpu.gpr[3] = 0xffff;
loaded.cpu.gpr[4] = event_ptr;
loaded.cpu.gpr[5] = 10;
loaded.cpu.gpr[6] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u16_be(event_ptr), Some(0));
assert!(ppc_run_result_cycles(probe.result) >= PPC_Q3_IDLE_STATE_ONLY_FRAME_EXTRA_CYCLES);
let pef = synthetic_pef_with_import(b"Button");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let pef = synthetic_pef_with_import(b"StillDown");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
let pef = synthetic_pef_with_import(b"StillDown");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
..PpcInputSnapshot::default()
});
loaded.set_event_queue([PpcQueuedEvent {
what: 1,
message: 0,
when: 0,
where_v: 170,
where_h: 352,
modifiers: 0x0080,
}]);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.event_queue().len(), 1);
let pef = synthetic_pef_with_import(b"GetMouse");
let mut loaded = load_pef_application(&pef).unwrap();
let point_ptr = PPC_DATA_BASE + 0x1120;
loaded.memory.add_region(point_ptr, vec![0xaa; 4]);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_v: 250,
mouse_h: 320,
..PpcInputSnapshot::default()
});
loaded.cpu.gpr[3] = point_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(point_ptr), Some(250));
assert_eq!(loaded.memory.read_u16_be(point_ptr + 2), Some(320));
let pef = synthetic_pef_with_import(b"ExitToShell");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
}
#[test]
fn get_mouse_returns_current_port_local_coordinates() {
let pef = synthetic_pef_with_import(b"GetMouse");
let mut loaded = load_pef_application(&pef).unwrap();
let point_ptr = PPC_DATA_BASE + 0x1120;
loaded.memory.add_region(point_ptr, vec![0xaa; 4]);
ppc_write_rect(&mut loaded.memory, PPC_MAIN_PIXMAP + 6, -60, -80, 540, 720).unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_v: 360,
mouse_h: 580,
..PpcInputSnapshot::default()
});
loaded.cpu.gpr[3] = point_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(point_ptr), Some(300));
assert_eq!(loaded.memory.read_u16_be(point_ptr + 2), Some(500));
}
#[test]
fn ppc_vfs_seed_registers_fond_associated_application_font() {
let pef = synthetic_pef_with_import(b"WaitNextEvent");
let mut loaded = load_pef_application(&pef).unwrap();
let family_id = 31001i16;
let font_resource_id = 2558i16;
let point_size = 17i16;
let mut fond = vec![0u8; 60];
fond[2..4].copy_from_slice(&(family_id as u16).to_be_bytes());
fond[52..54].copy_from_slice(&0u16.to_be_bytes());
fond[54..56].copy_from_slice(&(point_size as u16).to_be_bytes());
fond[56..58].copy_from_slice(&0u16.to_be_bytes());
fond[58..60].copy_from_slice(&(font_resource_id as u16).to_be_bytes());
let mut nfnt = vec![0u8; 38];
nfnt[2..4].copy_from_slice(&32u16.to_be_bytes());
nfnt[4..6].copy_from_slice(&32u16.to_be_bytes());
nfnt[6..8].copy_from_slice(&1u16.to_be_bytes());
nfnt[14..16].copy_from_slice(&1u16.to_be_bytes());
nfnt[16..18].copy_from_slice(&9u16.to_be_bytes());
nfnt[18..20].copy_from_slice(&1u16.to_be_bytes());
nfnt[24..26].copy_from_slice(&1u16.to_be_bytes());
nfnt[26] = 0xc0;
nfnt[30..32].copy_from_slice(&1u16.to_be_bytes());
nfnt[32..34].copy_from_slice(&2u16.to_be_bytes());
nfnt[34..36].copy_from_slice(&1u16.to_be_bytes());
nfnt[36..38].copy_from_slice(&1u16.to_be_bytes());
let record = |res_type: [u8; 4], res_id: i16, data: Vec<u8>| PpcVfsResourceRecord {
ref_num: 0,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(res_type),
res_id,
name: Vec::new(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
};
loaded.seed_vfs_files_and_resources(
Vec::new(),
Vec::new(),
vec![
record(*b"FOND", family_id, fond),
record(*b"NFNT", font_resource_id, nfnt),
],
);
let face = crate::quickdraw::fonts::get_font_face(family_id, point_size)
.expect("PPC application font should be registered");
assert_eq!(face.font_id, family_id);
assert_eq!(face.size, point_size);
assert_eq!(face.metrics.ascent, 1);
}
#[test]
fn getkeys_poll_fast_forward_requires_repeated_idle_caller() {
let key_map_ptr = PPC_DATA_BASE + 0x1000;
let mut memory = PpcSectionMem::new();
memory.add_region(key_map_ptr, vec![0xaa; PPC_KEY_MAP_SIZE as usize]);
let mut cpu = PpcCpu::new();
cpu.gpr[3] = key_map_ptr;
cpu.lr = 0x0100_46B8;
let mut idle_poll_counts = HashMap::new();
for _ in 0..PPC_GETKEYS_IDLE_POLL_FAST_FORWARD_THRESHOLD {
let action = dispatch_getkeys_import(
&mut cpu,
&mut memory,
PpcInputSnapshot::default(),
Some(&mut idle_poll_counts),
);
assert_eq!(action, PpcImportAction::ReturnPreserve);
}
let action = dispatch_getkeys_import(
&mut cpu,
&mut memory,
PpcInputSnapshot::default(),
Some(&mut idle_poll_counts),
);
assert_eq!(
action,
PpcImportAction::ReturnPreserveWithExtraCycles(PPC_GETKEYS_IDLE_POLL_EXTRA_CYCLES)
);
for offset in 0..PPC_KEY_MAP_SIZE {
assert_eq!(memory.read_u8(key_map_ptr + offset), Some(0));
}
cpu.lr = 0x0100_4734;
let action = dispatch_getkeys_import(
&mut cpu,
&mut memory,
PpcInputSnapshot::default(),
Some(&mut idle_poll_counts),
);
assert_eq!(action, PpcImportAction::ReturnPreserve);
for _ in 0..=PPC_GETKEYS_IDLE_POLL_FAST_FORWARD_THRESHOLD {
let action =
dispatch_getkeys_import(&mut cpu, &mut memory, PpcInputSnapshot::default(), None);
assert_eq!(
action,
PpcImportAction::ReturnPreserve,
"exact paths must not fast-forward GetKeys"
);
}
let mut input = PpcInputSnapshot::default();
input.key_map[(PPC_KEY_LEFT / 8) as usize] |= 1u8 << (PPC_KEY_LEFT % 8);
let action =
dispatch_getkeys_import(&mut cpu, &mut memory, input, Some(&mut idle_poll_counts));
assert_eq!(action, PpcImportAction::ReturnPreserve);
assert!(idle_poll_counts.is_empty());
}
#[test]
fn button_poll_fast_forward_requires_repeated_idle_caller() {
let mut cpu = PpcCpu::new();
cpu.lr = 0x0102_5D14;
let mut idle_poll_counts = HashMap::new();
for _ in 0..PPC_BUTTON_IDLE_POLL_FAST_FORWARD_THRESHOLD {
let action = dispatch_button_import(
&cpu,
PpcInputSnapshot::default(),
Some(&mut idle_poll_counts),
);
assert_eq!(action, PpcImportAction::Return(0));
}
let action = dispatch_button_import(
&cpu,
PpcInputSnapshot::default(),
Some(&mut idle_poll_counts),
);
assert_eq!(
action,
PpcImportAction::ReturnWithExtraCycles(0, PPC_BUTTON_IDLE_POLL_EXTRA_CYCLES)
);
cpu.lr = 0x0102_5E00;
let action = dispatch_button_import(
&cpu,
PpcInputSnapshot::default(),
Some(&mut idle_poll_counts),
);
assert_eq!(action, PpcImportAction::Return(0));
let action = dispatch_button_import(
&cpu,
PpcInputSnapshot {
mouse_button: true,
..PpcInputSnapshot::default()
},
Some(&mut idle_poll_counts),
);
assert_eq!(action, PpcImportAction::Return(1));
assert!(idle_poll_counts.is_empty());
}
#[test]
fn still_down_requires_pressed_button_without_pending_mouse_events() {
let mut cpu = PpcCpu::new();
cpu.lr = 0x0102_5D14;
let mut idle_poll_counts = HashMap::new();
let pressed = PpcInputSnapshot {
mouse_button: true,
..PpcInputSnapshot::default()
};
let action = dispatch_still_down_import(&cpu, pressed, &VecDeque::new(), None);
assert_eq!(action, PpcImportAction::Return(1));
let event_queue = VecDeque::from([PpcQueuedEvent {
what: 1,
message: 0,
when: 0,
where_v: 172,
where_h: 352,
modifiers: 0x0080,
}]);
let action =
dispatch_still_down_import(&cpu, pressed, &event_queue, Some(&mut idle_poll_counts));
assert_eq!(action, PpcImportAction::Return(0));
idle_poll_counts.clear();
for _ in 0..PPC_BUTTON_IDLE_POLL_FAST_FORWARD_THRESHOLD {
let action = dispatch_still_down_import(
&cpu,
PpcInputSnapshot::default(),
&VecDeque::new(),
Some(&mut idle_poll_counts),
);
assert_eq!(action, PpcImportAction::Return(0));
}
let action = dispatch_still_down_import(
&cpu,
PpcInputSnapshot::default(),
&VecDeque::new(),
Some(&mut idle_poll_counts),
);
assert_eq!(
action,
PpcImportAction::ReturnWithExtraCycles(0, PPC_BUTTON_IDLE_POLL_EXTRA_CYCLES)
);
cpu.lr = 0;
let action = dispatch_still_down_import(
&cpu,
PpcInputSnapshot::default(),
&VecDeque::new(),
Some(&mut idle_poll_counts),
);
assert_eq!(action, PpcImportAction::Return(0));
assert!(idle_poll_counts.is_empty());
}
#[test]
fn hle_import_runner_event_time_outputs_are_all_or_nothing() {
let pef = synthetic_pef_with_import(b"GetKeys");
let mut loaded = load_pef_application(&pef).unwrap();
let key_map_ptr = PPC_DATA_BASE + 0x1000;
let mut input = PpcInputSnapshot::default();
input.key_map[(PPC_KEY_LEFT / 8) as usize] |= 1u8 << (PPC_KEY_LEFT % 8);
loaded.set_input_snapshot(input);
loaded.memory.add_region(key_map_ptr, vec![0xcc; 4]);
loaded.cpu.gpr[3] = key_map_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
for offset in 0..4 {
assert_eq!(loaded.memory.read_u8(key_map_ptr + offset), Some(0xcc));
}
let pef = synthetic_pef_with_import(b"Microseconds");
let mut loaded = load_pef_application(&pef).unwrap();
let microseconds_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(microseconds_ptr, vec![0xdd; 4]);
loaded.cpu.gpr[3] = microseconds_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.memory.read_u32_be(microseconds_ptr),
Some(0xdddd_dddd)
);
let pef = synthetic_pef_with_import(b"GetDateTime");
let mut loaded = load_pef_application(&pef).unwrap();
let secs_ptr = PPC_DATA_BASE + 0x1180;
loaded.memory.add_region(secs_ptr, vec![0xbb; 2]);
loaded.cpu.gpr[3] = secs_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(secs_ptr), Some(0xbbbb));
let pef = synthetic_pef_with_import(b"GetNextEvent");
let mut loaded = load_pef_application(&pef).unwrap();
let event_ptr = PPC_DATA_BASE + 0x1200;
loaded.memory.add_region(event_ptr, vec![0xee; 4]);
loaded.cpu.gpr[3] = 0xffff;
loaded.cpu.gpr[4] = event_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(event_ptr), Some(0xeeee_eeee));
}
#[test]
fn virtual_tick_count_includes_cycle_phase_and_elapsed_cycles() {
assert_eq!(ppc_virtual_tick_count(42, 1_000, 250, 749), 42);
assert_eq!(ppc_virtual_tick_count(42, 1_000, 250, 750), 43);
assert_eq!(ppc_virtual_tick_count(u32::MAX, 1_000, 0, 1_000), 0);
}
#[test]
fn tick_count_poll_fast_forward_requires_stable_caller_and_tick() {
let mut cpu = PpcCpu::new();
cpu.lr = 0x0103_4560;
let mut idle_poll = PpcTickCountIdlePollState::default();
for _ in 0..PPC_TICK_COUNT_IDLE_POLL_FAST_FORWARD_THRESHOLD {
assert_eq!(
dispatch_tick_count_import(&cpu, 42, 500, Some(&mut idle_poll)),
PpcImportAction::Return(42)
);
}
assert_eq!(
dispatch_tick_count_import(&cpu, 42, 500, Some(&mut idle_poll)),
PpcImportAction::ReturnWithExtraCycles(42, 499)
);
cpu.lr = 0x0103_4600;
assert_eq!(
dispatch_tick_count_import(&cpu, 42, 400, Some(&mut idle_poll)),
PpcImportAction::Return(42),
"a different polling caller must restart detection"
);
assert_eq!(idle_poll.repeat_count, 1);
assert_eq!(
dispatch_tick_count_import(&cpu, 43, 1_000, Some(&mut idle_poll)),
PpcImportAction::Return(43),
"a new TickCount value must restart detection"
);
assert_eq!(
idle_poll.context.as_ref().map(|(lr, tick, _)| (*lr, *tick)),
Some((cpu.lr, 43))
);
assert_eq!(idle_poll.repeat_count, 1);
idle_poll.reset();
assert_eq!(
dispatch_tick_count_import(&cpu, 43, 500, Some(&mut idle_poll)),
PpcImportAction::Return(43),
"an intervening non-TickCount import must restart detection"
);
for _ in 0..=PPC_TICK_COUNT_IDLE_POLL_FAST_FORWARD_THRESHOLD {
assert_eq!(
dispatch_tick_count_import(&cpu, 43, 500, None),
PpcImportAction::Return(43),
"exact dispatcher paths must not fast-forward TickCount"
);
}
}
#[test]
fn hle_import_runner_fast_forwards_tick_count_poll_to_boundary() {
let pef = synthetic_pef_with_import(b"LMGetTicks");
let mut loaded = load_pef_application(&pef).unwrap();
let loop_pc = PPC_DATA_BASE + 0x1100;
let trap_hi = (PPC_IMPORT_TRAP_BASE >> 16) as u16;
let trap_lo = (PPC_IMPORT_TRAP_BASE & 0xffff) as u16;
let mut loop_code = Vec::new();
for word in [
d_form_u(15, 12, 0, trap_hi), // lis r12, trap@ha
d_form_u(24, 12, 12, trap_lo), // ori r12, r12, trap@l
xfx_form(31, 12, 9, 467), // mtctr r12
xl_form(19, 20, 0, 528, true), // bctrl
0x4bff_fffc, // b -4
] {
loop_code.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(loop_pc, loop_code);
loaded.cpu.pc = loop_pc;
loaded.set_tick_count(42);
loaded.set_clock_cycle_timing(1_000, 250);
let probe = loaded.run_with_hle_imports(750);
assert_eq!(ppc_run_result_cycles(probe.result), 750);
assert_eq!(loaded.cpu.gpr[3], 42);
assert!(
probe.handled_import_count
<= PPC_TICK_COUNT_IDLE_POLL_FAST_FORWARD_THRESHOLD.saturating_add(1),
"poll loop executed {} imports instead of returning at the tick boundary",
probe.handled_import_count
);
}
#[test]
fn hle_import_runner_tick_count_poll_respects_smaller_slice_budget() {
let pef = synthetic_pef_with_import(b"LMGetTicks");
let mut loaded = load_pef_application(&pef).unwrap();
let loop_pc = PPC_DATA_BASE + 0x1100;
let trap_hi = (PPC_IMPORT_TRAP_BASE >> 16) as u16;
let trap_lo = (PPC_IMPORT_TRAP_BASE & 0xffff) as u16;
let mut loop_code = Vec::new();
for word in [
d_form_u(15, 12, 0, trap_hi),
d_form_u(24, 12, 12, trap_lo),
xfx_form(31, 12, 9, 467),
xl_form(19, 20, 0, 528, true),
0x4bff_fffc,
] {
loop_code.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(loop_pc, loop_code);
loaded.cpu.pc = loop_pc;
loaded.set_tick_count(42);
loaded.set_clock_cycle_timing(1_000, 250);
let probe = loaded.run_with_hle_imports(100);
assert_eq!(ppc_run_result_cycles(probe.result), 100);
assert_eq!(loaded.cpu.gpr[3], 42);
}
#[test]
fn hle_import_trace_keeps_tick_count_poll_exact() {
let pef = synthetic_pef_with_import(b"LMGetTicks");
let mut loaded = load_pef_application(&pef).unwrap();
let loop_pc = PPC_DATA_BASE + 0x1100;
let trap_hi = (PPC_IMPORT_TRAP_BASE >> 16) as u16;
let trap_lo = (PPC_IMPORT_TRAP_BASE & 0xffff) as u16;
let mut loop_code = Vec::new();
for word in [
d_form_u(15, 12, 0, trap_hi),
d_form_u(24, 12, 12, trap_lo),
xfx_form(31, 12, 9, 467),
xl_form(19, 20, 0, 528, true),
0x4bff_fffc,
] {
loop_code.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(loop_pc, loop_code);
loaded.cpu.pc = loop_pc;
loaded.set_tick_count(42);
loaded.set_clock_cycle_timing(10_000, 0);
let probe = loaded.run_with_hle_import_trace(1_000);
assert_eq!(ppc_run_result_cycles(probe.result), 1_000);
assert!(probe.handled_import_count > 100);
assert_eq!(
probe
.import_trace
.iter()
.map(|entry| entry.repeat_count)
.sum::<u64>(),
u64::from(probe.handled_import_count)
);
}
#[test]
fn hle_import_runner_does_not_accelerate_stateful_tick_count_loop() {
let pef = synthetic_pef_with_import(b"LMGetTicks");
let mut loaded = load_pef_application(&pef).unwrap();
let loop_pc = PPC_DATA_BASE + 0x1100;
let trap_hi = (PPC_IMPORT_TRAP_BASE >> 16) as u16;
let trap_lo = (PPC_IMPORT_TRAP_BASE & 0xffff) as u16;
let mut loop_code = Vec::new();
for word in [
d_form_u(15, 12, 0, trap_hi), // lis r12, trap@ha
d_form_u(24, 12, 12, trap_lo), // ori r12, r12, trap@l
xfx_form(31, 12, 9, 467), // mtctr r12
xl_form(19, 20, 0, 528, true), // bctrl
d_form_u(14, 4, 4, 1), // addi r4,r4,1
0x4bff_fff8, // b -8
] {
loop_code.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(loop_pc, loop_code);
loaded.cpu.pc = loop_pc;
loaded.set_tick_count(42);
loaded.set_clock_cycle_timing(10_000, 0);
let probe = loaded.run_with_hle_imports(1_000);
assert_eq!(ppc_run_result_cycles(probe.result), 1_000);
assert!(
probe.handled_import_count > 100,
"state-changing loop was incorrectly accelerated after {} imports",
probe.handled_import_count
);
assert!(loaded.cpu.gpr[4] > 100);
}
#[test]
fn microseconds_poll_fast_forward_preserves_the_reported_clock() {
let mut cpu = PpcCpu::new();
cpu.lr = 0x0103_4560;
cpu.gpr[3] = PPC_DATA_BASE + 0x1000;
let mut memory = PpcSectionMem::new();
memory.add_region(cpu.gpr[3], vec![0; 8]);
let mut idle_poll_counts = HashMap::new();
let microseconds = 0x1122_3344_5566_7788u64;
for _ in 0..PPC_MICROSECONDS_IDLE_POLL_FAST_FORWARD_THRESHOLD {
assert_eq!(
dispatch_microseconds_import(
&cpu,
&mut memory,
microseconds,
Some(&mut idle_poll_counts)
),
PpcImportAction::ReturnPreserve
);
}
assert_eq!(
dispatch_microseconds_import(
&cpu,
&mut memory,
microseconds,
Some(&mut idle_poll_counts)
),
PpcImportAction::ReturnPreserveWithExtraCycles(PPC_MICROSECONDS_IDLE_POLL_EXTRA_CYCLES)
);
assert_eq!(
memory.read_u32_be(cpu.gpr[3]),
Some((microseconds >> 32) as u32)
);
assert_eq!(
memory.read_u32_be(cpu.gpr[3] + 4),
Some(microseconds as u32)
);
cpu.lr = 0;
assert_eq!(
dispatch_microseconds_import(
&cpu,
&mut memory,
microseconds,
Some(&mut idle_poll_counts)
),
PpcImportAction::ReturnPreserve
);
assert!(idle_poll_counts.is_empty());
}
#[test]
fn hle_import_runner_fast_forwards_microseconds_poll_loops() {
let pef = synthetic_pef_with_import(b"Microseconds");
let mut loaded = load_pef_application(&pef).unwrap();
let microseconds_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(microseconds_ptr, vec![0; 8]);
loaded.cpu.gpr[3] = microseconds_ptr;
let loop_pc = PPC_DATA_BASE + 0x1100;
let trap_hi = (PPC_IMPORT_TRAP_BASE >> 16) as u16;
let trap_lo = (PPC_IMPORT_TRAP_BASE & 0xffff) as u16;
let mut loop_code = Vec::new();
for word in [
d_form_u(15, 12, 0, trap_hi), // lis r12, trap@ha
d_form_u(24, 12, 12, trap_lo), // ori r12, r12, trap@l
xfx_form(31, 12, 9, 467), // mtctr r12
xl_form(19, 20, 0, 528, true), // bctrl
0x4bff_fffc, // b -4
] {
loop_code.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(loop_pc, loop_code);
loaded.cpu.pc = loop_pc;
let probe = loaded.run_with_hle_imports(100_000);
assert!(ppc_run_result_cycles(probe.result) >= 100_000);
assert!(
probe.handled_import_count
<= PPC_MICROSECONDS_IDLE_POLL_FAST_FORWARD_THRESHOLD.saturating_add(20),
"poll loop executed {} imports instead of charging guest cycles",
probe.handled_import_count
);
assert_ne!(loaded.memory.read_u32_be(microseconds_ptr + 4), Some(0));
}
#[test]
fn hle_import_runner_handles_num_to_string() {
let pef = synthetic_pef_with_import(b"NumToString");
let mut loaded = load_pef_application(&pef).unwrap();
let string_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(string_ptr, vec![0xaa; 32]);
loaded.cpu.gpr[3] = (-12345i32) as u32;
loaded.cpu.gpr[4] = string_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, string_ptr).as_deref(),
Some(b"-12345".as_slice())
);
}
mod standard_c_library;
#[test]
fn hle_import_runner_handles_string_to_num() {
let pef = synthetic_pef_with_import(b"StringToNum");
let mut loaded = load_pef_application(&pef).unwrap();
let string_ptr = PPC_DATA_BASE + 0x1000;
let number_ptr = PPC_DATA_BASE + 0x1040;
loaded.memory.add_region(string_ptr, vec![0; 64]);
loaded.memory.add_region(number_ptr, vec![0xaa; 4]);
write_ppc_pstring(&mut loaded.memory, string_ptr, b" -12345x");
loaded.cpu.gpr[3] = string_ptr;
loaded.cpu.gpr[4] = number_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], string_ptr);
assert_eq!(
loaded.memory.read_u32_be(number_ptr),
Some((-12345i32) as u32)
);
}
#[test]
fn hle_import_runner_handles_equal_string() {
let pef = synthetic_pef_with_import(b"EqualString");
let mut loaded = load_pef_application(&pef).unwrap();
let left_ptr = PPC_DATA_BASE + 0x1000;
let right_ptr = PPC_DATA_BASE + 0x1040;
loaded.memory.add_region(left_ptr, vec![0; 64]);
loaded.memory.add_region(right_ptr, vec![0; 64]);
write_ppc_pstring(&mut loaded.memory, left_ptr, b"Gridz");
write_ppc_pstring(&mut loaded.memory, right_ptr, b"gridz");
loaded.cpu.gpr[3] = left_ptr;
loaded.cpu.gpr[4] = right_ptr;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = left_ptr;
loaded.cpu.gpr[4] = right_ptr;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn hle_import_runner_handles_random() {
let pef = synthetic_pef_with_import(b"Random");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.memory
.write_u32_be(PPC_RAND_SEED_ADDR, 12345)
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.memory.read_u32_be(PPC_RAND_SEED_ADDR),
Some(207482415)
);
assert_eq!(loaded.cpu.gpr[3], u32::from(207482415u32 as u16));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_ne!(loaded.cpu.gpr[3], u32::from(207482415u32 as u16));
loaded
.memory
.write_u32_be(PPC_RAND_SEED_ADDR, 32768)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn hle_import_runner_bit_tst_uses_msb_first_bit_offsets() {
let pef = synthetic_pef_with_import(b"BitTst");
let mut loaded = load_pef_application(&pef).unwrap();
let keymap = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(keymap, vec![0; 8]);
// BitTst counts left-to-right from the high-order bit and accepts
// offsets beyond the first byte. Inside Macintosh: Operating System
// Utilities (1994), pp. 3-7 and 3-28.
loaded.memory.write_u8(keymap, 0x20).unwrap();
loaded.memory.write_u8(keymap + 6, 0x40).unwrap();
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::BitTst
);
for bit in [2, 49] {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = keymap;
loaded.cpu.gpr[4] = bit;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 1);
}
loaded.memory.write_u8(keymap, 0).unwrap();
loaded.memory.write_u8(keymap + 6, 0).unwrap();
for bit in [2, 49] {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = keymap;
loaded.cpu.gpr[4] = bit;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
}
#[test]
fn getkeys_lsb_bitmap_integrates_with_msb_first_bit_tst() {
let pef = synthetic_pef_with_import(b"GetKeys");
let mut loaded = load_pef_application(&pef).unwrap();
let keymap = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(keymap, vec![0; 16]);
let mut input = PpcInputSnapshot::default();
for key_code in [0x00, 0x31] {
let (byte, mask) = crate::trap::dispatch::key_map_byte_mask(key_code).unwrap();
input.key_map[byte] |= mask;
}
loaded.set_input_snapshot(input);
loaded.cpu.gpr[3] = keymap;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(keymap), Some(0x01));
assert_eq!(loaded.memory.read_u8(keymap + 6), Some(0x02));
// Inside Macintosh Volume I (1985), pp. I-259–I-260 maps virtual key
// codes directly to KeyMap indexes. BitTst independently counts from
// each byte's high-order bit (Operating System Utilities, 1994,
// pp. 3-7 and 3-28), so a KeyMap key is tested at keyCode XOR 7.
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::BitTst;
for (bit, expected) in [(7, 1), (54, 1), (0, 0), (49, 0)] {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = keymap;
loaded.cpu.gpr[4] = bit;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], expected, "BitTst offset {bit}");
}
}
#[test]
fn hle_import_runner_handles_p2cstr() {
let pef = synthetic_pef_with_import(b"p2cstr");
let mut loaded = load_pef_application(&pef).unwrap();
let string_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(string_ptr, vec![0xaa; 32]);
write_ppc_pstring(&mut loaded.memory, string_ptr, b"Gridz");
loaded.cpu.gpr[3] = string_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], string_ptr);
assert_eq!(
(0..6)
.map(|offset| loaded.memory.read_u8(string_ptr + offset).unwrap())
.collect::<Vec<_>>(),
b"Gridz\0".to_vec()
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::C2PStr;
loaded.cpu.gpr[3] = string_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], string_ptr);
assert_eq!(
ppc_read_pstring_bytes(&mut loaded.memory, string_ptr).as_deref(),
Some(b"Gridz".as_slice())
);
}
#[test]
fn hle_import_runner_upper_text_converts_only_the_requested_bytes() {
let pef = synthetic_pef_with_import(b"UpperText");
let mut loaded = load_pef_application(&pef).unwrap();
let text_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(text_ptr, vec![b'a', b'z', 0x8e, b'!', b'q']);
loaded.cpu.gpr[3] = text_ptr;
loaded.cpu.gpr[4] = 3;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], text_ptr);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, text_ptr, 5),
Some(vec![b'A', b'Z', 0x83, b'!', b'q'])
);
}
mod thread_manager;
mod process_manager;
#[test]
fn hle_import_runner_handles_display_manager_gdevice_lookup() {
let pef = synthetic_pef_with_import(b"DMGetGDeviceByDisplayID");
let mut loaded = load_pef_application(&pef).unwrap();
let gdevice_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(gdevice_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = 1;
loaded.cpu.gpr[4] = gdevice_out_ptr;
loaded.cpu.gpr[5] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(gdevice_out_ptr),
Some(PPC_MAIN_GDEVICE)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded
.memory
.write_u32_be(gdevice_out_ptr, 0xa5a5_5a5a)
.unwrap();
loaded.cpu.gpr[3] = PPC_DSP_DISPLAY_ID + 1;
loaded.cpu.gpr[4] = gdevice_out_ptr;
loaded.cpu.gpr[5] = 0;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DMGetGDeviceByDisplayID,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(
loaded.memory.read_u32_be(gdevice_out_ptr),
Some(0xa5a5_5a5a),
"failed lookup must leave the output untouched"
);
loaded.cpu.gpr[3] = PPC_DSP_DISPLAY_ID + 1;
loaded.cpu.gpr[4] = gdevice_out_ptr;
loaded.cpu.gpr[5] = 1;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DMGetGDeviceByDisplayID,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(gdevice_out_ptr),
Some(PPC_MAIN_GDEVICE),
"failToMain must resolve an unknown display ID to the main device"
);
}
#[test]
fn display_manager_display_id_lookup_honors_fail_to_main() {
let pef = synthetic_pef_with_import(b"DMGetDisplayIDByGDevice");
let mut loaded = load_pef_application(&pef).unwrap();
let display_id_out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(display_id_out, vec![0xa5; 4]);
loaded.cpu.gpr[3] = 0x06ff_0000;
loaded.cpu.gpr[4] = display_id_out;
loaded.cpu.gpr[5] = 0;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DMGetDisplayIDByGDevice,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(
loaded.memory.read_u32_be(display_id_out),
Some(0xa5a5_a5a5),
"failed lookup must leave the output untouched"
);
loaded.cpu.gpr[3] = 0x06ff_0000;
loaded.cpu.gpr[4] = display_id_out;
loaded.cpu.gpr[5] = 1;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DMGetDisplayIDByGDevice,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(display_id_out),
Some(PPC_DSP_DISPLAY_ID),
"failToMain must resolve an unknown GDevice to the main display"
);
}
#[test]
fn hle_import_runner_handles_get_device_list() {
let pef = synthetic_pef_with_import(b"GetDeviceList");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_MAIN_GDEVICE);
}
#[test]
fn hle_import_runner_handles_get_gdevice() {
let pef = synthetic_pef_with_import(b"GetGDevice");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = PPC_MAIN_GDEVICE);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_MAIN_GDEVICE);
}
#[test]
fn hle_import_runner_handles_set_gdevice() {
let pef = synthetic_pef_with_import(b"SetGDevice");
let mut loaded = load_pef_application(&pef).unwrap();
let gdevice = PPC_HEAP_BASE + 0x100;
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = PPC_MAIN_GDEVICE);
loaded.cpu.gpr[3] = gdevice;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], gdevice);
assert_eq!(*loaded.current_gdevice, gdevice);
assert!(loaded.toolbox_startup.known_gdevices.contains(&gdevice));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(*loaded.current_gdevice, gdevice);
assert!(!loaded.toolbox_startup.known_gdevices.contains(&0));
}
#[test]
fn hle_import_runner_handles_get_next_device_single_device_chain() {
let pef = synthetic_pef_with_import(b"GetNextDevice");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn hle_import_runner_get_max_device_requires_screen_intersection() {
let pef = synthetic_pef_with_import(b"GetMaxDevice");
let mut loaded = load_pef_application(&pef).unwrap();
let rect_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rect_ptr, vec![0; 8]);
ppc_write_rect(&mut loaded.memory, rect_ptr, 100, 100, 200, 200).unwrap();
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_MAIN_GDEVICE);
let top = PPC_MAIN_SCREEN_HEIGHT as i16 + 20;
let left = PPC_MAIN_SCREEN_WIDTH as i16 + 20;
ppc_write_rect(
&mut loaded.memory,
rect_ptr,
top,
left,
top + 100,
left + 100,
)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = rect_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn hle_import_runner_handles_menu_bar_height_accessors() {
let pef = synthetic_pef_with_import(b"GetMBarHeight");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 20);
let pef = synthetic_pef_with_import(b"LMSetMBarHeight");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 37;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR), Some(37));
}
mod font_manager;
mod gestalt;
mod display_depth;
mod desk_manager;
mod device_manager;
#[path = "native_exceptions.rs"]
mod native_exceptions;
mod draw_sprocket;
mod input_sprocket;
mod sound_manager;
fn establish_loaded_reservation(loaded: &mut PpcLoadedApp, address: u32) {
const LWARX_R12_R4_R5: u32 =
(31 << 26) | (12 << 21) | (4 << 16) | (5 << 11) | (20 << 1);
let preserved = (
loaded.cpu.pc,
loaded.cpu.gpr[4],
loaded.cpu.gpr[5],
loaded.cpu.gpr[12],
);
loaded.cpu.gpr[4] = address;
loaded.cpu.gpr[5] = 0;
assert_eq!(
loaded.cpu.step(&mut loaded.memory, LWARX_R12_R4_R5),
ppc::PpcStepResult::Stepped
);
assert_eq!(loaded.cpu.reservation_address(), Some(address));
(
loaded.cpu.pc,
loaded.cpu.gpr[4],
loaded.cpu.gpr[5],
loaded.cpu.gpr[12],
) = preserved;
}
mod interrupt_callbacks;
mod dialog_parameters;
mod loader_configuration;
pub(crate) fn synthetic_pef() -> Vec<u8> {
synthetic_pef_with_import(b"TestImport")
}
#[test]
fn native_universal_proc_prepares_resources_runs_initializers_and_retries_failures() {
for initialization in [None, Some(0u16), Some(1u16)] {
let mut loader =
synthetic_loader_with_chunks(b"InterfaceLib", b"TestImport", &[run_reloc(0x23, 2)]);
if initialization.is_some() {
write_i32(&mut loader, 8, 1);
write_u32(&mut loader, 12, 8);
}
let mut data = vec![0; 16];
write_u32(&mut data, 8, 12);
let mut fragment = synthetic_pef_with_loader_and_data(loader, &data);
let code_offset = parse_pef_sections(&fragment).unwrap()[0].container_offset as usize;
for (index, word) in [
d_form_u(32, 11, 1, 56), // ninth argument
0x7c63_5a14, // add r3,r3,r11
BLR,
d_form_u(14, 3, 0, initialization.unwrap_or(0)),
d_form_u(14, 4, 0, 0xBAD), // initializer clobbers argument registers
BLR,
]
.into_iter()
.enumerate()
{
write_u32(&mut fragment, code_offset + index * 4, word);
}
let mut loaded =
load_pef_application(&synthetic_pef_with_import(b"CallUniversalProc")).unwrap();
let descriptor = PPC_HEAP_BASE + 0x1000;
let fragment_address = descriptor + 0x100;
loaded
.memory
.add_region(descriptor, vec![0; 0x100 + fragment.len()]);
loaded
.memory
.write_bytes(fragment_address, &fragment)
.unwrap();
assert!(crate::cfm::fragment::read_resource_fragment(
&mut loaded.memory,
fragment_address,
Some(fragment.len() as u32 - 1)
)
.is_none());
assert_eq!(
crate::cfm::fragment::read_resource_fragment(
&mut loaded.memory,
fragment_address,
Some(fragment.len() as u32)
),
Some(fragment.clone())
);
loaded.set_heap_cursor(descriptor + 0x100 + fragment.len() as u32 + 0x100);
loaded
.memory
.write_u16_be(descriptor, PPC_MIXED_MODE_TRAP)
.unwrap();
loaded
.memory
.write_u8(descriptor + 2, PPC_ROUTINE_DESCRIPTOR_VERSION)
.unwrap();
loaded.memory.write_u16_be(descriptor + 10, 0).unwrap();
let record = descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE;
let proc_info =
test_stack_proc_info(PPC_PROCINFO_SIZE_FOUR, &[PPC_PROCINFO_SIZE_FOUR; 9]);
assert!(ppc_write_routine_record(
&mut loaded.memory,
record,
proc_info,
PPC_ROUTINE_RECORD_POWERPC_ISA,
3,
0x100
));
loaded.cpu.gpr[1] -= PPC_INITIAL_STACK_FRAME_SIZE;
let sp = loaded.cpu.gpr[1];
let caller_rtoc = loaded.cpu.gpr[2];
let first_id = loaded.cfm.as_ref().unwrap().next_connection_id;
let prepare_call = |loaded: &mut PpcLoadedApp| {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[2] = caller_rtoc;
loaded.cpu.gpr[3] = descriptor;
loaded.cpu.gpr[4] = proc_info;
for index in 0..9 {
let value = (index as u32 + 1) * 0x10;
if index < 6 {
loaded.cpu.gpr[5 + index] = value;
} else {
let slot = ppc_parameter_area_slot_addr(
sp,
PPC_CALL_UNIVERSAL_PROC_FIXED_WORD_PARAMETERS + index,
)
.unwrap();
loaded.memory.write_u32_be(slot, value).unwrap();
}
}
};
prepare_call(&mut loaded);
if initialization.is_some() {
for _ in 0..16 {
if loaded.guest_calls().is_resource_preparation_pending(record) {
break;
}
let slice = loaded.run_with_hle_imports(1);
assert_eq!(slice.unsupported_import_index, None);
}
assert!(loaded.guest_calls().is_resource_preparation_pending(record));
assert_eq!(loaded.memory.read_u16_be(record + 6), Some(3));
let request = match crate::guest_procedure::inspect_guest_procedure(
&mut loaded.memory,
descriptor,
caller_rtoc,
None,
GuestIsa::PowerPc,
GuestIsa::PowerPc,
)
.unwrap()
{
crate::guest_procedure::GuestProcedureResolution::Prepare(request) => request,
_ => panic!("initializing resource became callable"),
};
let mut recursive_cpu = loaded.cpu.clone();
let before_cpu = recursive_cpu.clone();
let mut cursor = loaded.heap_cursor();
let mut import_run_state = PpcImportRunState::from_parts(
std::mem::take(&mut loaded.imports),
loaded.import_count,
ppc_import_layout(),
);
let guest_calls = loaded.guest_calls().shared_handle();
let mut manager = loaded.process_memory_manager.0.borrow_mut();
let limit = manager.native_heap_state().unwrap().heap_limit;
let cfm = loaded.cfm.as_mut().unwrap();
assert_eq!(
ppc_prepare_resource_call(
&mut recursive_cpu,
&mut loaded.memory,
&mut manager,
&guest_calls,
&mut cursor,
limit,
&mut cfm.connections,
&mut cfm.next_connection_id,
&mut import_run_state,
request,
None
),
PpcImportAction::Return(ppc_i16_result(PPC_FRAG_INIT_LOOP))
);
(loaded.imports, loaded.import_count) = import_run_state.into_parts();
assert_eq!(recursive_cpu.gpr, before_cpu.gpr);
assert_eq!(recursive_cpu.pc, before_cpu.pc);
assert!(loaded.guest_calls().is_resource_preparation_pending(record));
}
let result = loaded.run_with_hle_imports(128);
assert_eq!(result.unsupported_import_index, None);
assert!(matches!(
result.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.cpu.gpr[2], caller_rtoc);
assert_eq!(loaded.cpu.gpr[1], sp);
assert!(loaded.guest_calls().is_empty());
if initialization == Some(1) {
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_FRAG_USER_INIT_PROC_ERR)
);
assert_eq!(loaded.memory.read_u16_be(record + 6), Some(3));
assert_eq!(loaded.memory.read_u32_be(record + 8), Some(0x100));
assert!(!loaded
.cfm
.as_ref()
.unwrap()
.connections
.iter()
.any(|connection| connection.id == first_id));
loaded
.memory
.write_u32_be(
fragment_address + code_offset as u32 + 12,
d_form_u(14, 3, 0, 0),
)
.unwrap();
prepare_call(&mut loaded);
let retry = loaded.run_with_hle_imports(128);
assert_eq!(retry.unsupported_import_index, None);
assert!(loaded.cfm.as_ref().unwrap().next_connection_id > first_id + 1);
}
assert_eq!(loaded.cpu.gpr[3], 0xA0);
assert_eq!(loaded.memory.read_u16_be(record + 6), Some(0));
let prepared_target = loaded.memory.read_u32_be(record + 8).unwrap();
assert_ne!(prepared_target, 0x100);
let cursor = loaded.heap_cursor();
let next = loaded.cfm.as_ref().unwrap().next_connection_id;
prepare_call(&mut loaded);
let again = loaded.run_with_hle_imports(128);
assert_eq!(again.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0xA0);
assert_eq!(loaded.cfm.as_ref().unwrap().next_connection_id, next);
assert_eq!(loaded.heap_cursor(), cursor);
}
}
fn synthetic_pef_with_initializer() -> Vec<u8> {
let mut pef = synthetic_pef();
// The synthetic loader section begins at $80. Reuse its main TVector
// as a valid initializer TVector so loading exercises CFM's startup
// fragment and InitBlock allocations without executing the code.
write_i32(&mut pef, 0x80 + 8, 1);
write_u32(&mut pef, 0x80 + 12, 0);
pef
}
fn assert_ppc_bytes_equal(memory: &mut PpcSectionMem, start: u32, len: u32, expected: u8) {
for offset in 0..len {
assert_eq!(memory.read_u8(start + offset), Some(expected));
}
}
mod standard_c_library_integration;
pub(crate) fn synthetic_pef_with_import(symbol_name: &[u8]) -> Vec<u8> {
synthetic_pef_with_library_import(b"InterfaceLib", symbol_name)
}
fn synthetic_pef_with_import_class(symbol_name: &[u8], symbol_class: u8) -> Vec<u8> {
synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
b"InterfaceLib",
symbol_name,
symbol_class,
&[sm_index_reloc(0x30, 0)],
))
}
fn write_test_dsp_context_attributes(
memory: &mut PpcSectionMem,
attributes: u32,
context_attributes: PpcDspContextAttributes,
) {
memory
.write_u32_be(attributes, context_attributes.frequency)
.unwrap();
memory
.write_u32_be(attributes + 4, context_attributes.width)
.unwrap();
memory
.write_u32_be(attributes + 8, context_attributes.height)
.unwrap();
memory
.write_u32_be(attributes + 28, context_attributes.context_options)
.unwrap();
memory
.write_u32_be(
attributes + 32,
context_attributes.back_buffer_best_depth_mask,
)
.unwrap();
memory
.write_u32_be(attributes + 36, context_attributes.display_best_depth_mask)
.unwrap();
memory
.write_u32_be(attributes + 40, context_attributes.back_buffer_depth)
.unwrap();
memory
.write_u32_be(attributes + 44, context_attributes.display_depth)
.unwrap();
memory
.write_u32_be(attributes + 48, context_attributes.page_count)
.unwrap();
}
fn synthetic_pef_with_library_import(library_name: &[u8], symbol_name: &[u8]) -> Vec<u8> {
synthetic_pef_with_loader(synthetic_loader(library_name, symbol_name))
}
fn synthetic_pef_with_reloc_chunks(
library_name: &[u8],
symbol_name: &[u8],
chunks: &[u16],
) -> Vec<u8> {
synthetic_pef_with_loader(synthetic_loader_with_chunks(
library_name,
symbol_name,
chunks,
))
}
fn synthetic_pef_with_loader(loader: Vec<u8>) -> Vec<u8> {
synthetic_pef_with_loader_and_data(loader, &[0; 8])
}
fn synthetic_pef_with_loader_and_data(loader: Vec<u8>, data: &[u8]) -> Vec<u8> {
let code = synthetic_code();
let loader_offset = 0x80usize;
let code_offset = align_test_offset((loader_offset + loader.len()).max(0x100), 0x10);
let data_offset = code_offset + code.len();
let total_len = data_offset + data.len();
let mut bytes = vec![0u8; total_len.max(loader_offset + loader.len())];
bytes[0..4].copy_from_slice(b"Joy!");
bytes[4..8].copy_from_slice(b"peff");
bytes[8..12].copy_from_slice(b"pwpc");
write_u32(&mut bytes, 12, 1);
write_u16(&mut bytes, 32, 3);
write_u16(&mut bytes, 34, 2);
write_section(
&mut bytes,
0,
SectionSpec {
total_size: code.len() as u32,
unpacked_size: code.len() as u32,
packed_size: code.len() as u32,
container_offset: code_offset as u32,
section_kind: SECTION_KIND_CODE,
},
);
write_section(
&mut bytes,
1,
SectionSpec {
total_size: data.len() as u32,
unpacked_size: data.len() as u32,
packed_size: data.len() as u32,
container_offset: data_offset as u32,
section_kind: SECTION_KIND_UNPACKED_DATA,
},
);
write_section(
&mut bytes,
2,
SectionSpec {
total_size: 0,
unpacked_size: 0,
packed_size: loader.len() as u32,
container_offset: loader_offset as u32,
section_kind: super::super::pef::SECTION_KIND_LOADER,
},
);
bytes[loader_offset..loader_offset + loader.len()].copy_from_slice(&loader);
bytes[code_offset..code_offset + code.len()].copy_from_slice(&code);
bytes[data_offset..data_offset + data.len()].copy_from_slice(&data);
bytes
}
fn align_test_offset(value: usize, align: usize) -> usize {
(value + align - 1) & !(align - 1)
}
fn synthetic_code() -> Vec<u8> {
let mut code = Vec::new();
let hi = (PPC_IMPORT_TRAP_BASE >> 16) as u16;
let lo = (PPC_IMPORT_TRAP_BASE & 0xffff) as u16;
for word in [
d_form_u(15, 12, 0, hi), // lis r12, trap@ha
d_form_u(24, 12, 12, lo), // ori r12, r12, trap@l
xfx_form(31, 12, 9, 467), // mtctr r12
xl_form(19, 20, 0, 528, true), // bctrl
d_form_u(14, 0, 0, 0), // li r0, 0
xfx_form(31, 0, 8, 467), // mtlr r0
BLR,
] {
code.extend_from_slice(&word.to_be_bytes());
}
code
}
fn synthetic_loader(library_name: &[u8], symbol_name: &[u8]) -> Vec<u8> {
let chunks = [run_reloc(0x23, 1)];
synthetic_loader_with_chunks(library_name, symbol_name, &chunks)
}
fn synthetic_loader_with_chunks(
library_name: &[u8],
symbol_name: &[u8],
chunks: &[u16],
) -> Vec<u8> {
synthetic_loader_with_symbol_class(library_name, symbol_name, 0x02, chunks)
}
fn synthetic_loader_with_symbol_class(
library_name: &[u8],
symbol_name: &[u8],
symbol_class: u8,
chunks: &[u16],
) -> Vec<u8> {
let mut strings = Vec::new();
let library_name = push_c_string(&mut strings, library_name);
let symbol_name = push_c_string(&mut strings, symbol_name);
let reloc_header_offset = 56 + 24 + 4;
let reloc_instr_offset = reloc_header_offset + 12;
let strings_offset = reloc_instr_offset + chunks.len() * 2;
let mut bytes = vec![0u8; strings_offset + strings.len()];
write_i32(&mut bytes, 0, 1);
write_u32(&mut bytes, 4, 0);
write_i32(&mut bytes, 8, -1);
write_i32(&mut bytes, 16, -1);
write_u32(&mut bytes, 24, 1);
write_u32(&mut bytes, 28, 1);
write_u32(&mut bytes, 32, 1);
write_u32(&mut bytes, 36, reloc_instr_offset as u32);
write_u32(&mut bytes, 40, strings_offset as u32);
write_u32(&mut bytes, 56, library_name);
write_u32(&mut bytes, 56 + 12, 1);
write_symbol(&mut bytes, 56 + 24, symbol_class, symbol_name);
write_u16(&mut bytes, reloc_header_offset, 1);
write_u32(&mut bytes, reloc_header_offset + 4, chunks.len() as u32);
write_u32(&mut bytes, reloc_header_offset + 8, 0);
for (index, chunk) in chunks.iter().enumerate() {
write_u16(&mut bytes, reloc_instr_offset + index * 2, *chunk);
}
bytes[strings_offset..].copy_from_slice(&strings);
bytes
}
fn synthetic_loader_with_repeated_imports(import_count: u32) -> Vec<u8> {
let mut strings = Vec::new();
let library_name = push_c_string(&mut strings, b"InterfaceLib");
let symbol_name = push_c_string(&mut strings, b"TickCount");
let symbol_count = usize::try_from(import_count).unwrap();
let strings_offset = 56 + 24 + symbol_count * 4;
let mut bytes = vec![0u8; strings_offset + strings.len()];
write_i32(&mut bytes, 0, 1);
write_i32(&mut bytes, 8, -1);
write_i32(&mut bytes, 16, -1);
write_u32(&mut bytes, 24, 1);
write_u32(&mut bytes, 28, import_count);
write_u32(&mut bytes, 36, strings_offset as u32);
write_u32(&mut bytes, 40, strings_offset as u32);
write_u32(&mut bytes, 56, library_name);
write_u32(&mut bytes, 56 + 12, import_count);
for index in 0..symbol_count {
write_symbol(&mut bytes, 56 + 24 + index * 4, 2, symbol_name);
}
bytes[strings_offset..].copy_from_slice(&strings);
bytes
}
fn synthetic_loader_with_overlapping_library_ranges() -> Vec<u8> {
let mut strings = Vec::new();
let first_library = push_c_string(&mut strings, b"InterfaceLib");
let second_library = push_c_string(&mut strings, b"StdCLib");
let symbol = push_c_string(&mut strings, b"errno");
let reloc_header_offset = 56 + 2 * 24 + 4;
let reloc_instr_offset = reloc_header_offset + 12;
let strings_offset = reloc_instr_offset + 2;
let mut bytes = vec![0u8; strings_offset + strings.len()];
write_i32(&mut bytes, 0, 1);
write_i32(&mut bytes, 8, -1);
write_i32(&mut bytes, 16, -1);
write_u32(&mut bytes, 24, 2);
write_u32(&mut bytes, 28, 1);
write_u32(&mut bytes, 32, 1);
write_u32(&mut bytes, 36, reloc_instr_offset as u32);
write_u32(&mut bytes, 40, strings_offset as u32);
write_u32(&mut bytes, 56, first_library);
write_u32(&mut bytes, 56 + 12, 1);
write_u32(&mut bytes, 56 + 24, second_library);
write_u32(&mut bytes, 56 + 24 + 12, 1);
write_symbol(&mut bytes, 56 + 2 * 24, 2, symbol);
write_u16(&mut bytes, reloc_header_offset, 1);
write_u32(&mut bytes, reloc_header_offset + 4, 1);
write_u32(&mut bytes, reloc_header_offset + 8, 0);
write_u16(&mut bytes, reloc_instr_offset, sm_index_reloc(0x30, 0));
bytes[strings_offset..].copy_from_slice(&strings);
bytes
}
fn synthetic_pef_with_exports() -> Vec<u8> {
let names = [b"tvector".as_slice(), b"absolute", b"reexport"];
let mut strings = Vec::new();
let mut name_offsets = Vec::new();
for name in names {
name_offsets.push(strings.len() as u32);
strings.extend_from_slice(name);
strings.push(0);
}
let strings_offset = 56usize;
let export_hash_offset = strings_offset + strings.len();
let key_table_offset = export_hash_offset + 4;
let symbol_table_offset = key_table_offset + names.len() * 4;
let loader_len = symbol_table_offset + names.len() * 10;
let mut loader = vec![0; loader_len];
write_i32(&mut loader, 0, -1);
write_i32(&mut loader, 8, -1);
write_i32(&mut loader, 16, -1);
write_u32(&mut loader, 40, strings_offset as u32);
write_u32(&mut loader, 44, export_hash_offset as u32);
write_u32(&mut loader, 48, 0);
write_u32(&mut loader, 52, names.len() as u32);
loader[strings_offset..export_hash_offset].copy_from_slice(&strings);
// All three entries occupy one valid hash chain. The resolver uses
// the flattened export table, but the parser still validates chains.
write_u32(&mut loader, export_hash_offset, 3 << 18);
for (index, name) in names.iter().enumerate() {
write_u32(
&mut loader,
key_table_offset + index * 4,
(name.len() as u32) << 16,
);
}
let records = [
(2u8, name_offsets[0], 0u32, 1i16),
(1u8, name_offsets[1], 0x1234_5678, -2i16),
(2u8, name_offsets[2], 0u32, -3i16),
];
for (index, (class, name_offset, value, section_index)) in records.into_iter().enumerate() {
let base = symbol_table_offset + index * 10;
write_u32(&mut loader, base, (u32::from(class) << 24) | name_offset);
write_u32(&mut loader, base + 4, value);
write_u16(&mut loader, base + 8, section_index as u16);
}
synthetic_pef_with_loader_and_data(loader, &[0; 8])
}
fn write_ppc_pstring(memory: &mut PpcSectionMem, addr: u32, bytes: &[u8]) {
assert!(bytes.len() <= 255);
memory.write_u8(addr, bytes.len() as u8).unwrap();
for (offset, byte) in bytes.iter().enumerate() {
memory.write_u8(addr + 1 + offset as u32, *byte).unwrap();
}
}
fn compressed_resource_bytes(decompressed_len: u32, body: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
out.extend_from_slice(b"\xA8\x9Fer");
out.extend_from_slice(&0x12u16.to_be_bytes());
out.extend_from_slice(&0x0801u16.to_be_bytes());
out.extend_from_slice(&decompressed_len.to_be_bytes());
out.extend_from_slice(&[0x80, 0x03]);
out.extend_from_slice(&0i16.to_be_bytes());
out.extend_from_slice(&0u16.to_be_bytes());
out.extend_from_slice(body);
out
}
fn noncanonical_single_resource_fork_bytes(
res_type: [u8; 4],
res_id: i16,
data: &[u8],
attrs: u8,
map_attrs: u16,
) -> Vec<u8> {
let data_offset = 16u32;
let data_length = (4 + data.len()) as u32;
let map_offset = data_offset + data_length;
let type_list_offset = 30u16;
let ref_list_offset = 10u16;
let name_list_offset = 40u16;
let map_length = 52u32;
let mut bytes = vec![0u8; (map_offset + map_length) as usize];
let mut header = [0u8; 16];
header[0..4].copy_from_slice(&data_offset.to_be_bytes());
header[4..8].copy_from_slice(&map_offset.to_be_bytes());
header[8..12].copy_from_slice(&data_length.to_be_bytes());
header[12..16].copy_from_slice(&map_length.to_be_bytes());
bytes[0..16].copy_from_slice(&header);
let data_start = data_offset as usize;
bytes[data_start..data_start + 4].copy_from_slice(&(data.len() as u32).to_be_bytes());
bytes[data_start + 4..data_start + 4 + data.len()].copy_from_slice(data);
let map_start = map_offset as usize;
bytes[map_start..map_start + 16].copy_from_slice(&header);
bytes[map_start + 22..map_start + 24].copy_from_slice(&map_attrs.to_be_bytes());
bytes[map_start + 24..map_start + 26].copy_from_slice(&type_list_offset.to_be_bytes());
bytes[map_start + 26..map_start + 28].copy_from_slice(&name_list_offset.to_be_bytes());
let type_list_start = map_start + type_list_offset as usize;
bytes[type_list_start..type_list_start + 2].copy_from_slice(&0u16.to_be_bytes());
bytes[type_list_start + 2..type_list_start + 6].copy_from_slice(&res_type);
bytes[type_list_start + 6..type_list_start + 8].copy_from_slice(&0u16.to_be_bytes());
bytes[type_list_start + 8..type_list_start + 10]
.copy_from_slice(&ref_list_offset.to_be_bytes());
let ref_list_start = type_list_start + ref_list_offset as usize;
bytes[ref_list_start..ref_list_start + 2].copy_from_slice(&(res_id as u16).to_be_bytes());
bytes[ref_list_start + 2..ref_list_start + 4].copy_from_slice(&0xffffu16.to_be_bytes());
bytes[ref_list_start + 4] = attrs;
bytes[ref_list_start + 5..ref_list_start + 8].copy_from_slice(&0u32.to_be_bytes()[1..4]);
bytes
}
fn test_sound_file_playback(channel: u32) -> PpcSoundFilePlaybackRecord {
PpcSoundFilePlaybackRecord {
channel,
ref_num: PPC_FIRST_FILE_REF_NUM,
resource_id: 0,
buffer_size: 0,
buffer: 0,
selection: 0,
completion: 0,
completion_command: None,
async_play: false,
aiff: None,
decoded_aiff: None,
}
}
fn write_ppc_fsspec(
memory: &mut PpcSectionMem,
addr: u32,
vref: i16,
dir_id: u32,
name: &[u8],
) {
memory.write_u16_be(addr, vref as u16).unwrap();
memory.write_u32_be(addr + 2, dir_id).unwrap();
write_ppc_pstring(memory, addr + 6, name);
}
fn push_quicktime_atom(bytes: &mut Vec<u8>, atom_type: &[u8; 4], payload: &[u8]) {
let size = 8usize.checked_add(payload.len()).unwrap();
bytes.extend_from_slice(&u32::try_from(size).unwrap().to_be_bytes());
bytes.extend_from_slice(atom_type);
bytes.extend_from_slice(payload);
}
fn ppc_test_push_u16(bytes: &mut Vec<u8>, value: u16) {
bytes.extend_from_slice(&value.to_be_bytes());
}
fn ppc_test_push_u24(bytes: &mut Vec<u8>, value: usize) {
assert!(value <= 0x00ff_ffff);
bytes.push(((value >> 16) & 0xff) as u8);
bytes.push(((value >> 8) & 0xff) as u8);
bytes.push((value & 0xff) as u8);
}
fn test_cinepak_frame_sample(frame_flags: u8, strip_id: u8, strip_payload: &[u8]) -> Vec<u8> {
let strip_size = 12usize.checked_add(strip_payload.len()).unwrap();
let frame_size = 10usize.checked_add(strip_size).unwrap();
let mut bytes = Vec::new();
bytes.push(frame_flags);
ppc_test_push_u24(&mut bytes, frame_size);
ppc_test_push_u16(&mut bytes, 4);
ppc_test_push_u16(&mut bytes, 4);
ppc_test_push_u16(&mut bytes, 1);
bytes.push(strip_id);
ppc_test_push_u24(&mut bytes, strip_size);
ppc_test_push_u16(&mut bytes, 0);
ppc_test_push_u16(&mut bytes, 0);
ppc_test_push_u16(&mut bytes, 4);
ppc_test_push_u16(&mut bytes, 4);
bytes.extend_from_slice(strip_payload);
bytes
}
fn test_cinepak_v1_frame_sample() -> Vec<u8> {
let mut strip_payload = Vec::new();
strip_payload.push(0x22);
ppc_test_push_u24(&mut strip_payload, 10);
strip_payload.extend_from_slice(&[0, 85, 170, 255, 0, 0]);
strip_payload.push(0x32);
ppc_test_push_u24(&mut strip_payload, 5);
strip_payload.push(0);
test_cinepak_frame_sample(0, 0x10, &strip_payload)
}
fn test_cinepak_v4_frame_sample() -> Vec<u8> {
let mut strip_payload = Vec::new();
strip_payload.push(0x24);
ppc_test_push_u24(&mut strip_payload, 20);
strip_payload.extend_from_slice(&[
10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160,
]);
strip_payload.push(0x30);
ppc_test_push_u24(&mut strip_payload, 12);
strip_payload.extend_from_slice(&0x8000_0000u32.to_be_bytes());
strip_payload.extend_from_slice(&[0, 1, 2, 3]);
test_cinepak_frame_sample(0, 0x10, &strip_payload)
}
fn test_cinepak_flagged_v1_update_sample() -> Vec<u8> {
let mut strip_payload = Vec::new();
strip_payload.push(0x23);
ppc_test_push_u24(&mut strip_payload, 14);
strip_payload.extend_from_slice(&0x4000_0000u32.to_be_bytes());
strip_payload.extend_from_slice(&[255, 0, 0, 255, 0, 0]);
strip_payload.push(0x32);
ppc_test_push_u24(&mut strip_payload, 5);
strip_payload.push(1);
test_cinepak_frame_sample(0, 0x11, &strip_payload)
}
fn test_cinepak_skip_frame_sample() -> Vec<u8> {
let mut strip_payload = Vec::new();
strip_payload.push(0x31);
ppc_test_push_u24(&mut strip_payload, 8);
strip_payload.extend_from_slice(&0u32.to_be_bytes());
test_cinepak_frame_sample(0, 0x11, &strip_payload)
}
fn ppc_test_rgb_at(frame: &PpcQuickTimeDecodedVideoFrame, x: usize, y: usize) -> [u8; 3] {
let offset = y
.checked_mul(frame.width)
.and_then(|base| base.checked_add(x))
.and_then(|pixel| pixel.checked_mul(3))
.unwrap();
[
frame.rgb[offset],
frame.rgb[offset + 1],
frame.rgb[offset + 2],
]
}
fn test_quicktime_tkhd_movie(width: u16, height: u16) -> Vec<u8> {
fn push_u16(bytes: &mut Vec<u8>, value: u16) {
bytes.extend_from_slice(&value.to_be_bytes());
}
fn push_u32(bytes: &mut Vec<u8>, value: u32) {
bytes.extend_from_slice(&value.to_be_bytes());
}
let mut mvhd_payload = vec![0; 100];
mvhd_payload[12..16].copy_from_slice(&60u32.to_be_bytes());
mvhd_payload[16..20].copy_from_slice(&120u32.to_be_bytes());
let mut tkhd_payload = vec![0; 84];
tkhd_payload[3] = 0x07;
tkhd_payload[76..80].copy_from_slice(&(u32::from(width) << 16).to_be_bytes());
tkhd_payload[80..84].copy_from_slice(&(u32::from(height) << 16).to_be_bytes());
let mut video_mdhd_payload = vec![0; 24];
video_mdhd_payload[12..16].copy_from_slice(&60u32.to_be_bytes());
video_mdhd_payload[16..20].copy_from_slice(&120u32.to_be_bytes());
let mut video_hdlr_payload = vec![0; 24];
video_hdlr_payload[4..8].copy_from_slice(b"mhlr");
video_hdlr_payload[8..12].copy_from_slice(b"vide");
let mut video_stsd_payload = Vec::new();
push_u32(&mut video_stsd_payload, 0);
push_u32(&mut video_stsd_payload, 1);
push_u32(&mut video_stsd_payload, 16);
video_stsd_payload.extend_from_slice(b"rle ");
video_stsd_payload.extend_from_slice(&[0; 8]);
let mut video_stts_payload = Vec::new();
push_u32(&mut video_stts_payload, 0);
push_u32(&mut video_stts_payload, 1);
push_u32(&mut video_stts_payload, 2);
push_u32(&mut video_stts_payload, 60);
let mut video_stsc_payload = Vec::new();
push_u32(&mut video_stsc_payload, 0);
push_u32(&mut video_stsc_payload, 1);
push_u32(&mut video_stsc_payload, 1);
push_u32(&mut video_stsc_payload, 2);
push_u32(&mut video_stsc_payload, 1);
let mut video_stsz_payload = Vec::new();
push_u32(&mut video_stsz_payload, 0);
push_u32(&mut video_stsz_payload, 4);
push_u32(&mut video_stsz_payload, 2);
let mut video_stco_payload = Vec::new();
push_u32(&mut video_stco_payload, 0);
push_u32(&mut video_stco_payload, 1);
push_u32(&mut video_stco_payload, 8);
let mut video_stbl_payload = Vec::new();
push_quicktime_atom(&mut video_stbl_payload, b"stsd", &video_stsd_payload);
push_quicktime_atom(&mut video_stbl_payload, b"stts", &video_stts_payload);
push_quicktime_atom(&mut video_stbl_payload, b"stsc", &video_stsc_payload);
push_quicktime_atom(&mut video_stbl_payload, b"stsz", &video_stsz_payload);
push_quicktime_atom(&mut video_stbl_payload, b"stco", &video_stco_payload);
let mut video_minf_payload = Vec::new();
push_quicktime_atom(&mut video_minf_payload, b"stbl", &video_stbl_payload);
let mut video_mdia_payload = Vec::new();
push_quicktime_atom(&mut video_mdia_payload, b"mdhd", &video_mdhd_payload);
push_quicktime_atom(&mut video_mdia_payload, b"hdlr", &video_hdlr_payload);
push_quicktime_atom(&mut video_mdia_payload, b"minf", &video_minf_payload);
let mut video_trak_payload = Vec::new();
push_quicktime_atom(&mut video_trak_payload, b"tkhd", &tkhd_payload);
push_quicktime_atom(&mut video_trak_payload, b"mdia", &video_mdia_payload);
let mut audio_mdhd_payload = vec![0; 24];
audio_mdhd_payload[12..16].copy_from_slice(&22_050u32.to_be_bytes());
audio_mdhd_payload[16..20].copy_from_slice(&6u32.to_be_bytes());
let mut audio_hdlr_payload = vec![0; 24];
audio_hdlr_payload[4..8].copy_from_slice(b"mhlr");
audio_hdlr_payload[8..12].copy_from_slice(b"soun");
let mut audio_stsd_payload = Vec::new();
push_u32(&mut audio_stsd_payload, 0);
push_u32(&mut audio_stsd_payload, 1);
push_u32(&mut audio_stsd_payload, 36);
audio_stsd_payload.extend_from_slice(b"raw ");
push_u32(&mut audio_stsd_payload, 0);
push_u16(&mut audio_stsd_payload, 0);
push_u16(&mut audio_stsd_payload, 1);
push_u16(&mut audio_stsd_payload, 0);
push_u16(&mut audio_stsd_payload, 0);
push_u32(&mut audio_stsd_payload, 0);
push_u16(&mut audio_stsd_payload, 1);
push_u16(&mut audio_stsd_payload, 8);
push_u16(&mut audio_stsd_payload, 0);
push_u16(&mut audio_stsd_payload, 0);
push_u32(&mut audio_stsd_payload, 22_050u32 << 16);
let mut audio_stts_payload = Vec::new();
push_u32(&mut audio_stts_payload, 0);
push_u32(&mut audio_stts_payload, 1);
push_u32(&mut audio_stts_payload, 6);
push_u32(&mut audio_stts_payload, 1);
let mut audio_stsc_payload = Vec::new();
push_u32(&mut audio_stsc_payload, 0);
push_u32(&mut audio_stsc_payload, 1);
push_u32(&mut audio_stsc_payload, 1);
push_u32(&mut audio_stsc_payload, 6);
push_u32(&mut audio_stsc_payload, 1);
let mut audio_stsz_payload = Vec::new();
push_u32(&mut audio_stsz_payload, 0);
push_u32(&mut audio_stsz_payload, 1);
push_u32(&mut audio_stsz_payload, 6);
let mut audio_stco_payload = Vec::new();
push_u32(&mut audio_stco_payload, 0);
push_u32(&mut audio_stco_payload, 1);
push_u32(&mut audio_stco_payload, 16);
let mut audio_stbl_payload = Vec::new();
push_quicktime_atom(&mut audio_stbl_payload, b"stsd", &audio_stsd_payload);
push_quicktime_atom(&mut audio_stbl_payload, b"stts", &audio_stts_payload);
push_quicktime_atom(&mut audio_stbl_payload, b"stsc", &audio_stsc_payload);
push_quicktime_atom(&mut audio_stbl_payload, b"stsz", &audio_stsz_payload);
push_quicktime_atom(&mut audio_stbl_payload, b"stco", &audio_stco_payload);
let mut audio_minf_payload = Vec::new();
push_quicktime_atom(&mut audio_minf_payload, b"stbl", &audio_stbl_payload);
let mut audio_mdia_payload = Vec::new();
push_quicktime_atom(&mut audio_mdia_payload, b"mdhd", &audio_mdhd_payload);
push_quicktime_atom(&mut audio_mdia_payload, b"hdlr", &audio_hdlr_payload);
push_quicktime_atom(&mut audio_mdia_payload, b"minf", &audio_minf_payload);
let mut audio_trak_payload = Vec::new();
push_quicktime_atom(&mut audio_trak_payload, b"mdia", &audio_mdia_payload);
let mut moov_payload = Vec::new();
push_quicktime_atom(&mut moov_payload, b"mvhd", &mvhd_payload);
push_quicktime_atom(&mut moov_payload, b"trak", &video_trak_payload);
push_quicktime_atom(&mut moov_payload, b"trak", &audio_trak_payload);
let mut bytes = Vec::new();
push_quicktime_atom(
&mut bytes,
b"mdat",
&[
0x10, 0x20, 0x30, 0x40, 0x80, 0x90, 0x70, 0x60, 0x80, 0x90, 0x70, 0x60, 0x50, 0x40,
],
);
push_quicktime_atom(&mut bytes, b"moov", &moov_payload);
bytes
}
fn test_v1_one_bit_packbits_pict() -> Vec<u8> {
fn push_u16(bytes: &mut Vec<u8>, value: u16) {
bytes.extend_from_slice(&value.to_be_bytes());
}
let mut bytes = Vec::new();
push_u16(&mut bytes, 0); // patched picSize
for value in [0i16, 0, 1, 8] {
push_u16(&mut bytes, value as u16);
}
bytes.push(0x11); // versionOp
bytes.push(0x01); // version 1
bytes.push(0x98); // PackBitsRect
push_u16(&mut bytes, 1); // rowBytes < 8: unpacked bitmap data
for value in [0i16, 0, 1, 8] {
push_u16(&mut bytes, value as u16);
}
for _ in 0..2 {
for value in [0i16, 0, 1, 8] {
push_u16(&mut bytes, value as u16);
}
}
push_u16(&mut bytes, 0); // srcCopy
bytes.push(0b1010_0000);
bytes.push(0xff); // EndOfPicture
let size = u16::try_from(bytes.len()).unwrap();
bytes[0..2].copy_from_slice(&size.to_be_bytes());
bytes
}
fn test_one_bit_cicon() -> Vec<u8> {
let mut data = vec![0u8; 101];
data[4..6].copy_from_slice(&0x8001u16.to_be_bytes());
data[10..12].copy_from_slice(&1u16.to_be_bytes());
data[12..14].copy_from_slice(&8u16.to_be_bytes());
data[32..34].copy_from_slice(&1u16.to_be_bytes());
data[34..36].copy_from_slice(&1u16.to_be_bytes());
data[36..38].copy_from_slice(&1u16.to_be_bytes());
data[54..56].copy_from_slice(&1u16.to_be_bytes());
data[60..62].copy_from_slice(&1u16.to_be_bytes());
data[62..64].copy_from_slice(&8u16.to_be_bytes());
data[68..70].copy_from_slice(&1u16.to_be_bytes());
data[74..76].copy_from_slice(&1u16.to_be_bytes());
data[76..78].copy_from_slice(&8u16.to_be_bytes());
data[82] = 0xf0; // first four pixels are opaque
data[83] = 0x00; // monochrome fallback
data[90..92].copy_from_slice(&0u16.to_be_bytes()); // one ColorSpec
data[92..94].copy_from_slice(&0u16.to_be_bytes()); // pixel value 0
data[94..96].copy_from_slice(&0xffffu16.to_be_bytes()); // red
data[96..98].copy_from_slice(&0u16.to_be_bytes());
data[98..100].copy_from_slice(&0u16.to_be_bytes());
data[100] = 0x00; // eight one-bit red pixels
data
}
fn test_stack_proc_info(result_size: u32, parameter_sizes: &[u32]) -> u32 {
let mut proc_info =
PPC_PROCINFO_PASCAL_STACK_BASED | (result_size << PPC_PROCINFO_RESULT_SIZE_PHASE);
for (index, size) in parameter_sizes.iter().copied().enumerate() {
proc_info |= size
<< (PPC_PROCINFO_STACK_PARAMETER_PHASE
+ u32::try_from(index).unwrap() * PPC_PROCINFO_STACK_PARAMETER_WIDTH);
}
proc_info
}
fn test_register_proc_info(result_size: u32, parameters: &[(u32, u32)]) -> u32 {
let mut proc_info =
PPC_PROCINFO_REGISTER_BASED | (result_size << PPC_PROCINFO_RESULT_SIZE_PHASE);
for (index, (which_register, size)) in parameters.iter().copied().enumerate() {
let field = size | (which_register << PPC_PROCINFO_REGISTER_PARAMETER_WHICH_SHIFT);
proc_info |= field
<< (PPC_PROCINFO_REGISTER_PARAMETER_PHASE
+ u32::try_from(index).unwrap() * PPC_PROCINFO_REGISTER_PARAMETER_WIDTH);
}
proc_info
}
fn test_register_proc_info_with_result_location(
result_size: u32,
result_location: u32,
parameters: &[(u32, u32)],
) -> u32 {
test_register_proc_info(result_size, parameters)
| (result_location << PPC_PROCINFO_REGISTER_RESULT_LOCATION_PHASE)
}
fn test_dispatched_stack_proc_info(
calling_convention: u32,
result_size: u32,
selector_size: u32,
parameter_sizes: &[u32],
) -> u32 {
let mut proc_info = calling_convention
| (result_size << PPC_PROCINFO_RESULT_SIZE_PHASE)
| (selector_size << PPC_PROCINFO_DISPATCHED_SELECTOR_SIZE_PHASE);
for (index, size) in parameter_sizes.iter().copied().enumerate() {
proc_info |= size
<< (PPC_PROCINFO_DISPATCHED_PARAMETER_PHASE
+ u32::try_from(index).unwrap() * PPC_PROCINFO_STACK_PARAMETER_WIDTH);
}
proc_info
}
fn install_test_powerpc_callback(
loaded: &mut PpcLoadedApp,
descriptor: u32,
tvector: u32,
callback_entry: u32,
callback_rtoc: u32,
proc_info: u32,
callback_words: &[u32],
) {
let mut callback = Vec::new();
for word in callback_words {
callback.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(callback_entry, callback);
loaded.memory.add_region(callback_rtoc, vec![0; 0x100]);
loaded.memory.add_region(descriptor, vec![0; 0x100]);
loaded
.memory
.write_u16_be(descriptor, PPC_MIXED_MODE_TRAP)
.unwrap();
loaded
.memory
.write_u8(descriptor + 2, PPC_ROUTINE_DESCRIPTOR_VERSION)
.unwrap();
loaded.memory.write_u16_be(descriptor + 10, 0).unwrap();
assert!(ppc_write_routine_record(
&mut loaded.memory,
descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE,
proc_info,
PPC_ROUTINE_RECORD_POWERPC_ISA,
PPC_ROUTINE_FLAG_USE_NATIVE_ISA,
tvector,
));
loaded.memory.write_u32_be(tvector, callback_entry).unwrap();
loaded
.memory
.write_u32_be(tvector + 4, callback_rtoc)
.unwrap();
}
fn install_test_m68k_callback(
loaded: &mut PpcLoadedApp,
descriptor: u32,
callback_entry: u32,
proc_info: u32,
routine_flags: u16,
callback_words: &[u16],
) {
let mut callback = Vec::new();
for word in callback_words {
callback.extend_from_slice(&word.to_be_bytes());
}
loaded.set_heap_cursor(
loaded
.heap_cursor()
.max(descriptor + 0x100)
.max(callback_entry + u32::try_from(callback.len()).unwrap()),
);
loaded.memory.add_region(callback_entry, callback);
loaded.memory.add_region(descriptor, vec![0; 0x100]);
loaded
.memory
.write_u16_be(descriptor, PPC_MIXED_MODE_TRAP)
.unwrap();
loaded
.memory
.write_u8(descriptor + 2, PPC_ROUTINE_DESCRIPTOR_VERSION)
.unwrap();
loaded.memory.write_u16_be(descriptor + 10, 0).unwrap();
assert!(ppc_write_routine_record(
&mut loaded.memory,
descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE,
proc_info,
PPC_ROUTINE_RECORD_M68K_ISA,
routine_flags,
callback_entry,
));
}
fn compatibility_binding(
library_name: &str,
symbol_name: &str,
dispatcher_target: PpcImportDispatcherTarget,
) -> PpcImportBinding {
PpcImportBinding {
library_index: 0,
symbol_index: 0,
library_name: library_name.to_string(),
symbol_name: symbol_name.to_string(),
class: 0,
weak: false,
address: 0,
tvector_address: None,
trap_pc: 0,
dispatcher_target,
}
}
mod apple_event_handlers;
mod apple_event_descriptors;
mod hardware_compatibility;
mod math_compatibility;
struct SectionSpec {
total_size: u32,
unpacked_size: u32,
packed_size: u32,
container_offset: u32,
section_kind: u8,
}
fn write_section(bytes: &mut [u8], index: usize, spec: SectionSpec) {
let off = 40 + index * 28;
write_i32(bytes, off, -1);
write_u32(bytes, off + 8, spec.total_size);
write_u32(bytes, off + 12, spec.unpacked_size);
write_u32(bytes, off + 16, spec.packed_size);
write_u32(bytes, off + 20, spec.container_offset);
bytes[off + 24] = spec.section_kind;
bytes[off + 25] = 4;
bytes[off + 26] = 4;
}
fn push_c_string(strings: &mut Vec<u8>, value: &[u8]) -> u32 {
let offset = strings.len() as u32;
strings.extend_from_slice(value);
strings.push(0);
offset
}
fn write_symbol(bytes: &mut [u8], offset: usize, class_byte: u8, name_offset: u32) {
bytes[offset] = class_byte;
bytes[offset + 1] = ((name_offset >> 16) & 0xff) as u8;
bytes[offset + 2] = ((name_offset >> 8) & 0xff) as u8;
bytes[offset + 3] = (name_offset & 0xff) as u8;
}
fn run_reloc(dispatch: u8, run_length: u16) -> u16 {
(u16::from(dispatch) << 9) | ((run_length - 1) & 0x01ff)
}
fn sm_index_reloc(dispatch: u8, index: u16) -> u16 {
(u16::from(dispatch) << 9) | (index & 0x01ff)
}
fn delt(offset: u16) -> u16 {
(0x40u16 << 9) | ((offset - 1) & 0x0fff)
}
fn d_form_u(opcd: u8, rt: u8, ra: u8, value: u16) -> u32 {
((opcd as u32) << 26)
| ((rt as u32 & 0x1f) << 21)
| ((ra as u32 & 0x1f) << 16)
| u32::from(value)
}
fn x_form(opcd: u8, rt: u8, ra: u8, rb: u8, xo: u16, rc: bool) -> u32 {
((opcd as u32 & 0x3f) << 26)
| ((rt as u32 & 0x1f) << 21)
| ((ra as u32 & 0x1f) << 16)
| ((rb as u32 & 0x1f) << 11)
| ((xo as u32 & 0x3ff) << 1)
| u32::from(rc)
}
fn a_form_fp(opcd: u8, frt: u8, fra: u8, frb: u8, frc: u8, xo_5: u8, rc: bool) -> u32 {
((opcd as u32 & 0x3f) << 26)
| ((frt as u32 & 0x1f) << 21)
| ((fra as u32 & 0x1f) << 16)
| ((frb as u32 & 0x1f) << 11)
| ((frc as u32 & 0x1f) << 6)
| ((xo_5 as u32 & 0x1f) << 1)
| u32::from(rc)
}
fn xfx_form(opcd: u8, rt_or_rs: u8, spr_decimal: u16, xo: u16) -> u32 {
let high_5 = (spr_decimal >> 5) & 0x1f;
let low_5 = spr_decimal & 0x1f;
((opcd as u32 & 0x3f) << 26)
| ((rt_or_rs as u32 & 0x1f) << 21)
| ((low_5 as u32) << 16)
| ((high_5 as u32) << 11)
| ((xo as u32 & 0x3ff) << 1)
}
fn xl_form(opcd: u8, bo: u8, bi: u8, xo: u16, lk: bool) -> u32 {
((opcd as u32 & 0x3f) << 26)
| ((bo as u32 & 0x1f) << 21)
| ((bi as u32 & 0x1f) << 16)
| ((xo as u32 & 0x3ff) << 1)
| u32::from(lk)
}
fn write_i32(bytes: &mut [u8], offset: usize, value: i32) {
bytes[offset..offset + 4].copy_from_slice(&value.to_be_bytes());
}
fn write_u32(bytes: &mut [u8], offset: usize, value: u32) {
bytes[offset..offset + 4].copy_from_slice(&value.to_be_bytes());
}
fn write_u16(bytes: &mut [u8], offset: usize, value: u16) {
bytes[offset..offset + 2].copy_from_slice(&value.to_be_bytes());
}