//! HLE-side PowerPC loader handoff.
//!
//! The PEF parser lives in [`super::pef`]. This module turns parsed and
//! instantiated PEF data into deterministic CPU + guest-address-space state:
//! section bases, relocations, synthetic import TVectors, and an initial
//! stack frame. Parsed loader facts are mapped here into the native runtime;
//! optional PEF dump formatting lives in the private `pef_dump` child.
use crate::guest_call::{MenuBarBuildResume, MenuBarCallOrigin};
#[cfg(test)]
use super::pef::SECTION_KIND_UNPACKED_DATA;
use super::pef::{
apply_pef_relocations_detailed, instantiate_pef_sections, parse_pef_header,
parse_pef_imported_symbols, parse_pef_loader_header, parse_pef_reloc_headers,
parse_pef_sections, pef_reloc_chunk_stream, resolve_pef_imports, PefRelocApplyError,
PefRelocContext, SECTION_KIND_CODE, SECTION_KIND_CONSTANT,
};
use super::ApplicationSizeResource;
use crate::callback_manager::CallbackTaskArchitecture;
use crate::cfm::fragment::{
first_base_for_kind, first_data_base, section_bases, CfmSection as MappedSection,
};
use crate::cfm::{CfmLoadId, CfmOperation, CfmResourceCall, CfmResourcePreparation};
use crate::event_queue::{
EventProbeResult, EventQueue, EventQueueProbeSnapshot, EventRecordSnapshot, QueuedEvent,
};
use crate::guest_call::{
format_ppc_import_action, install_powerpc_call_arguments, ExecutionMenuViews,
GuestCallContinuation, GuestCallEffect, GuestCallRequest, GuestCallTarget, MenuTrackingCall,
MenuTrackingOrigin, NativeRetirement, SharedGuestCallStack,
};
use crate::guest_procedure::{
resolve_guest_procedure, GuestIsa, GuestProcedure,
ROUTINE_DESCRIPTOR_HEADER_SIZE as PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE,
ROUTINE_DESCRIPTOR_MIXED_MODE_TRAP as PPC_MIXED_MODE_TRAP,
ROUTINE_DESCRIPTOR_VERSION as PPC_ROUTINE_DESCRIPTOR_VERSION,
ROUTINE_FLAG_DONT_PASS_SELECTOR as PPC_ROUTINE_FLAG_DONT_PASS_SELECTOR,
ROUTINE_FLAG_USE_NATIVE_ISA as PPC_ROUTINE_FLAG_USE_NATIVE_ISA,
ROUTINE_RECORD_FLAGS_OFFSET as PPC_ROUTINE_RECORD_FLAGS_OFFSET,
ROUTINE_RECORD_ISA_OFFSET as PPC_ROUTINE_RECORD_ISA_OFFSET,
ROUTINE_RECORD_M68K_ISA as PPC_ROUTINE_RECORD_M68K_ISA,
ROUTINE_RECORD_POWERPC_ISA as PPC_ROUTINE_RECORD_POWERPC_ISA,
ROUTINE_RECORD_PROC_DESCRIPTOR_OFFSET as PPC_ROUTINE_RECORD_PROC_DESCRIPTOR_OFFSET,
ROUTINE_RECORD_SIZE as PPC_ROUTINE_RECORD_SIZE,
};
#[cfg(test)]
use crate::guest_procedure::{
ROUTINE_FLAG_PROC_DESCRIPTOR_RELATIVE as PPC_ROUTINE_FLAG_PROC_DESCRIPTOR_RELATIVE,
ROUTINE_RECORD_SELECTOR_OFFSET as PPC_ROUTINE_RECORD_SELECTOR_OFFSET,
};
use crate::list_manager::ProcessListManagerState;
use crate::machine_profile::{
REFERENCE_MACHINE_PROFILE, REFERENCE_POWERPC_EXECUTION_CAPABILITIES,
};
use crate::managers::resource::{
serialize_resource_fork_with_attrs, ResourceFork, ResourceForkEntry,
};
use crate::memory::{GuestAddressSpace as PpcSectionMem, MacMemoryBus, MemoryBus};
use crate::menu_manager::{
compiled_menu_color_entries, filter_menu_color_entries,
for_each_standard_hierarchy_indicator_pixel, for_each_standard_menu_bar_corner_pixel,
for_each_standard_scroll_down_indicator_pixel, for_each_standard_scroll_up_indicator_pixel,
install_menu_list_copy, is_standard_system_menu_title, laid_out_menu_item_count,
menu_choice_value, merge_menu_color_entries, new_standard_menu_record,
standard_menu_bar_system_mark_top, standard_menu_bar_title_baseline,
standard_menu_gray_pattern_is_ink, standard_menu_height, standard_menu_highlighted_value,
standard_menu_icon_kind, standard_menu_icon_resource_id, standard_menu_item_layout,
standard_menu_text_advance, standard_menu_title_advance, standard_menu_width,
standard_popup_menu_layout, standard_pull_down_menu_layout, standard_submenu_layout,
ColorIconLayout, MenuBarBuild, MenuBarResource, MenuBarTitleRegion,
MenuColorTable, MenuDefinitionInvocation, MenuDefinitionMessage, MenuDefinitionPane,
MenuDefinitionTracking, MenuItem as PpcMenuItemDefinition, MenuItems, MenuKeyItem, MenuKeyMenu,
MenuKeySelection, MenuList as PpcMenuListDefinition, MenuListInstallRequest, MenuRow, MenuRows,
MenuSnapshotRecord, MenuFlashStep, MenuTrackingKind, MenuTrackingPane, MenuTrackingRequest, MenuTrackingSurface,
MonochromeMenuIconLayout, PopupMenuRequest, ProcessMenuTrackingState, ProcessTrackedMenuPane,
SharedNativeMenuSelection, StandardMenuChrome, StandardMenuIconKind, StandardMenuItemWidth,
StandardMenuPaneKind, SubmenuReconciliation, SubmenuRequest,
TrackedMenuIcon as PpcTrackedMenuIcon,
TrackedMenuItemAppearance as PpcTrackedMenuItemAppearance, TrackedMenuPaneView,
MAX_MENU_LIST_ENTRIES, STANDARD_MENU_BAR_FIRST_TITLE_LEFT, STANDARD_MENU_BAR_TITLE_SPACING,
STANDARD_MENU_DEFINITION_SHIM, STANDARD_MENU_SEPARATOR_HEIGHT,
};
#[cfg(test)]
use crate::menu_manager::{
MenuListEntry as PpcMenuListEntry, MENU_COLOR_ENTRY_SIZE, STANDARD_MENU_BAR_TITLE_ORIGIN_INSET,
};
use crate::menu_model::GuestMenuSnapshot;
use crate::process_context::{
ProcessAppleEventHandler, ProcessContext, ProcessFileSystemState,
ProcessHandleHeap, ProcessHandleRecord, ProcessHandleStateRecord,
ProcessMemoryManager, ProcessNewHandleBackend, ProcessNewHandleRequest,
ProcessNativeHeapState, ProcessNativeMemoryManager, ProcessPtrRecord,
ProcessResourceManagerState, ProcessVfsFileRecords,
ProcessVfsResourceFileRecords, ProcessWorkingDirectory, SharedProcessAppleEventHandlers,
SharedProcessAppleEventLaunchState,
SharedProcessCallbackScheduling, SharedProcessCursorState, SharedProcessDialogText,
SharedProcessDisplayClut,
SharedProcessControlManager, SharedProcessEventQueue,
SharedProcessFileSystem, SharedProcessInputState, SharedProcessMemoryManager,
DEFAULT_QUICKDRAW_HILITE_COLOR,
SharedProcessMixedModeM68kState,
SharedProcessQuickDrawHiliteColors, SharedProcessQuickDrawOpColors,
SharedProcessDisplayGamma, SharedProcessQuickDrawPixelStates, SharedProcessResourcePolicy,
SharedProcessTickState, SharedProcessTimerTasks, SharedProcessValue, SharedProcessVblTasks,
SharedProcessWindowList,
};
use crate::process_manager::{
resolve_process_application_metadata, ProcessSerialNumber, SingleProcessEnumeration,
};
use crate::quickdraw::fonts::style::{
get_italic_end_extend, get_italic_slant, get_italic_underline_extend_left,
};
use crate::quickdraw::fonts::{
font_id_for_name, font_name_for_id, get_font_face, get_font_face_scale_ratio,
get_font_face_scaled, FONT_APPLICATION,
};
use crate::quickdraw::text::{
get_font_metrics, get_glyph, get_glyph_italic, get_underline_thickness, QuickDrawTextStyle,
};
use crate::trap::extended80::Extended80;
use crate::trap::manager::{
TrapManager, TrapManagerMemoryOp, TrapManagerMemoryResult, TrapManagerSetError, TrapTableKind,
};
use crate::trap::types::{decode_mac_roman, encode_mac_roman_lossy, Rect};
use crate::trap::{pict, TrapDispatcher};
use crate::thread_manager::{RetiredThreadStorageEdge, ThreadManager};
use crate::ui_theme::{render_scrollbar_bitmap, Rgb8, ThemeBitmap, UiThemeId};
use ppc::{
PpcAlignmentPolicy, PpcCpu, PpcException, PpcExecutionContext, PpcFetchHistogram,
PpcFetchObserver, PpcImportAction, PpcMemory, PpcMemoryWriteObserver, PpcNativeReturnGpr3,
PpcRunResult, PpcSectionMemSpan,
};
use std::cell::Cell;
use std::collections::{HashMap, HashSet, VecDeque};
use std::sync::OnceLock;
mod dispatch_cfm;
use dispatch_cfm::*;
mod dispatch_apple_events;
use dispatch_apple_events::*;
mod dispatch_bit_transfers;
mod dispatch_color_tables;
mod dispatch_control;
mod dispatch_cursor;
mod dispatch_desk;
mod dispatch_devices;
mod dispatch_dialog;
mod dispatch_drawsprocket;
mod dispatch_event;
mod dispatch_files;
mod dispatch_fonts;
mod dispatch_gestalt;
mod dispatch_graphics_devices;
mod dispatch_gworlds;
mod dispatch_inputsprocket;
mod dispatch_list;
mod dispatch_low_memory;
mod dispatch_math;
mod dispatch_memory;
mod dispatch_menu;
mod dispatch_mixed_mode;
mod dispatch_native_exceptions;
use dispatch_native_exceptions::*;
mod dispatch_palettes;
mod dispatch_picture;
mod dispatch_polygons;
mod dispatch_process;
mod dispatch_qd3d;
mod dispatch_quickdraw;
mod dispatch_quicktime;
mod dispatch_regions;
mod dispatch_resources;
mod dispatch_scrap;
mod dispatch_sound;
mod dispatch_standard_file;
mod dispatch_textedit;
mod dispatch_threads;
mod dispatch_time;
mod dispatch_stdc;
mod dispatch_toolbox;
mod dispatch_window;
mod dispatch_display;
use dispatch_control::*;
pub(crate) use dispatch_dialog::PpcDialogCallbackState;
use dispatch_dialog::*;
pub(crate) use dispatch_stdc::{PpcQsortState, PpcStdSignalState};
pub(in crate::loader::ppc) use dispatch_mixed_mode::*;
pub(super) use dispatch_stdc::*;
pub(super) use dispatch_window::*;
#[cfg(test)]
use dispatch_display::*;
#[cfg(test)]
use dispatch_list::*;
use dispatch_standard_file::*;
mod pef_dump;
mod theme;
#[cfg(test)]
use pef_dump::format_pef_dump_json;
use pef_dump::{maybe_write, PefDumpContext};
use theme::*;
use dispatch_time::ppc_sync_vbl_task_links;
#[cfg(test)]
pub(crate) use dispatch_time::{
ppc_install_time_task, ppc_install_vbl_task, ppc_remove_time_task, ppc_remove_vbl_task,
};
use dispatch_event::{
dispatch_button_import, dispatch_getkeys_import, dispatch_microseconds_import,
dispatch_still_down_import, dispatch_tick_count_import, ppc_still_down_result,
ppc_wait_mouse_up_result, PpcTickCountIdlePollState,
};
pub mod graphics;
pub mod imports;
pub mod qd3d;
pub mod quicktime;
pub mod sound;
pub mod sprockets;
pub mod vfs;
pub use graphics::*;
pub use imports::*;
pub use qd3d::*;
pub use quicktime::*;
pub use sound::*;
pub use sprockets::*;
pub use vfs::*;
#[derive(Debug, Clone, Copy)]
struct SystemlessPpcImportBindingPolicy;
impl PpcImportBindingPolicy for SystemlessPpcImportBindingPolicy {
fn dispatcher_target(&self, library: &str, symbol: &str) -> PpcImportDispatcherTarget {
dispatcher_target_for_import(library, symbol)
}
fn fixed_data_address(&self, library: &str, symbol: &str) -> Option<u32> {
import_data_address_for(library, symbol)
}
fn is_explicit_hle_library(&self, library: &str) -> bool {
ppc_is_explicit_hle_cfm_library(library)
}
}
fn ppc_import_layout() -> PpcImportLayout {
PpcImportLayout {
capacity: PPC_IMPORT_CAPACITY,
tvector_base: PPC_IMPORT_TVECTOR_BASE,
trap_base: PPC_IMPORT_TRAP_BASE,
}
}
fn ppc_initial_import_error(error: PpcImportBindingError) -> PpcLoadError {
match error {
PpcImportBindingError::SymbolIndexOutOfRange {
symbol_index,
import_count,
} => PpcLoadError::ImportBindingOutOfRange {
symbol_index,
import_count,
},
PpcImportBindingError::CapacityExceeded {
import_count,
capacity,
} => PpcLoadError::ImportCapacityExceeded {
import_count,
capacity,
},
PpcImportBindingError::CountOverflow
| PpcImportBindingError::BindingAddressOverflow
| PpcImportBindingError::AddressTableOutOfRange => PpcLoadError::AddressOverflow,
PpcImportBindingError::RegistryChanged => unreachable!("fresh import plan has no registry"),
}
}
pub(in crate::loader::ppc) fn ppc_dynamic_import_error(error: PpcImportBindingError) -> i16 {
match error {
PpcImportBindingError::CountOverflow
| PpcImportBindingError::CapacityExceeded { .. }
| PpcImportBindingError::AddressTableOutOfRange => PPC_FRAG_NO_MEM,
PpcImportBindingError::SymbolIndexOutOfRange { .. }
| PpcImportBindingError::BindingAddressOverflow
| PpcImportBindingError::RegistryChanged => PPC_FRAG_CORRUPT_ERR,
}
}
pub(crate) fn ppc_initial_process_file_system() -> SharedProcessFileSystem {
let mut state = ProcessFileSystemState::default();
state.stdio_streams = ppc_initial_stdio_streams();
state.next_file_ref_num = PPC_FIRST_FILE_REF_NUM;
state.vfs_directories.replace(initial_ppc_vfs_directories());
state
.next_vfs_dir_id
.with_mut(|next_dir_id| *next_dir_id = PPC_FIRST_DYNAMIC_DIR_ID);
state
.default_dir_id
.with_mut(|default_dir_id| *default_dir_id = PPC_ROOT_DIR_ID);
SharedProcessFileSystem::from_state(state)
}
pub const PPC_CODE_BASE: u32 = 0x0100_0000;
const PPC_CUR_RES_FILE_ADDR: u32 = 0x0000_0A5A;
pub const PPC_IMPORT_TVECTOR_BASE: u32 = 0x01e0_0000;
pub const PPC_IMPORT_TRAP_BASE: u32 = 0x01f0_0000;
const PPC_IMPORT_DATA_BASE: u32 = 0x01d0_0000;
const PPC_IMPORT_DATA_SIZE: usize = 0x1000;
const PPC_IMPORT_CTYPE_POINTER: u32 = PPC_IMPORT_DATA_BASE + 0x40c;
const PPC_IMPORT_MATH_PI: u32 = PPC_IMPORT_DATA_BASE + 0x410;
const PPC_IMPORT_MATH_FE_DFL_ENV: u32 = PPC_IMPORT_DATA_BASE + 0x418;
const PPC_IMPORT_STD_DBL_EPSILON: u32 = PPC_IMPORT_DATA_BASE + 0x420;
const PPC_IMPORT_STD_DBL_MAX: u32 = PPC_IMPORT_DATA_BASE + 0x428;
const PPC_IMPORT_STD_DBL_MIN: u32 = PPC_IMPORT_DATA_BASE + 0x430;
const PPC_IMPORT_STD_FLT_EPSILON: u32 = PPC_IMPORT_DATA_BASE + 0x438;
const PPC_IMPORT_STD_FLT_MAX: u32 = PPC_IMPORT_DATA_BASE + 0x43c;
const PPC_IMPORT_STD_FLT_MIN: u32 = PPC_IMPORT_DATA_BASE + 0x440;
const PPC_IMPORT_STD_ERRNO: u32 = PPC_IMPORT_DATA_BASE + 0x444;
const PPC_IMPORT_STD_MAC_OS_ERR: u32 = PPC_IMPORT_DATA_BASE + 0x448;
const PPC_IMPORT_CTYPE_TABLE: u32 = PPC_IMPORT_DATA_BASE + 0x500;
const PPC_IMPORT_CUR_AP_NAME: u32 = PPC_IMPORT_DATA_BASE + 0x900;
// Metrowerks StdCLib exposes `_iob` as the three 24-byte FILE records used
// for stdin, stdout, and stderr. Keep this zero-initialized storage in the
// stable import-data page. The actual FILE fields are private to StdCLib, so
// stream state lives in host-side metadata keyed by the guest FILE pointer.
const PPC_STDIO_IOB_ADDR: u32 = PPC_IMPORT_DATA_BASE + 0xa00;
const PPC_STDIO_FILE_SIZE: u32 = 24;
pub const PPC_CFM_MAIN_STUB_BASE: u32 = 0x01d8_0000;
pub const PPC_MAIN_GWORLD: u32 = 0x02f0_0000;
pub const PPC_MAIN_GDEVICE: u32 = 0x02f0_0100;
pub const PPC_DSP_BACK_GWORLD: u32 = 0x0501_0000;
pub const PPC_DATA_BASE: u32 = 0x0200_0000;
pub const PPC_HEAP_BASE: u32 = 0x0300_0000;
const PPC_HEAP_ALIGNMENT: u32 = 16;
pub const PPC_STACK_TOP: u32 = 0x0500_0000;
pub const PPC_DEFAULT_STACK_SIZE: u32 = 64 * 1024;
pub const PPC_STACK_SIZE: u32 = PPC_DEFAULT_STACK_SIZE;
pub const PPC_STACK_BASE: u32 = PPC_STACK_TOP - PPC_DEFAULT_STACK_SIZE;
pub const PPC_HALT_PC: u32 = 0;
const PPC_LOW_MEMORY_SIZE: usize = 64 * 1024;
const PPC_CLASSIC_APP_MEMORY_BASE: u32 = PPC_LOW_MEMORY_SIZE as u32;
const PPC_THE_ZONE_ADDR: u32 = 0x0000_0118;
const PPC_SYS_ZONE_ADDR: u32 = 0x0000_02a6;
const PPC_APPL_ZONE_ADDR: u32 = 0x0000_02aa;
const PPC_MMU_32BIT_ADDR: u32 = 0x0000_0cb2;
const PPC_CLASSIC_APP_MEMORY_SIZE: usize = 0x000f_0000;
pub const PPC_MEM_FULL_ERR: i16 = -108;
const PPC_NIL_HANDLE_ERR: i16 = -109;
#[cfg(test)]
const PPC_MEM_WZ_ERR: i16 = -111;
#[cfg(test)]
const PPC_MEM_PUR_ERR: i16 = -112;
const PPC_C_DEPTH_ERR: i16 = -157;
pub const PPC_NO_ERR: i16 = 0;
const PPC_EVT_NOT_ENB: i16 = 1;
pub const PPC_EOF_ERR: i16 = -39;
pub const PPC_FN_OPN_ERR: i16 = -38;
pub const PPC_POS_ERR: i16 = -40;
pub const PPC_NSV_ERR: i16 = -35;
pub const PPC_FNF_ERR: i16 = -43;
pub const PPC_DUP_FN_ERR: i16 = -48;
pub const PPC_RF_NUM_ERR: i16 = -51;
pub const PPC_WR_PERM_ERR: i16 = -61;
pub const PPC_PARAM_ERR: i16 = -50;
pub const PPC_C_RES_ERR: i16 = -156;
pub const PPC_DIR_NF_ERR: i16 = -120;
const PPC_PIXMAP_TOO_DEEP_ERR: i16 = -148;
const PPC_RGN_TOO_BIG_ERR: i16 = -500;
const PPC_OPEN_ERR: i16 = -23;
const PPC_BD_NAM_ERR: i16 = -37;
const PPC_PROC_NOT_FOUND_ERR: i16 = -600;
const PPC_DSP_CONTEXT_ALREADY_RESERVED_ERR: i16 = -30444;
const PPC_DSP_CONTEXT_NOT_RESERVED_ERR: i16 = -30445;
const PPC_DSP_CONTEXT_NOT_FOUND_ERR: i16 = -30446;
const PPC_NOT_ENOUGH_HARDWARE_ERR: i16 = -201;
const PPC_SM_NO_MORE_SRSRCS_ERR: i16 = -344;
const PPC_NO_MPP_ERR: i16 = -3102;
const PPC_ERR_AE_DESC_NOT_FOUND: i16 = -1701;
const PPC_ERR_AE_EVENT_NOT_HANDLED: i16 = -1708;
const PPC_HM_HELP_MANAGER_NOT_INITED: i16 = -855;
const PPC_HIGH_LEVEL_EVENT_MASK: u16 = 0x0400;
const PPC_HIGH_LEVEL_EVENT: u16 = 23;
const PPC_CORE_EVENT_CLASS: u32 = u32::from_be_bytes(*b"aevt");
const PPC_OPEN_APPLICATION_EVENT: u32 = u32::from_be_bytes(*b"oapp");
const PPC_TYPE_WILDCARD: u32 = u32::from_be_bytes(*b"****");
pub const PPC_BAD_FORMAT: i16 = -206;
pub const PPC_CHANNEL_NOT_BUSY: i16 = -211;
pub const PPC_GESTALT_UNDEF_SELECTOR_ERR: i16 = -5551;
pub const PPC_FRAG_LIB_NOT_FOUND: i16 = -2804;
pub const PPC_FRAG_FORMAT_UNKNOWN: i16 = -2806;
pub const PPC_FRAG_HAD_UNRESOLVEDS: i16 = -2807;
pub const PPC_FRAG_NO_MEM: i16 = -2809;
pub const PPC_FRAG_INIT_LOOP: i16 = -2815;
pub const PPC_FRAG_NO_ADDR_SPACE: i16 = -2810;
pub const PPC_FRAG_LIB_CONN_ERR: i16 = -2817;
pub const PPC_FRAG_CONNECTION_ID_NOT_FOUND: i16 = -2801;
pub const PPC_FRAG_SYMBOL_NOT_FOUND: i16 = -2802;
pub const PPC_FRAG_CORRUPT_ERR: i16 = -2820;
pub const PPC_FRAG_USER_INIT_PROC_ERR: i16 = -2821;
pub const PPC_FRAG_ARCH_ERR: i16 = -2823;
pub const PPC_INVALID_COMPONENT_ID: i16 = -3000;
pub const PPC_RES_NOT_FOUND_ERR: i16 = -192;
pub const PPC_RES_F_NOT_FOUND_ERR: i16 = -193;
pub const PPC_RESOURCE_IN_MEMORY_ERR: i16 = -188;
pub const PPC_INPUT_OUT_OF_BOUNDS_ERR: i16 = -190;
pub const PPC_ADD_RES_FAILED: i16 = -194;
pub const PPC_RMV_RES_FAILED: i16 = -196;
pub const PPC_RES_ATTR_ERR: i16 = -198;
const BLR: u32 = 0x4e80_0020;
const PPC_FIRST_FILE_REF_NUM: i16 = 128;
const PPC_CLOSED_RESOURCE_REF_NUM: i16 = i16::MIN;
const PPC_PICT_INFO_SIZE: u32 = 104;
const PPC_CFM_MAIN_STUB_COUNT: u32 = 256;
const PPC_IMPORT_CAPACITY: u32 = 4096;
// The final mapped traps are reserved for guest-call and thread returns and
// does not reduce the 4,096 application/CFM binding capacity.
const PPC_IMPORT_SLOT_COUNT: u32 = PPC_IMPORT_CAPACITY + 2;
const PPC_THREAD_RETURN_IMPORT_INDEX: u32 = PPC_IMPORT_CAPACITY + 1;
pub(super) const PPC_THREAD_RETURN_PC: u32 =
PPC_IMPORT_TRAP_BASE + PPC_THREAD_RETURN_IMPORT_INDEX * 4;
const PPC_GUEST_CALL_RETURN_IMPORT_INDEX: u32 = PPC_IMPORT_CAPACITY;
const PPC_FIRST_CFM_CONNECTION_ID: u32 = 1;
const PPC_CFM_FIND_LIB: u32 = 2;
const PPC_CFM_LOAD_LIB: u32 = 1;
const PPC_CFM_LOAD_NEW_COPY: u32 = 5;
const PPC_CFM_POWERPC_ARCH: u32 = u32::from_be_bytes(*b"pwpc");
#[cfg(test)]
use crate::cfm::CFM_INIT_BLOCK_SIZE as PPC_CFM_INIT_BLOCK_SIZE;
pub(super) const PPC_INITIAL_STACK_FRAME_SIZE: u32 = 64;
const PPC_INTERRUPT_RED_ZONE_SIZE: u32 = 224;
const PPC_PARAMETER_AREA_OFFSET: u32 = 24;
const PPC_LINKAGE_BACK_CHAIN_OFFSET: u32 = 0;
const PPC_LINKAGE_SAVED_CR_OFFSET: u32 = 4;
const PPC_LINKAGE_SAVED_LR_OFFSET: u32 = 8;
const PPC_LINKAGE_SAVED_RTOC_OFFSET: u32 = 20;
pub(super) const PPC_GUEST_CALL_RETURN_PC: u32 = PPC_IMPORT_TRAP_BASE + PPC_GUEST_CALL_RETURN_IMPORT_INDEX * 4;
const PPC_APPLICATION_INIT_RETURN_PC: u32 = PPC_IMPORT_TRAP_BASE - 0x100;
const PPC_EXCEPTION_INFORMATION_SIZE: u32 = 24;
const PPC_EXCEPTION_MACHINE_INFORMATION_SIZE: u32 = 64;
const PPC_EXCEPTION_REGISTER_INFORMATION_SIZE: u32 = 256;
const PPC_EXCEPTION_FPU_INFORMATION_SIZE: u32 = 264;
const PPC_EXCEPTION_VECTOR_INFORMATION_SIZE: u32 = 532;
const PPC_EXCEPTION_MEMORY_INFORMATION_SIZE: u32 = 16;
// Universal Interfaces 3.4, MachineExceptions.h defines these exception and
// reference-kind values. Mac OS 8.1 reports status 5 for an unmapped access.
const PPC_ILLEGAL_INSTRUCTION_EXCEPTION: u32 = 1;
const PPC_TRAP_EXCEPTION: u32 = 2;
const PPC_UNMAPPED_MEMORY_EXCEPTION: u32 = 4;
const PPC_UNMAPPED_MEMORY_ERROR: u32 = 5;
const PPC_WRITE_REFERENCE: u32 = 0;
const PPC_READ_REFERENCE: u32 = 1;
const PPC_PROCINFO_CALLING_CONVENTION_MASK: u32 =
crate::mixed_mode::proc_info::CALLING_CONVENTION_MASK;
const PPC_PROCINFO_PASCAL_STACK_BASED: u32 = crate::mixed_mode::proc_info::PASCAL_STACK_BASED;
const PPC_PROCINFO_C_STACK_BASED: u32 = crate::mixed_mode::proc_info::C_STACK_BASED;
const PPC_PROCINFO_REGISTER_BASED: u32 = crate::mixed_mode::proc_info::REGISTER_BASED;
const PPC_PROCINFO_THINK_C_STACK_BASED: u32 = crate::mixed_mode::proc_info::THINK_C_STACK_BASED;
const PPC_PROCINFO_D0_DISPATCHED_PASCAL_STACK_BASED: u32 =
crate::mixed_mode::proc_info::D0_DISPATCHED_PASCAL_STACK_BASED;
const PPC_PROCINFO_D0_DISPATCHED_C_STACK_BASED: u32 =
crate::mixed_mode::proc_info::D0_DISPATCHED_C_STACK_BASED;
const PPC_PROCINFO_D1_DISPATCHED_PASCAL_STACK_BASED: u32 =
crate::mixed_mode::proc_info::D1_DISPATCHED_PASCAL_STACK_BASED;
const PPC_PROCINFO_STACK_DISPATCHED_PASCAL_STACK_BASED: u32 =
crate::mixed_mode::proc_info::STACK_DISPATCHED_PASCAL_STACK_BASED;
const PPC_PROCINFO_SPECIAL_CASE: u32 = crate::mixed_mode::proc_info::SPECIAL_CASE;
const PPC_PROCINFO_RESULT_SIZE_PHASE: u32 = crate::mixed_mode::proc_info::RESULT_SIZE_PHASE;
const PPC_PROCINFO_STACK_PARAMETER_PHASE: u32 = crate::mixed_mode::proc_info::STACK_PARAMETER_PHASE;
const PPC_PROCINFO_STACK_PARAMETER_WIDTH: u32 = crate::mixed_mode::proc_info::STACK_PARAMETER_WIDTH;
const PPC_PROCINFO_DISPATCHED_SELECTOR_SIZE_PHASE: u32 =
crate::mixed_mode::proc_info::DISPATCHED_SELECTOR_SIZE_PHASE;
const PPC_PROCINFO_DISPATCHED_PARAMETER_PHASE: u32 =
crate::mixed_mode::proc_info::DISPATCHED_PARAMETER_PHASE;
const PPC_PROCINFO_REGISTER_RESULT_LOCATION_PHASE: u32 =
crate::mixed_mode::proc_info::REGISTER_RESULT_LOCATION_PHASE;
const PPC_PROCINFO_REGISTER_PARAMETER_PHASE: u32 =
crate::mixed_mode::proc_info::REGISTER_PARAMETER_PHASE;
const PPC_PROCINFO_REGISTER_PARAMETER_WIDTH: u32 =
crate::mixed_mode::proc_info::REGISTER_PARAMETER_WIDTH;
const PPC_PROCINFO_REGISTER_PARAMETER_SIZE_MASK: u32 =
crate::mixed_mode::proc_info::REGISTER_PARAMETER_SIZE_MASK;
const PPC_PROCINFO_REGISTER_PARAMETER_WHICH_SHIFT: u32 =
crate::mixed_mode::proc_info::REGISTER_PARAMETER_WHICH_SHIFT;
const PPC_PROCINFO_REGISTER_PARAMETER_WHICH_MASK: u32 =
crate::mixed_mode::proc_info::REGISTER_PARAMETER_WHICH_MASK;
const PPC_PROCINFO_REGISTER_CCR_C: u32 = crate::mixed_mode::proc_info::REGISTER_CCR_C;
const PPC_PROCINFO_REGISTER_CCR_V: u32 = crate::mixed_mode::proc_info::REGISTER_CCR_V;
const PPC_PROCINFO_REGISTER_CCR_Z: u32 = crate::mixed_mode::proc_info::REGISTER_CCR_Z;
const PPC_PROCINFO_REGISTER_CCR_N: u32 = crate::mixed_mode::proc_info::REGISTER_CCR_N;
const PPC_PROCINFO_REGISTER_CCR_X: u32 = crate::mixed_mode::proc_info::REGISTER_CCR_X;
const PPC_CR0_LT_BIT: u8 = 0;
const PPC_CR0_EQ_BIT: u8 = 2;
const PPC_PROCINFO_SIZE_NONE: u32 = crate::mixed_mode::proc_info::SIZE_NONE;
const PPC_PROCINFO_SIZE_ONE: u32 = crate::mixed_mode::proc_info::SIZE_ONE;
const PPC_PROCINFO_SIZE_TWO: u32 = crate::mixed_mode::proc_info::SIZE_TWO;
const PPC_PROCINFO_SIZE_FOUR: u32 = crate::mixed_mode::proc_info::SIZE_FOUR;
const PPC_PROCINFO_MAX_STACK_PARAMETERS: usize = crate::mixed_mode::proc_info::MAX_STACK_PARAMETERS;
const PPC_PROCINFO_MAX_DISPATCHED_STACK_PARAMETERS: usize =
crate::mixed_mode::proc_info::MAX_DISPATCHED_STACK_PARAMETERS;
const PPC_PROCINFO_MAX_REGISTER_PARAMETERS: usize =
crate::mixed_mode::proc_info::MAX_REGISTER_PARAMETERS;
const PPC_CALL_UNIVERSAL_PROC_FIXED_WORD_PARAMETERS: usize = 2;
const PPC_CALL_UNIVERSAL_PROC_REGISTER_VARARGS: usize = 6;
const PPC_NATIVE_PARAMETER_GPR_COUNT: usize = 8;
const PPC_MAX_STACK_SIZE: u32 = PPC_STACK_TOP - PPC_HEAP_BASE;
pub(super) const PPC_RAND_SEED_ADDR: u32 = 0x0000_0156;
const PPC_GRAY_RGN_ADDR: u32 = 0x0000_09ee;
// TheMenu identifies the menu owning the selected item. For a hierarchical
// choice this is the submenu ID even though its originating regular title is
// visibly highlighted. Macintosh Toolbox Essentials (1992), pp. 3-115--3-119;
// Inside Macintosh Volume V (1986), pp. V-244 and V-571.
const PPC_THE_MENU_ADDR: u32 = crate::memory::globals::addr::THE_MENU;
fn ppc_current_menu_list(memory: &mut PpcSectionMem) -> u32 {
memory
.read_u32_be(crate::memory::globals::addr::MENU_LIST)
.unwrap_or(0)
}
fn ppc_set_current_menu_list(memory: &mut PpcSectionMem, menu_list: u32) {
let _ = memory.write_u32_be(crate::memory::globals::addr::MENU_LIST, menu_list);
}
const PPC_MBAR_HEIGHT_ADDR: u32 = 0x0000_0baa;
const PPC_DEFAULT_DOUBLE_TIME_TICKS: u32 = 20;
const PPC_RES_CHANGED_ATTR: u16 = 0x0002;
const PPC_RES_PROTECTED_ATTR: u16 = 0x0008;
const PPC_BOOT_VOLUME_REF_NUM: i16 = -1;
const PPC_ROOT_DIR_ID: u32 = 2;
const PPC_SYSTEM_FOLDER_DIR_ID: u32 = 16;
const PPC_PREFERENCES_DIR_ID: u32 = 17;
const PPC_FIRST_DYNAMIC_DIR_ID: u32 = 18;
const PPC_DIRECTORY_FILE_TYPE: u32 = u32::from_be_bytes(*b"fold");
const PPC_DIRECTORY_CREATOR: u32 = u32::from_be_bytes(*b"MACS");
const PPC_FSSPEC_SIZE: usize = 70;
const PPC_FSSPEC_MAX_NAME_LEN: usize = 63;
const PPC_ALIAS_RECORD_MAGIC: u32 = u32::from_be_bytes(*b"alis");
const PPC_ALIAS_RECORD_VERSION: u16 = 1;
#[cfg(test)]
const PPC_ALIAS_RECORD_HEADER_SIZE: usize = 16;
#[cfg(test)]
const PPC_ALIAS_RECORD_FSSPEC_OFFSET: usize = PPC_ALIAS_RECORD_HEADER_SIZE;
#[cfg(test)]
const PPC_ALIAS_RECORD_SIZE: usize = PPC_ALIAS_RECORD_HEADER_SIZE + PPC_FSSPEC_SIZE;
const PPC_CLASSIC_ALIAS_RECORD_HEADER_SIZE: usize = 150;
const PPC_CLASSIC_ALIAS_RECORD_VERSION: u16 = 2;
const PPC_CLASSIC_ALIAS_VOLUME_NAME_OFFSET: usize = 10;
const PPC_CLASSIC_ALIAS_FILE_NAME_OFFSET: usize = 50;
const PPC_CLASSIC_ALIAS_DIR_ID_OFFSET: usize = 114;
const PPC_CLASSIC_ALIAS_MYSTERY_WORDS_OFFSET: usize = 130;
const PPC_CLASSIC_ALIAS_TAIL_TAG: u16 = 0x0009;
const PPC_CLASSIC_ALIAS_FULL_PATH_TAG: u16 = 0x0002;
const PPC_CLASSIC_ALIAS_END_TAG: u16 = 0xffff;
const PPC_CLASSIC_ALIAS_TAIL_PAYLOAD_SIZE: usize = 168;
const PPC_CLASSIC_ALIAS_RECORD_SIZE: usize =
PPC_CLASSIC_ALIAS_RECORD_HEADER_SIZE + 4 + PPC_CLASSIC_ALIAS_TAIL_PAYLOAD_SIZE + 4;
const PPC_RES_PROBLEM: i16 = -204;
const PPC_NO_SCRAP_ERR: i16 = -100;
const PPC_NO_TYPE_ERR: i16 = -102;
const PPC_SOUND_MANAGER_VERSION: u32 = 0x0333_8000;
const PPC_DEFAULT_OUTPUT_VOLUME: u32 = 0x0001_0000;
const PPC_GUEST_SND_CHANNEL_SIZE: u32 = 1088;
const PPC_SQUARE_WAVE_SYNTH_ID: i16 = 1;
const PPC_WAVE_TABLE_SYNTH_ID: i16 = 3;
const PPC_SAMPLED_SYNTH_ID: i16 = 5;
const PPC_QUICKTIME_VERSION: u32 = 0x0300_0000;
const PPC_QD3D_VERSION: u32 = 0x0150_8000;
const PPC_MAIN_GDEVICE_RECORD: u32 = 0x02f0_0200;
const PPC_MAIN_GDEVICE_FLAGS: u16 =
(1 << 0) | (1 << 10) | (1 << 11) | (1 << 12) | (1 << 13) | (1 << 15);
const PPC_MAIN_PIXMAP_HANDLE: u32 = 0x02f0_0300;
const PPC_MAIN_PIXMAP: u32 = 0x02f0_0400;
const PPC_GRAY_RGN_HANDLE: u32 = 0x02f0_0500;
const PPC_GRAY_RGN: u32 = 0x02f0_0600;
const PPC_MAIN_DCE_HANDLE: u32 = 0x02f0_0700;
const PPC_MAIN_DCE: u32 = 0x02f0_0800;
const PPC_MAIN_CTABLE_HANDLE: u32 = 0x02f0_0900;
const PPC_MAIN_CTABLE: u32 = 0x02f0_3000;
const PPC_MAIN_CTABLE_SIZE: u32 = 8 + 256 * 8;
const PPC_MAIN_VIS_RGN_HANDLE: u32 = 0x02f0_0b00;
const PPC_MAIN_VIS_RGN: u32 = 0x02f0_0c00;
const PPC_MAIN_CLIP_RGN_HANDLE: u32 = 0x02f0_0d00;
const PPC_MAIN_CLIP_RGN: u32 = 0x02f0_0e00;
const PPC_MAIN_GAMMA_TABLE: u32 = 0x02f0_1000;
const PPC_MAIN_GAMMA_TABLE_SIZE: u32 = 12 + 256;
const PPC_PORT_LIST_HANDLE: u32 = 0x02f0_1300;
const PPC_PORT_LIST: u32 = 0x02f0_1400;
const PPC_UNIT_TABLE: u32 = 0x02f0_1500;
const PPC_SOUND_DCE_HANDLE: u32 = 0x02f0_1600;
const PPC_SOUND_DCE: u32 = 0x02f0_1700;
const PPC_PORT_LIST_ADDR: u32 = 0x0d66;
const PPC_APPLICATION_ZONE: u32 = 0x02f0_2000;
const PPC_SYSTEM_ZONE: u32 = 0x02f0_2100;
const PPC_ZONE_STORAGE_SIZE: usize = 64;
const PPC_ZONE_HEAP_TYPE_OFFSET: u32 = 30;
const PPC_ZONE_32_BIT_HEAP: u8 = 1;
const PPC_ZONE_NEW_STYLE_HEAP: u8 = 2;
pub(super) const PPC_MAIN_SCREEN_BASE: u32 = 0x02f1_0000;
const PPC_DSP_BACK_PIXMAP_HANDLE: u32 = 0x0501_0300;
const PPC_DSP_BACK_PIXMAP: u32 = 0x0501_0400;
const PPC_DSP_BACK_VIS_RGN_HANDLE: u32 = 0x0501_0500;
const PPC_DSP_BACK_VIS_RGN: u32 = 0x0501_0600;
const PPC_DSP_BACK_CLIP_RGN_HANDLE: u32 = 0x0501_0700;
const PPC_DSP_BACK_CLIP_RGN: u32 = 0x0501_0800;
const PPC_DSP_BACK_SCREEN_BASE: u32 = 0x0502_0000;
const PPC_MAIN_PIXEL_DEPTH: u32 = REFERENCE_MACHINE_PROFILE.screen_depth as u32;
pub const PPC_QD_TEXT_FONT_DEFAULT: i16 = 0;
pub const PPC_QD_TEXT_MODE_SRC_OR: i16 = 1;
pub const PPC_QD_TEXT_SIZE_SYSTEM: i16 = 0;
const PPC_QD_PEN_MODE_PAT_COPY: i16 = 8;
const PPC_CGRAF_PORT_PN_LOC_OFFSET: u32 = 48;
const PPC_CGRAF_PORT_PN_SIZE_OFFSET: u32 = 52;
const PPC_CGRAF_PORT_PN_MODE_OFFSET: u32 = 56;
const PPC_CGRAF_PORT_PN_VIS_OFFSET: u32 = 66;
const PPC_CGRAF_PORT_VIS_RGN_OFFSET: u32 = 24;
const PPC_CGRAF_PORT_CLIP_RGN_OFFSET: u32 = 28;
const PPC_CGRAF_PORT_GRAF_VARS_OFFSET: u32 = 8;
const PPC_CGRAF_PORT_RGB_FG_COLOR_OFFSET: u32 = 36;
const PPC_CGRAF_PORT_RGB_BK_COLOR_OFFSET: u32 = 42;
const PPC_CGRAF_PORT_BK_PIXPAT_OFFSET: u32 = 32;
const PPC_CGRAF_PORT_TX_FONT_OFFSET: u32 = 68;
const PPC_CGRAF_PORT_TX_FACE_OFFSET: u32 = 70;
const PPC_CGRAF_PORT_TX_MODE_OFFSET: u32 = 72;
const PPC_CGRAF_PORT_TX_SIZE_OFFSET: u32 = 74;
const PPC_CGRAF_PORT_RGN_SAVE_OFFSET: u32 = 96;
// Inside Macintosh: Text (1993), pp. 2-72 and 2-78 through 2-80. These are
// the public TERec and TEStyleRec layouts used by native PowerPC clients.
const PPC_TE_DEST_RECT_OFFSET: u32 = 0x00;
const PPC_TE_VIEW_RECT_OFFSET: u32 = 0x08;
const PPC_TE_SEL_RECT_OFFSET: u32 = 0x10;
const PPC_TE_LINE_HEIGHT_OFFSET: u32 = 0x18;
const PPC_TE_FONT_ASCENT_OFFSET: u32 = 0x1a;
const PPC_TE_SEL_POINT_OFFSET: u32 = 0x1c;
const PPC_TE_SEL_START_OFFSET: u32 = 0x20;
const PPC_TE_SEL_END_OFFSET: u32 = 0x22;
const PPC_TE_ACTIVE_OFFSET: u32 = 0x24;
const PPC_TE_CLICK_TIME_OFFSET: u32 = 0x2e;
const PPC_TE_CLICK_LOC_OFFSET: u32 = 0x32;
const PPC_TE_CARET_TIME_OFFSET: u32 = 0x34;
const PPC_TE_CARET_STATE_OFFSET: u32 = 0x38;
const PPC_TE_JUST_OFFSET: u32 = 0x3a;
const PPC_TE_LENGTH_OFFSET: u32 = 0x3c;
const PPC_TE_HTEXT_OFFSET: u32 = 0x3e;
const PPC_TE_TX_FONT_OFFSET: u32 = 0x4a;
const PPC_TE_TX_FACE_OFFSET: u32 = 0x4c;
const PPC_TE_TX_MODE_OFFSET: u32 = 0x4e;
const PPC_TE_TX_SIZE_OFFSET: u32 = 0x50;
const PPC_TE_IN_PORT_OFFSET: u32 = 0x52;
const PPC_TE_N_LINES_OFFSET: u32 = 0x5e;
const PPC_TE_LINE_STARTS_OFFSET: u32 = 0x60;
const PPC_TE_REC_MIN_SIZE: u32 = 128;
const PPC_TE_STYLE_N_RUNS_OFFSET: u32 = 0x00;
const PPC_TE_STYLE_N_STYLES_OFFSET: u32 = 0x02;
const PPC_TE_STYLE_TABLE_OFFSET: u32 = 0x04;
const PPC_TE_STYLE_LH_TABLE_OFFSET: u32 = 0x08;
const PPC_TE_STYLE_NULL_STYLE_OFFSET: u32 = 0x10;
const PPC_TE_STYLE_RUNS_OFFSET: u32 = 0x14;
const PPC_TE_STYLE_REC_SIZE: u32 = 0x1c;
const PPC_TE_ST_ELEMENT_SIZE: u32 = 0x12;
const PPC_TE_LH_ELEMENT_SIZE: u32 = 0x04;
const PPC_TE_NULL_STYLE_SCRAP_OFFSET: u32 = 0x04;
const PPC_TE_NULL_STYLE_REC_SIZE: u32 = 0x08;
const PPC_TE_STYLE_SCRAP_REC_SIZE: u32 = 0x16;
const PPC_TE_SCRAP_N_STYLES_OFFSET: u32 = 0x00;
const PPC_TE_SCRAP_STYLE_TAB_OFFSET: u32 = 0x02;
const PPC_TE_SCRAP_STYLE_HEIGHT_OFFSET: u32 = 0x04;
const PPC_TE_SCRAP_STYLE_ASCENT_OFFSET: u32 = 0x06;
const PPC_TE_SCRAP_STYLE_FONT_OFFSET: u32 = 0x08;
const PPC_TE_SCRAP_STYLE_FACE_OFFSET: u32 = 0x0a;
const PPC_TE_SCRAP_STYLE_SIZE_OFFSET: u32 = 0x0c;
const PPC_TE_SCRAP_STYLE_COLOR_OFFSET: u32 = 0x0e;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcTeResolvedStyle {
font: i16,
face: u8,
size: i16,
color: PpcRgbColor,
line_height: i16,
ascent: i16,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcTeStyleRun {
start: usize,
style_index: usize,
style: PpcTeResolvedStyle,
}
const PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET: u32 = 156;
const PPC_CGRAF_PORT_PALETTE_UPDATES_OFFSET: u32 = 160;
const PPC_GRAF_PORT_SIZE: u32 = 108;
const PPC_DSP_CONTEXT_STATE_ACTIVE: u32 = 0;
const PPC_DSP_CONTEXT_STATE_PAUSED: u32 = 1;
const PPC_DSP_CONTEXT_STATE_INACTIVE: u32 = 2;
#[cfg(test)]
const PPC_GDEVICE_SIZE: u32 = 62;
const PPC_PIXMAP_SIZE: u32 = 50;
const PPC_CGRAF_PORT_SIZE: u32 = 170;
const PPC_Q3_OBJECT_BASE: u32 = 0x0400_0000;
const PPC_Q3_OBJECT_STRIDE: u32 = 4;
const PPC_Q3_MIPMAP_COPY_SIZE: u32 = 536;
const PPC_Q3_TYPE_NONE: u32 = 0;
const PPC_Q3_TYPE_3DMF: u32 = u32::from_be_bytes(*b"3DMF");
const PPC_Q3_TYPE_BEGIN_GROUP: u32 = u32::from_be_bytes(*b"bgng");
const PPC_Q3_TYPE_END_GROUP: u32 = u32::from_be_bytes(*b"endg");
const PPC_Q3_TYPE_TOC: u32 = u32::from_be_bytes(*b"toc ");
const PPC_Q3_TYPE_REFERENCE: u32 = u32::from_be_bytes(*b"rfrn");
const PPC_Q3_TYPE_CONTAINER: u32 = u32::from_be_bytes(*b"cntr");
const PPC_Q3_TYPE_TRIMESH: u32 = u32::from_be_bytes(*b"tmsh");
const PPC_Q3_TYPE_ATTRIBUTE_ARRAY: u32 = u32::from_be_bytes(*b"atar");
const PPC_Q3_TYPE_FILE: u32 = u32::from_be_bytes(*b"file");
const PPC_Q3_TYPE_VIEW: u32 = u32::from_be_bytes(*b"view");
const PPC_Q3_OBJECT_TYPE_SHARED: u32 = u32::from_be_bytes(*b"shrd");
const PPC_Q3_SHARED_TYPE_RENDERER: u32 = u32::from_be_bytes(*b"rddr");
const PPC_Q3_RENDERER_TYPE_WIREFRAME: u32 = u32::from_be_bytes(*b"wrfr");
const PPC_Q3_RENDERER_TYPE_GENERIC: u32 = u32::from_be_bytes(*b"gnrr");
const PPC_Q3_RENDERER_TYPE_INTERACTIVE: u32 = u32::from_be_bytes(*b"irnd");
const PPC_Q3_RENDERER_TYPE_INTERACTIVE_QUESA: u32 = u32::from_be_bytes(*b"ctwn");
const PPC_Q3_RENDERER_TYPE_OPENGL: u32 = u32::from_be_bytes(*b"oglr");
const PPC_Q3_RENDERER_TYPE_CARTOON: u32 = u32::from_be_bytes(*b"toon");
const PPC_Q3_RENDERER_TYPE_HIDDEN_LINE: u32 = u32::from_be_bytes(*b"hdnl");
const PPC_Q3_SHARED_TYPE_SHAPE: u32 = u32::from_be_bytes(*b"shap");
const PPC_Q3_SHAPE_TYPE_GEOMETRY: u32 = u32::from_be_bytes(*b"gmtr");
const PPC_Q3_SHAPE_TYPE_SHADER: u32 = u32::from_be_bytes(*b"shdr");
const PPC_Q3_SHADER_TYPE_SURFACE: u32 = u32::from_be_bytes(*b"sush");
const PPC_Q3_SHADER_TYPE_ILLUMINATION: u32 = u32::from_be_bytes(*b"ilsh");
const PPC_Q3_SHAPE_TYPE_STYLE: u32 = u32::from_be_bytes(*b"styl");
const PPC_Q3_SHAPE_TYPE_TRANSFORM: u32 = u32::from_be_bytes(*b"xfrm");
const PPC_Q3_SHAPE_TYPE_LIGHT: u32 = u32::from_be_bytes(*b"lght");
const PPC_Q3_SHAPE_TYPE_CAMERA: u32 = u32::from_be_bytes(*b"cmra");
const PPC_Q3_SHAPE_TYPE_GROUP: u32 = u32::from_be_bytes(*b"grup");
const PPC_Q3_SHARED_TYPE_SET: u32 = u32::from_be_bytes(*b"set ");
const PPC_Q3_SHARED_TYPE_DRAW_CONTEXT: u32 = u32::from_be_bytes(*b"dctx");
const PPC_Q3_SHARED_TYPE_TEXTURE: u32 = u32::from_be_bytes(*b"txtr");
const PPC_Q3_SHARED_TYPE_STORAGE: u32 = u32::from_be_bytes(*b"strg");
const PPC_Q3_GROUP_TYPE_DISPLAY: u32 = u32::from_be_bytes(*b"dspg");
const PPC_Q3_GROUP_TYPE_IO_PROXY_DISPLAY: u32 = u32::from_be_bytes(*b"iopx");
const PPC_Q3_GROUP_TYPE_ORDERED_DISPLAY: u32 = u32::from_be_bytes(*b"ordg");
const PPC_Q3_GROUP_TYPE_LIGHT: u32 = u32::from_be_bytes(*b"lghg");
const PPC_Q3_TYPE_ATTRIBUTE_SET: u32 = u32::from_be_bytes(*b"attr");
const PPC_Q3_ILLUMINATION_TYPE_LAMBERT: u32 = u32::from_be_bytes(*b"lmil");
const PPC_Q3_ILLUMINATION_TYPE_NULL: u32 = u32::from_be_bytes(*b"nuil");
const PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT_3DMF: u32 = u32::from_be_bytes(*b"camb");
const PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR_3DMF: u32 = u32::from_be_bytes(*b"kdif");
const PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR_3DMF: u32 = u32::from_be_bytes(*b"kspc");
const PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL_3DMF: u32 = u32::from_be_bytes(*b"cspc");
const PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR_3DMF: u32 = u32::from_be_bytes(*b"kxpr");
const PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE: u32 = u32::from_be_bytes(*b"txsu");
const PPC_Q3_TEXTURE_TYPE_MIPMAP: u32 = u32::from_be_bytes(*b"txmm");
const PPC_Q3_PIXEL_TYPE_RGB32: u32 = 0;
const PPC_Q3_PIXEL_TYPE_ARGB32: u32 = 1;
const PPC_Q3_PIXEL_TYPE_RGB16: u32 = 2;
const PPC_Q3_PIXEL_TYPE_ARGB16: u32 = 3;
const PPC_Q3_PIXEL_TYPE_RGB16_565: u32 = 4;
const PPC_Q3_PIXEL_TYPE_RGB24: u32 = 5;
const PPC_Q3_ENDIAN_BIG: u32 = 0;
const PPC_Q3_ENDIAN_LITTLE: u32 = 1;
const PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER: u32 = 1;
const PPC_Q3_VIEW_STATUS_DONE: u32 = 0;
const PPC_Q3_VIEW_STATUS_ERROR: u32 = 2;
const PPC_Q3_STORAGE_TYPE_MEMORY: u32 = u32::from_be_bytes(*b"mems");
const PPC_Q3_STORAGE_TYPE_MACINTOSH: u32 = u32::from_be_bytes(*b"macn");
const PPC_Q3_MEMORY_STORAGE_TYPE_HANDLE: u32 = u32::from_be_bytes(*b"hndl");
const PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT: u32 = u32::from_be_bytes(*b"vana");
const PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC: u32 = u32::from_be_bytes(*b"orth");
const PPC_Q3_CAMERA_TYPE_VIEW_PLANE: u32 = u32::from_be_bytes(*b"vwpl");
const PPC_Q3_LIGHT_TYPE_AMBIENT: u32 = u32::from_be_bytes(*b"ambn");
const PPC_Q3_LIGHT_TYPE_DIRECTIONAL: u32 = u32::from_be_bytes(*b"drct");
const PPC_Q3_LIGHT_TYPE_POINT: u32 = u32::from_be_bytes(*b"pntl");
const PPC_Q3_LIGHT_TYPE_SPOT: u32 = u32::from_be_bytes(*b"spot");
const PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP: u32 = u32::from_be_bytes(*b"dpxp");
const PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH: u32 = u32::from_be_bytes(*b"dmac");
const PPC_Q3_TRANSFORM_TYPE_MATRIX: u32 = u32::from_be_bytes(*b"mtrx");
const PPC_Q3_STYLE_TYPE_BACKFACING: u32 = u32::from_be_bytes(*b"bckf");
const PPC_Q3_STYLE_TYPE_INTERPOLATION: u32 = u32::from_be_bytes(*b"intp");
const PPC_Q3_STYLE_TYPE_FILL: u32 = u32::from_be_bytes(*b"fist");
const PPC_Q3_STYLE_TYPE_ORIENTATION: u32 = u32::from_be_bytes(*b"fdir");
const PPC_Q3_TRIMESH_DATA_SIZE: u32 = 80;
const PPC_Q3_TRIMESH_ATTRIBUTE_SET_OFFSET: u32 = 0;
const PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET: u32 = 4;
const PPC_Q3_TRIMESH_TRIANGLES_OFFSET: u32 = 8;
const PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET: u32 = 12;
const PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET: u32 = 16;
const PPC_Q3_TRIMESH_NUM_EDGES_OFFSET: u32 = 20;
const PPC_Q3_TRIMESH_EDGES_OFFSET: u32 = 24;
const PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET: u32 = 28;
const PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET: u32 = 32;
const PPC_Q3_TRIMESH_NUM_POINTS_OFFSET: u32 = 36;
const PPC_Q3_TRIMESH_POINTS_OFFSET: u32 = 40;
const PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET: u32 = 44;
const PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET: u32 = 48;
const PPC_Q3_TRIMESH_TRIANGLE_DATA_SIZE: u32 = 12;
const PPC_Q3_TRIMESH_EDGE_DATA_SIZE: u32 = 8;
const PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE: u32 = 12;
const PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_TRIANGLE: u32 = 0;
const PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_EDGE: u32 = 1;
const PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_VERTEX: u32 = 2;
const PPC_Q3_POINT3D_SIZE: u32 = 12;
const PPC_Q3_VECTOR2D_SIZE: u32 = 8;
const PPC_Q3_VECTOR3D_SIZE: u32 = 12;
const PPC_Q3_BOUNDING_BOX_SIZE: u32 = PPC_Q3_POINT3D_SIZE * 2 + 4;
const PPC_Q3_BOUNDING_BOX_MAX_OFFSET: u32 = PPC_Q3_POINT3D_SIZE;
const PPC_Q3_BOUNDING_BOX_IS_EMPTY_OFFSET: u32 = PPC_Q3_POINT3D_SIZE * 2;
const PPC_Q3_SOFTWARE_RENDER_MAX_POINTS: u32 = 65_536;
const PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES: u32 = 131_072;
const PPC_Q3_SOFTWARE_RENDER_MAX_EDGES: u32 = 196_608;
const PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES: u32 = 64;
const PPC_Q3_SOFTWARE_DEPTH_NEAR: f32 = -1.0;
const PPC_Q3_SOFTWARE_DEPTH_FAR: f32 = 1.0;
const PPC_Q3_SOFTWARE_CLIP_EPSILON: f32 = 1.0e-5;
const PPC_Q3_MIPMAP_IMAGE_OFFSET: u32 = 0;
const PPC_Q3_MIPMAP_USE_MIPMAPPING_OFFSET: u32 = 4;
const PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET: u32 = 8;
const PPC_Q3_MIPMAP_BIT_ORDER_OFFSET: u32 = 12;
const PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET: u32 = 16;
const PPC_Q3_MIPMAP_RESERVED_OFFSET: u32 = 20;
const PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET: u32 = 24;
const PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET: u32 = 28;
const PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET: u32 = 32;
const PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET: u32 = 36;
const PPC_Q3_DRAW_CONTEXT_DATA_SIZE: u32 = 68;
const PPC_Q3_DRAW_CONTEXT_CLEAR_METHOD_OFFSET: u32 = 0;
const PPC_Q3_DRAW_CONTEXT_CLEAR_COLOR_RED_OFFSET: u32 = 8;
const PPC_Q3_DRAW_CONTEXT_CLEAR_COLOR_GREEN_OFFSET: u32 = 12;
const PPC_Q3_DRAW_CONTEXT_CLEAR_COLOR_BLUE_OFFSET: u32 = 16;
const PPC_Q3_CLEAR_METHOD_WITH_COLOR: u32 = 1;
const PPC_Q3_DRAW_CONTEXT_PANE_OFFSET: u32 = 20;
const PPC_Q3_DRAW_CONTEXT_PANE_SIZE: u32 = 16;
const PPC_Q3_DRAW_CONTEXT_PANE_STATE_OFFSET: u32 = 36;
const PPC_Q3_PIXMAP_DRAW_CONTEXT_DATA_SIZE: u32 = 100;
const PPC_Q3_PIXMAP_DRAW_CONTEXT_WIDTH_OFFSET: u32 = PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 4;
const PPC_Q3_PIXMAP_DRAW_CONTEXT_HEIGHT_OFFSET: u32 = PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 8;
const PPC_Q3_MAC_DRAW_CONTEXT_DATA_SIZE: u32 = 84;
const PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET: u32 = PPC_Q3_DRAW_CONTEXT_DATA_SIZE;
const PPC_Q3_CAMERA_DATA_SIZE: u32 = 60;
const PPC_Q3_CAMERA_PLACEMENT_SIZE: u32 = 36;
const PPC_Q3_CAMERA_RANGE_SIZE: u32 = 8;
const PPC_Q3_CAMERA_VIEWPORT_SIZE: u32 = 16;
const PPC_Q3_CAMERA_PLACEMENT_OFFSET: u32 = 0;
const PPC_Q3_CAMERA_RANGE_OFFSET: u32 = 36;
const PPC_Q3_CAMERA_VIEWPORT_OFFSET: u32 = 44;
const PPC_Q3_CAMERA_VIEWPORT_WIDTH_OFFSET: u32 = 8;
const PPC_Q3_CAMERA_VIEWPORT_HEIGHT_OFFSET: u32 = 12;
const PPC_Q3_VIEW_ANGLE_ASPECT_CAMERA_DATA_SIZE: u32 = 68;
const PPC_Q3_ORTHOGRAPHIC_CAMERA_DATA_SIZE: u32 = 76;
const PPC_Q3_VIEW_PLANE_CAMERA_DATA_SIZE: u32 = 80;
const PPC_Q3_LIGHT_DATA_SIZE: u32 = 20;
const PPC_Q3_DIRECTIONAL_LIGHT_DATA_SIZE: u32 = 36;
const PPC_Q3_POINT_LIGHT_DATA_SIZE: u32 = 40;
const PPC_Q3_SPOT_LIGHT_DATA_SIZE: u32 = 64;
const PPC_Q3_ATTENUATION_TYPE_NONE: u32 = 0;
const PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE: u32 = 1;
const PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE_SQUARED: u32 = 2;
const PPC_Q3_FALL_OFF_TYPE_NONE: u32 = 0;
const PPC_Q3_FALL_OFF_TYPE_LINEAR: u32 = 1;
const PPC_Q3_FALL_OFF_TYPE_EXPONENTIAL: u32 = 2;
const PPC_Q3_FALL_OFF_TYPE_COSINE: u32 = 3;
const PPC_Q3_FOG_STYLE_DATA_SIZE: u32 = 36;
const PPC_Q3_MEMORY_STORAGE_DEFAULT_BUFFER_SIZE: u32 = 4096;
const PPC_Q3_FOG_MODE_LINEAR: u32 = 0;
const PPC_Q3_FOG_MODE_EXPONENTIAL: u32 = 1;
const PPC_Q3_FOG_MODE_EXPONENTIAL_SQUARED: u32 = 2;
const PPC_Q3_FOG_MODE_ALPHA: u32 = 3;
const PPC_Q3_BACKFACING_STYLE_BOTH: u32 = 0;
const PPC_Q3_BACKFACING_STYLE_REMOVE: u32 = 1;
const PPC_Q3_BACKFACING_STYLE_FLIP: u32 = 2;
const PPC_Q3_ORIENTATION_STYLE_COUNTER_CLOCKWISE: u32 = 0;
const PPC_Q3_ORIENTATION_STYLE_CLOCKWISE: u32 = 1;
const PPC_Q3_INTERPOLATION_STYLE_NONE: u32 = 0;
const PPC_Q3_INTERPOLATION_STYLE_VERTEX: u32 = 1;
const PPC_Q3_INTERPOLATION_STYLE_PIXEL: u32 = 2;
const PPC_Q3_FILL_STYLE_FILLED: u32 = 0;
const PPC_Q3_FILL_STYLE_EDGES: u32 = 1;
const PPC_Q3_FILL_STYLE_POINTS: u32 = 2;
const PPC_Q3_ATTRIBUTE_TYPE_NONE: u32 = 0;
const PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV: u32 = 1;
const PPC_Q3_ATTRIBUTE_TYPE_SHADING_UV: u32 = 2;
const PPC_Q3_ATTRIBUTE_TYPE_NORMAL: u32 = 3;
const PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT: u32 = 4;
const PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR: u32 = 5;
const PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR: u32 = 6;
const PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL: u32 = 7;
const PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR: u32 = 8;
const PPC_Q3_ATTRIBUTE_TYPE_SURFACE_TANGENT: u32 = 9;
const PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE: u32 = 10;
const PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER: u32 = 11;
const PPC_Q3_SHADER_UV_BOUNDARY_CLAMP: u32 = 1;
const PPC_Q3_MATRIX3X3_SIZE: u32 = 36;
const PPC_Q3_MATRIX4X4_SIZE: u32 = 64;
const PPC_DSP_CONTEXT: u32 = 0x0500_0000;
const PPC_DSP_CONTEXT_ATTRIBUTES_SIZE: u32 = 72;
const PPC_DSP_DEPTH_MASK_8: u32 = 1 << 3;
const PPC_DSP_DISPLAY_ID: u32 = 1;
const PPC_DSP_BUFFER_KIND_NORMAL: u32 = 0;
const PPC_DSP_MAX_REQUESTED_PAGE_COUNT: u32 = 2;
const PPC_QA_ENGINE: u32 = 0x0500_0100;
const PPC_QA_DRAW_CONTEXT: u32 = 0x0500_0110;
const PPC_QA_DRAW_CONTEXT_PRIVATE: u32 = 0x0500_0190;
const PPC_QA_DRAW_CONTEXT_METHOD_SLOT_COUNT: u32 = 31;
const PPC_QA_METHOD_RETURN_ZERO_TVECTOR: u32 = 0x0500_0200;
const PPC_QA_METHOD_RETURN_ZERO_ENTRY: u32 = 0x0500_0210;
const PPC_QA_OBJECTS_SIZE: usize = 16 * 1024;
const PPC_QA_OPTIONAL_TEXTURE: u32 = 1 << 1;
const PPC_QA_OPTIONAL_TEXTURE_COLOR: u32 = 1 << 3;
const PPC_QA_OPTIONAL_PERSPECTIVE_Z: u32 = 1 << 8;
const PPC_QA_FAST_LINE: u32 = 1 << 0;
const PPC_QA_FAST_GOURAUD: u32 = 1 << 1;
const PPC_QA_FAST_TEXTURE: u32 = 1 << 2;
const PPC_QA_VENDOR_APPLE: u32 = 0;
const PPC_QA_ENGINE_APPLE_SW: u32 = 0;
const PPC_QA_AVAILABLE_TEXTURE_MEMORY: u32 = 8 * 1024 * 1024;
const PPC_QA_ENGINE_NAME: &[u8] = b"Apple Software Renderer";
const PPC_ISP_DEVICE_COUNT: u32 = 2;
const PPC_ISP_KEYBOARD_DEVICE: u32 = 0x0500_2000;
const PPC_ISP_MOUSE_DEVICE: u32 = 0x0500_2010;
const PPC_ISP_KEYBOARD_ELEMENT: u32 = 0x0500_2020;
const PPC_ISP_MOUSE_X_ELEMENT: u32 = 0x0500_2030;
const PPC_ISP_MOUSE_Y_ELEMENT: u32 = 0x0500_2040;
const PPC_ISP_MOUSE_BUTTON_ELEMENT: u32 = 0x0500_2050;
const PPC_ISP_DEVICE_DEFINITION_SIZE: u32 = 92;
const PPC_ISP_ELEMENT_INFO_SIZE: u32 = 80;
const PPC_ISP_DEVICE_CLASS_KEYBOARD: u32 = u32::from_be_bytes(*b"keyd");
const PPC_ISP_DEVICE_CLASS_MOUSE: u32 = u32::from_be_bytes(*b"mous");
const PPC_ISP_ELEMENT_LABEL_NONE: u32 = u32::from_be_bytes(*b"none");
const PPC_ISP_ELEMENT_LABEL_CURSOR_X: u32 = u32::from_be_bytes(*b"curx");
const PPC_ISP_ELEMENT_LABEL_CURSOR_Y: u32 = u32::from_be_bytes(*b"cury");
const PPC_ISP_ELEMENT_LABEL_MOUSE_ONE: u32 = u32::from_be_bytes(*b"mou1");
const PPC_ISP_NEED_SIZE: u32 = 92;
const PPC_ISP_NEED_KIND_OFFSET: u32 = 68;
const PPC_ISP_VIRTUAL_ELEMENT_RECORD_SIZE: u32 = 16 + PPC_ISP_NEED_SIZE;
const PPC_ISP_ELEMENT_NEED_INDEX_OFFSET: u32 = 8;
const PPC_ISP_ELEMENT_NEED_SOURCE_OFFSET: u32 = 12;
const PPC_ISP_ELEMENT_NEED_RECORD_OFFSET: u32 = 16;
const PPC_ISP_ELEMENT_LIST_HEADER_SIZE: u32 = 8;
const PPC_ISP_ELEMENT_LIST_ENTRY_SIZE: u32 = 12;
const PPC_ISP_ELEMENT_LIST_CAPACITY: u32 = 64;
const PPC_ISP_ELEMENT_LIST_RECORD_SIZE: u32 = PPC_ISP_ELEMENT_LIST_HEADER_SIZE
+ PPC_ISP_ELEMENT_LIST_ENTRY_SIZE * PPC_ISP_ELEMENT_LIST_CAPACITY;
const PPC_ISP_ELEMENT_EVENT_SIZE: u32 = 20;
const PPC_ISP_ELEMENT_KIND_BUTTON: u32 = 0x6275_746e;
const PPC_ISP_ELEMENT_KIND_DPAD: u32 = 0x6470_6164;
const PPC_ISP_ELEMENT_KIND_AXIS: u32 = 0x6178_6973;
const PPC_ISP_ELEMENT_KIND_DELTA: u32 = 0x6465_6c74;
const PPC_ISP_AXIS_MIDDLE: u32 = 0x7fff_ffff;
const PPC_ISP_AXIS_LOW: u32 = 0;
const PPC_ISP_AXIS_HIGH: u32 = 0xffff_ffff;
const PPC_ISP_BUTTON_PRESSED: u32 = 1;
const PPC_ISP_DPAD_UP: u32 = 1 << 0;
const PPC_ISP_DPAD_RIGHT: u32 = 1 << 1;
const PPC_ISP_DPAD_DOWN: u32 = 1 << 2;
const PPC_ISP_DPAD_LEFT: u32 = 1 << 3;
const PPC_KEY_RETURN: u8 = 0x24;
const PPC_KEY_A: u8 = 0x00;
const PPC_KEY_B: u8 = 0x0b;
const PPC_KEY_G: u8 = 0x05;
const PPC_KEY_M: u8 = 0x2e;
const PPC_KEY_Q: u8 = 0x0c;
const PPC_KEY_Z: u8 = 0x06;
const PPC_KEY_1: u8 = 0x12;
const PPC_KEY_2: u8 = 0x13;
const PPC_KEY_EQUAL: u8 = 0x18;
const PPC_KEY_MINUS: u8 = 0x1b;
const PPC_KEY_COMMA: u8 = 0x2b;
const PPC_KEY_PERIOD: u8 = 0x2f;
const PPC_KEY_TAB: u8 = 0x30;
const PPC_KEY_SPACE: u8 = 0x31;
const PPC_KEY_ESCAPE: u8 = 0x35;
const PPC_KEY_COMMAND: u8 = 0x37;
const PPC_KEY_SHIFT: u8 = 0x38;
const PPC_KEY_OPTION: u8 = 0x3a;
const PPC_KEY_CONTROL: u8 = 0x3b;
const PPC_KEY_CONTROL_RIGHT: u8 = 0x3e;
const PPC_KEY_LEFT: u8 = 0x7b;
const PPC_KEY_RIGHT: u8 = 0x7c;
const PPC_KEY_DOWN: u8 = 0x7d;
const PPC_KEY_UP: u8 = 0x7e;
const PPC_KEY_NUMPAD_ADD: u8 = 0x45;
const PPC_KEY_NUMPAD_ENTER: u8 = 0x4c;
const PPC_KEY_NUMPAD_SUBTRACT: u8 = 0x4e;
const PPC_KEY_NUMPAD_LEFT: u8 = 0x56;
const PPC_KEY_NUMPAD_DOWN: u8 = 0x57;
const PPC_KEY_NUMPAD_RIGHT: u8 = 0x58;
const PPC_KEY_NUMPAD_UP: u8 = 0x5b;
const PPC_CONTROL_RECORD_SIZE: u32 = 296;
const PPC_CONTROL_NEXT_OFFSET: u32 = 0;
const PPC_CONTROL_OWNER_OFFSET: u32 = 4;
const PPC_CONTROL_RECT_OFFSET: u32 = 8;
const PPC_CONTROL_VISIBLE_OFFSET: u32 = 16;
const PPC_CONTROL_HILITE_OFFSET: u32 = 17;
const PPC_CONTROL_VALUE_OFFSET: u32 = 18;
const PPC_CONTROL_MIN_OFFSET: u32 = 20;
const PPC_CONTROL_MAX_OFFSET: u32 = 22;
const PPC_CONTROL_REF_CON_OFFSET: u32 = 36;
const PPC_CONTROL_TITLE_OFFSET: u32 = 40;
const PPC_KEY_MAP_SIZE: u32 = 16;
const PPC_GETKEYS_IDLE_POLL_FAST_FORWARD_THRESHOLD: u32 = 4;
const PPC_GETKEYS_IDLE_POLL_EXTRA_CYCLES: u64 = 7_296;
const PPC_MICROSECONDS_IDLE_POLL_FAST_FORWARD_THRESHOLD: u32 =
PPC_GETKEYS_IDLE_POLL_FAST_FORWARD_THRESHOLD;
const PPC_MICROSECONDS_IDLE_POLL_EXTRA_CYCLES: u64 = PPC_GETKEYS_IDLE_POLL_EXTRA_CYCLES;
const PPC_BUTTON_IDLE_POLL_FAST_FORWARD_THRESHOLD: u32 =
PPC_GETKEYS_IDLE_POLL_FAST_FORWARD_THRESHOLD;
const PPC_BUTTON_IDLE_POLL_EXTRA_CYCLES: u64 = PPC_GETKEYS_IDLE_POLL_EXTRA_CYCLES;
const PPC_TICK_COUNT_IDLE_POLL_FAST_FORWARD_THRESHOLD: u32 =
PPC_GETKEYS_IDLE_POLL_FAST_FORWARD_THRESHOLD;
const PPC_Q3_IDLE_STATE_ONLY_FRAME_EXTRA_CYCLES: u64 = 416_000;
// QD3D scenes can submit hundreds of calls per frame. About 1.5K cycles per
// hot HLE call leaves most of a 25 MHz guest VBL for interpreted application
// code while still accounting for work performed by a native QD3D driver.
const PPC_Q3_HOT_IMPORT_EXTRA_CYCLES: u64 = 1_536;
const PPC_MATH_HOT_IMPORT_EXTRA_CYCLES: u64 = 128;
const PPC_Q3_RETAINED_BOUNDING_TRIMESH_PREVIEW_LIMIT: usize = 16;
const PPC_FIXED_MAC_TIME: u32 = 3_786_912_000;
const PPC_MICROSECONDS_PER_TICK: u64 = 16_625;
const PPC_QT_GRAPHICS_IMPORTER: u32 = 0x0500_3000;
const PPC_QT_MOVIE: u32 = 0x0500_3010;
const PPC_QT_MOVIE_TASKS_PER_SECOND: u64 = 60;
fn ppc_interrupt_callback_stack_pointer(interrupted_sp: u32) -> u32 {
// Inside Macintosh: PowerPC System Software (1994), pp. 1-46–1-47:
// an interrupt handler must skip the 224-byte Red Zone before using the
// stack because an optimized leaf routine may keep live nonvolatile
// registers there without allocating a frame.
interrupted_sp
.saturating_sub(PPC_INTERRUPT_RED_ZONE_SIZE)
.saturating_sub(PPC_INITIAL_STACK_FRAME_SIZE)
& !0xFu32
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PpcLoadConfig {
pub stack_size: u32,
pub screen_depth: u32,
}
impl PpcLoadConfig {
pub fn from_cfrg_app_stack_size(app_stack_size: u32) -> Self {
if app_stack_size == 0 {
Self::default()
} else {
Self {
stack_size: app_stack_size,
..Self::default()
}
}
}
}
impl Default for PpcLoadConfig {
fn default() -> Self {
Self {
stack_size: PPC_DEFAULT_STACK_SIZE,
screen_depth: PPC_MAIN_PIXEL_DEPTH,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcMath64Operation {
LongDoubleToSInt64,
LongDoubleToUInt64,
S32Set,
S64Absolute,
S64Add,
S64And,
S64BitwiseAnd,
S64BitwiseEor,
S64BitwiseNot,
S64BitwiseOr,
S64Compare,
S64Divide,
S64Eor,
S64Max,
S64Min,
S64Multiply,
S64Negate,
S64Not,
S64Or,
S64Set,
S64SetU,
S64ShiftLeft,
S64ShiftRight,
S64Subtract,
SInt64ToLongDouble,
SInt64ToUInt64,
U32SetU,
U64Add,
U64And,
U64BitwiseAnd,
U64BitwiseEor,
U64BitwiseNot,
U64BitwiseOr,
U64Compare,
U64Divide,
U64Eor,
U64Max,
U64Multiply,
U64Not,
U64Or,
U64Set,
U64SetU,
U64ShiftLeft,
U64ShiftRight,
U64Subtract,
UInt64ToLongDouble,
UInt64ToSInt64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcMathCompatibilityOperation {
Dec2Num,
Dec2Str,
FeClearExcept,
FeTestExcept,
Floor,
Modf,
Num2Dec,
Str2Dec,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcStdCCompatibilityOperation {
Qsort,
Signal,
Sscanf,
Strftime,
Vsprintf,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcSoundInputCompatibilityOperation {
CloseDevice,
GetDeviceInfo,
OpenDevice,
Record,
SetDeviceInfo,
StopRecording,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcSpeechCompatibilityOperation {
CountVoices,
DisposeSpeechChannel,
GetIndVoice,
GetVoiceDescription,
NewSpeechChannel,
SpeakString,
SpeakText,
SpeechBusy,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcPrintingCompatibilityOperation {
PrClose,
PrCloseDoc,
PrClosePage,
PrError,
PrJobDialog,
PrOpen,
PrOpenDoc,
PrOpenPage,
PrPicFile,
PrStlDialog,
PrintDefault,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcStandardFileOperation {
StandardGetFile,
CustomGetFile,
CustomPutFile,
SfGetFile,
SfpGetFile,
SfpPutFile,
SfPutFile,
StandardPutFile,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcDialogCompatibilityOperation {
AppendDitl,
CountDitl,
DialogSelect,
FindDialogItem,
HideDialogItem,
IsDialogEvent,
ShortenDitl,
ShowDialogItem,
UpdateDialog,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcQuickDrawCompatibilityOperation {
AnimateEntry,
AnimatePalette,
BackPat,
BackPixPat,
ClosePicture,
CopyDeepMask,
CopyMask,
CopyPalette,
Ctab2Palette,
DisposeGDevice,
DisposePalette,
Exp1To3,
Exp1To6,
GetCPixel,
GetEntryUsage,
GetItemIcon,
GetItemStyle,
GetNewPalette,
NewGDevice,
NewPalette,
OpenPicture,
Palette2Ctab,
PenPat,
PlotIcon,
ScrollRect,
SetCPixel,
SetEntryColor,
SetEntryUsage,
SetItemIcon,
SetItemStyle,
SetStdCProcs,
SetStdProcs,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcSystemCompatibilityOperation {
BuildDdPwds,
CtbGetCtbVersion,
CallComponentUpp,
DiBadMount,
DiLoad,
DiUnload,
Debugger,
Dequeue,
Enqueue,
FindNextComponent,
GetNextProcess,
GetScript,
GetScriptManagerVariable,
GetScriptVariable,
GetSysBeepVolume,
IuCompString,
IuDateString,
InitCrm,
InitCtbUtilities,
KeyTranslate,
LaunchApplication,
LmGetCurApName,
LmGetSfSaveDisk,
LmGetSysFontFam,
LmGetSysFontSize,
MidiAddPort,
MidiRemovePort,
MidiSignOut,
MidiWritePacket,
Munger,
NmRemove,
ObscureCursor,
OpenDefaultComponent,
ResetAlertStage,
SetFrontProcess,
StyledLineBreak,
SystemEdit,
TruncText,
UpperString,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcFileCompatibilityOperation {
Create,
FsOpen,
OpenDf,
OpenRf,
PbCatSearchSync,
PbCloseWdSync,
PbDirCreateSync,
PbGetFPosSync,
PbGetWdInfoSync,
PbHGetVolParmsSync,
PbHGetVolSync,
PbHOpenRfSync,
PbHSetVolSync,
PbOpenWdSync,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcParameterBlockCreateOperation {
Legacy,
Hierarchical,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcDeleteByNameOperation {
LegacyHighLevel,
HierarchicalHighLevel,
LegacyParameterBlock,
HierarchicalParameterBlock,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcLegacyMemoryUtilityOperation {
BitClear,
BitNot,
BitSet,
FixToExtended,
GetMyZone,
HandleZone,
LockMemory,
MaxBlock,
PurgeSpace,
ReserveMem,
SetGrowZone,
StackSpace,
TempFreeMem,
UnlockMemory,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcLegacyWindowOperation {
BringToFront,
CalculateVisibleRegion,
DisposeWindow,
DragWindow,
GetNewWindow,
GetWindowTitle,
GrowWindow,
HighlightWindow,
NewWindow,
SendBehind,
SetWindowTitle,
TrackBox,
TrackGoAway,
ZoomWindow,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcLegacyControlOperation {
DisposeControl,
DrawOneControl,
FindControl,
GetControlMaximum,
GetControlMinimum,
GetControlTitle,
GetControlValue,
GetNewControl,
HideControl,
KillControls,
MoveControl,
NewControl,
SetControlMaximum,
SetControlMinimum,
ShowControl,
SizeControl,
TestControl,
TrackControl,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcStdIoOperation {
ClearErr,
FileBuffer,
FileClose,
FileEof,
FileError,
FileFlush,
FileOpen,
FilePrintf,
FileRead,
FileSeek,
FileTell,
FileWrite,
IoBuffer,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcInputSprocketCompatibilityOperation {
DevicesActivateClass,
ElementDisposeVirtual,
ElementFlush,
ElementGetNextEvent,
Tickle,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcAppleEventCompatibilityOperation {
CountItems,
CreateAppleEvent,
CreateDesc,
DisposeDesc,
GetAttributePtr,
GetNthPtr,
GetParamDesc,
PutParamDesc,
PutParamPtr,
Send,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcEventPollOperation {
GetNextEvent,
WaitNextEvent,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcAppleTalkCompatibilityOperation {
GetBridgeAddress,
GetNodeAddress,
GetZoneList,
MppOpen,
NbpExtract,
NbpSetEntity,
NbpSetNte,
PCloseSkt,
PKillNbp,
PLookupName,
POpenSkt,
PRegisterName,
PRemoveName,
PSetSelfSend,
PWriteDdp,
StandardNbp,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PpcImportDispatcherTarget {
InstallExceptionHandler,
NewPtr { clear: bool },
DisposePtr,
GetPtrSize,
SetPtrSize,
RecoverHandle,
BlockMove,
PtrToHand,
HandToHand,
HandAndHand,
NewHandle { clear: bool },
TempNewHandle,
DisposeHandle,
EmptyHandle,
GetHandleSize,
SetHandleSize,
HLock,
HLockHi,
HGetState,
HSetState,
HUnlock,
MoveHHi,
HNoPurge,
HPurge,
TickCount,
GetZone,
SetZone,
InitZone,
SystemZone,
ApplicationZone,
MaxApplZone,
MoreMasters,
GetApplLimit,
SetApplLimit,
HeapFreeBytes,
MaxMem,
PurgeMem,
PurgeMemSys,
MemError,
CurResFile,
UseResFile,
CloseResFile,
OpenResFile,
HOpenResFile,
ResError,
SetResLoad,
LoadResource,
GetIndString,
GetString,
GetResource,
Get1Resource,
GetNamedResource,
Get1NamedResource,
GetIndResource,
Get1IndResource,
GetResAttrs,
SetResAttrs,
GetResInfo,
GetResourceSizeOnDisk,
SetResInfo,
HomeResFile,
CountResources,
Count1Resources,
UniqueID,
Unique1ID,
UpdateResFile,
AddResource,
ChangedResource,
WriteResource,
RemoveResource,
ReleaseResource,
DetachResource,
ReadPartialResource,
GetPicture,
GetIcon,
GetIconSuite,
GetPattern,
GetIndPattern,
GetPixPat,
GetPictInfo,
DrawPicture,
KillPicture,
Gestalt,
GetSharedLibrary,
FindSymbol,
CountSymbols,
GetIndSymbol,
CloseConnection,
GetMemFragment,
InitCursor,
HideCursor,
ShowCursor,
ShieldCursor,
CrsrDevNextDevice,
CrsrDevMoveTo,
GetCursor,
SetCursor,
GetCCursor,
GetCIcon,
PlotCIcon,
DisposeCIcon,
SetCCursor,
DisposeCCursor,
SysBeep,
GetForeColor,
GetBackColor,
ForeColor,
BackColor,
RGBForeColor,
RGBBackColor,
OpColor,
HiliteColor,
PmForeColor,
PmBackColor,
Color2Index,
Index2Color,
RGB2HSL,
RGB2HSV,
HSV2RGB,
FixRatio,
FixMul,
FixDiv,
Long2Fix,
Fix2Long,
FixRound,
Fix2Frac,
Frac2Fix,
Frac2X,
X2Frac,
FracSin,
FracCos,
FracSqrt,
FracMul,
FracDiv,
FixATan2,
WideAdd,
WideSubtract,
WideNegate,
WideShift,
WideMultiply,
WideDivide,
WideWideDivide,
WideSquareRoot,
WideCompare,
MoveTo,
Move,
LineTo,
Line,
DrawChar,
DrawText,
DrawString,
TextFont,
TextFace,
TextMode,
TextSize,
PaintRect,
EraseRect,
InvertRect,
FrameRect,
FillRect,
FrameOval,
PaintOval,
EraseOval,
PaintArc,
FrameRgn,
PaintRgn,
FillRgn,
InvertRgn,
FillCRect,
FrameRoundRect,
PaintRoundRect,
InvalRect,
ValidRect,
BeginUpdate,
EndUpdate,
ClipRect,
GetClip,
SetClip,
GetPen,
HidePen,
ShowPen,
PenSize,
PenMode,
PenNormal,
PenPixPat,
GetPenState,
SetPenState,
CopyBits,
BitMapToRegion,
NewRgn,
DisposeRgn,
CopyRgn,
OpenRgn,
CloseRgn,
SectRgn,
UnionRgn,
DiffRgn,
XorRgn,
SetEmptyRgn,
SetRectRgn,
RectRgn,
OffsetRgn,
EmptyRgn,
PtInRgn,
RectInRgn,
OpenPoly,
ClosePoly,
KillPoly,
PaintPoly,
FramePoly,
FillPoly,
NewCWindow,
GetNewCWindow,
GetWRefCon,
SetWRefCon,
SizeWindow,
MoveWindow,
ShowWindow,
HideWindow,
ShowHide,
CloseWindow,
SelectWindow,
FrontWindow,
SetWinColor,
PaintOne,
PaintBehind,
CalcVisBehind,
GetMouse,
ActivatePalette,
NSetPalette,
GetPalette,
GetPort,
GetWMgrPort,
SetPort,
GetGDevice,
SetGDevice,
GetDeviceList,
GetNextDevice,
GetMainDevice,
GetMaxDevice,
GetSysFont,
GetAppFont,
GetDefFontSize,
GetFontName,
GetMBarHeight,
SetMBarHeight,
NewMenu,
DisposeMenu,
GetMenu,
GetItemCmd,
SetItemCmd,
GetItemMark,
CountMItems,
GetMenuItemText,
SetMenuItemText,
DeleteMenuItem,
CalcMenuSize,
PopUpMenuSelect,
InsertMenu,
DeleteMenu,
AppendMenu,
InsertMenuItem,
AppendResMenu,
InsertResMenu,
EnableMenuItem,
DisableMenuItem,
SetItemMark,
CheckItem,
GetMenuBar,
GetNewMBar,
LMGetMenuList,
LMGetMenuFlash,
LMGetPaintWhite,
LMGetSysMap,
LMSetPaintWhite,
LMSetResumeProc,
LMSetACount,
LMSetANumber,
LMSetDlgFont,
SetMenuFlash,
ClearMenuBar,
InvalMenuBar,
SetMenuBar,
GetMenuHandle,
DrawMenuBar,
FlashMenuBar,
HMGetHelpMenuHandle,
HiliteMenu,
DrawGrowIcon,
MenuNoop,
MenuKey,
MenuEvent,
MenuChoice,
MenuSelect,
TestDeviceAttribute,
SetDeviceAttribute,
HasDepth,
SetDepth,
NewGWorld,
UpdateGWorld,
DisposeGWorld,
GetCTable,
GetCTSeed,
MakeITable,
QDError,
CTabChanged,
ProtectEntry,
ReserveEntry,
RestoreEntries,
SetEntries,
RestoreDeviceClut,
DisposeCTable,
NewPixMap,
DisposePixMap,
GetGWorld,
SetGWorld,
GetGWorldDevice,
GetGWorldPixMap,
OpenPort,
OpenCPort,
CloseCPort,
SetPortBits { color: bool },
GetPixBaseAddr,
LockPixels,
UnlockPixels,
GetPixelsState,
SetPixelsState,
AllowPurgePixels,
NoPurgePixels,
SetRect,
SectRect,
UnionRect,
EqualRect,
EmptyRect,
SetPt,
EqualPt,
AddPt,
SubPt,
LocalToGlobal,
GlobalToLocal,
PtInRect,
SetOrigin,
OffsetRect,
MapRect,
InsetRect,
FindWindow,
GetGrayRgn,
LMSetGrayRgn,
GetDCtlEntry,
GetADBInfo,
OpenDriver,
Control,
PBControl,
PBStatus,
FindFolder,
NewAlias,
UpdateAlias,
ResolveAlias,
ResolveAliasFile,
DirCreate,
FSpDirCreate,
FSMakeFSSpec,
PBGetFInfo,
PBHGetFInfo,
PBSetFInfo,
PBHSetFInfo,
PBGetCatInfo,
PBSetCatInfo,
PBHGetVInfo,
PBGetFCBInfo,
FSpGetFInfo,
GetFInfo,
HGetFInfo,
FSpSetFInfo,
HSetFInfo,
StandardGetFile,
GetScrap,
PutScrap,
ZeroScrap,
LoadScrap,
SndSoundManagerVersion,
UnsignedFixedMulDiv,
GetSoundOutputInfo,
GetSoundVol,
SetSoundVol,
GetDefaultOutputVolume,
SetDefaultOutputVolume,
GetVol,
GetWDInfo,
HGetVol,
HSetVol,
FlushVol,
PBFlushVol,
SndNewChannel,
SndDisposeChannel,
SndPlay,
SndChannelStatus,
SndGetInfo,
ParseSndHeader,
SndDoCommand,
SndDoImmediate,
SndPlayDoubleBuffer,
SndStartFilePlay,
SndPauseFilePlay,
SndStopFilePlay,
GetSoundHeaderOffset,
FSpCreateResFile,
HCreateResFile,
FSpOpenDF,
PBHOpenDF,
HOpen,
FSOpen,
FSpOpenResFile,
FSClose,
PBClose,
PBFlushFile,
FSRead,
PBRead,
FSWrite,
PBWrite,
GetEOF,
PBGetEOF,
SetEOF,
AllocContig,
PBSetEOF,
GetFPos,
SetFPos,
PBSetFPos,
FSpCreate,
PBCreate(PpcParameterBlockCreateOperation),
FSpDelete,
DeleteByName(PpcDeleteByNameOperation),
HCreate,
Create,
DSpGetFirstContext,
DSpGetNextContext,
DSpFindBestContext,
DSpUserSelectContext,
DSpStartup,
DSpShutdown,
DSpProcessEvent,
DSpCanUserSelectContext,
DSpGetMouse,
DSpFindContextFromPoint,
DSpContextGlobalToLocal,
DSpSetBlankingColor,
DSpAltBufferNew,
DSpAltBufferGetCGrafPtr,
DSpContextReserve,
DSpContextRelease,
DSpContextSetState,
DSpContextFadeGamma,
DSpContextFadeGammaIn,
DSpContextFadeGammaOut,
DSpContextGetFrontBuffer,
DSpContextGetBackBuffer,
DSpContextSwapBuffers,
DSpContextSetClutEntries,
DSpContextGetDisplayID,
DSpContextGetAttributes,
DSpContextSetVblProc,
DSpContextIsBusy,
DSpAltBufferDispose,
DSpContextInvalBackBufferRect,
DSpContextSetUnderlayAltBuffer,
DMGetDisplayIDByGDevice,
DMGetGDeviceByDisplayID,
GetNewDialog,
NewDialog,
NewFeaturesDialog,
GetDialogItem,
SetDialogItem,
GetDialogItemText,
SetDialogItemText,
SetDialogDefaultItem,
SetDialogCancelItem,
DrawDialog,
DrawControls,
ModalDialog,
SetControlTitle,
SetControlValue,
HiliteControl,
InitGraf,
InitFonts,
InitWindows,
InitMenus,
TEInit,
TENew,
TEStyleNew,
TESetStyle,
TEUseStyleScrap,
TEContinuousStyle,
MeasureText,
TEGetText,
TEDispose,
TEActivate { active: bool },
TESetSelect,
TESetText,
TECalText,
TEInsert { styled: bool },
TEDelete,
TEKey,
TEClick,
TEIdle,
TEUpdate,
TETextBox,
TESetAlignment,
TEGetHeight,
TEGetPoint,
TEScroll { pinned: bool },
TEAutoView,
TECopy { cut: bool, dialog: bool },
TEPaste { dialog: bool },
TETransferScrap { from_desktop: bool },
TEScrapHandle,
TEScrapLength { set: bool },
SelectDialogItemText,
InitDialogs,
SystemTask,
SystemClick,
OpenDeskAcc,
AEInstallEventHandler,
AEProcessAppleEvent,
LNew,
LDispose,
LAddRow,
LDelRow,
LGetSelect,
LSetSelect,
LSetCell,
LGetCell,
LClick,
LActivate,
LSetDrawingMode,
LScroll,
LSize,
LUpdate,
LAutoScroll,
LSearch,
FlushEvents,
SetEventMask,
DisposeDialog,
GetNextEvent(PpcEventPollOperation),
GetOSEvent,
EventAvail,
OSEventAvail,
PostEvent,
Button,
StillDown,
WaitMouseUp,
GetKeys,
GetDateTime,
ReadDateTime,
ReadLocation,
GetTime,
Delay,
GetDblTime,
LMGetTime,
LMGetUTableBase,
SecondsToDate,
Microseconds,
SysEnvirons,
TextWidth,
StringWidth,
TruncString,
CharWidth,
RealFont,
GetFontInfo,
FontMetrics,
GetFNum,
GetIntlResource,
AESetInteractionAllowed,
AEGetInteractionAllowed,
LMGetCurDirStore,
LMSetCurDirStore,
LMGetRndSeed,
LMSetRndSeed,
SetCurrentA5,
SetA5,
SVersion,
DMGetFirstScreenDevice,
DMGetNextScreenDevice,
DMGetDisplayMode,
DMCheckDisplayMode,
DMSetDisplayMode,
DMNewDisplayModeList,
DMGetIndexedDisplayModeFromList,
DMDisposeList,
DMBeginConfigureDisplays,
DMEndConfigureDisplays,
SetToolTrapAddress,
SetOSTrapAddress,
NSetTrapAddress,
EqualString,
NumToString,
StringToNum,
Random,
BitAnd,
BitOr,
BitTst,
StdMemset,
StdMemcmp,
StdMemcpy,
StdMemmove,
StdMalloc,
StdFree,
StdCalloc,
StdRealloc,
StdStrcpy,
StdStrcat,
StdStrncpy,
StdStrncat,
StdStrcmp,
StdStrncmp,
StdStrlen,
StdMemchr,
StdStrchr,
StdStrrchr,
StdStrspn,
StdStrcspn,
StdStrpbrk,
StdStrstr,
StdAtoi,
StdGetenv,
StdSprintf,
StdIoCompatibility(PpcStdIoOperation),
StdAbs,
StdToupper,
StdTolower,
StdIsalnum,
StdIsalpha,
StdIsascii,
StdIscntrl,
StdIsdigit,
StdIsgraph,
StdIslower,
StdIsprint,
StdIspunct,
StdIsspace,
StdIsupper,
StdIsxdigit,
StdToascii,
StdSrand,
StdRand,
P2CStr,
C2PStr,
UpperText,
GetCurrentThread,
GetThreadState,
GetThreadCurrentTaskRef,
GetThreadStateGivenTaskRef,
SetThreadReadyGivenTaskRef,
SetThreadState,
SetThreadStateEndCritical,
ThreadBeginCritical,
NewThread,
CreateThreadPool,
GetFreeThreadCount,
GetSpecificFreeThreadCount,
GetDefaultThreadStackSize,
ThreadCurrentStackSpace,
YieldToThread,
YieldToAnyThread,
DisposeThread,
ThreadEndCritical,
GetCurrentProcess,
WakeUpProcess,
SameProcess,
GetProcessInformation,
ParamText,
AlertReturnDefault,
ExitToShell,
MathCeil,
MathSqrt,
MathExp,
MathSin,
MathCos,
MathAsin,
MathTan,
MathAtan,
MathAtan2,
MathPow,
MathFmod,
MathLog,
MathLog10,
MathDtox80,
Math64(PpcMath64Operation),
X2Fix,
Q3MemoryStorageNew,
Q3MemoryStorageNewBuffer,
Q3FSSpecStorageNew,
Q3MemoryStorageSet,
Q3MemoryStorageGetBuffer,
Q3MemoryStorageSetBuffer,
Q3MemoryStorageGetType,
Q3NewObject,
Q3FileNew,
Q3ViewNew,
Q3Initialize,
Q3Exit,
Q3DisplayGroupNew,
Q3ErrorGet,
Q3ObjectDispose,
Q3ObjectDuplicate,
Q3SharedGetReference,
Q3SharedIsReferenced,
Q3SharedGetType,
Q3ShapeGetType,
Q3ShapeGetLeafType,
Q3ObjectIsDrawable,
Q3ObjectIsType,
Q3ObjectGetType,
Q3ObjectGetLeafType,
Q3GeometryGetType,
Q3ShaderGetType,
Q3GroupGetType,
Q3RendererNewFromType,
Q3RendererGetType,
Q3RendererSync,
Q3RendererFlush,
Q3InteractiveRendererSetDoubleBufferBypass,
Q3InteractiveRendererSetPreferences,
Q3InteractiveRendererSetRaveContextHints,
Q3InteractiveRendererGetRaveContextHints,
Q3InteractiveRendererGetRaveDrawContexts,
Q3InteractiveRendererSetRaveTextureFilter,
Q3TextureShaderNew,
Q3TextureShaderGetTexture,
Q3LambertIlluminationNew,
Q3NullIlluminationNew,
Q3PhongIlluminationNew,
Q3MipmapTextureNew,
Q3MipmapTextureGetMipmap,
Q3ViewAngleAspectCameraNew,
Q3OrthographicCameraNew,
Q3ViewPlaneCameraNew,
Q3CameraGetPlacement,
Q3CameraSetPlacement,
Q3CameraGetRange,
Q3CameraSetRange,
Q3CameraGetViewPort,
Q3CameraSetViewPort,
Q3CameraGetWorldToView,
Q3CameraGetViewToFrustum,
Q3LightGetType,
Q3LightGetState,
Q3LightSetState,
Q3LightGetBrightness,
Q3LightSetBrightness,
Q3LightGetColor,
Q3LightSetColor,
Q3LightGetData,
Q3LightSetData,
Q3AmbientLightNew,
Q3AmbientLightGetData,
Q3AmbientLightSetData,
Q3DirectionalLightNew,
Q3DirectionalLightGetCastShadowsState,
Q3DirectionalLightSetCastShadowsState,
Q3DirectionalLightGetDirection,
Q3DirectionalLightSetDirection,
Q3DirectionalLightGetData,
Q3DirectionalLightSetData,
Q3PointLightNew,
Q3PointLightGetCastShadowsState,
Q3PointLightSetCastShadowsState,
Q3PointLightGetAttenuation,
Q3PointLightSetAttenuation,
Q3PointLightGetLocation,
Q3PointLightSetLocation,
Q3PointLightGetData,
Q3PointLightSetData,
Q3SpotLightNew,
Q3SpotLightGetCastShadowsState,
Q3SpotLightSetCastShadowsState,
Q3SpotLightGetAttenuation,
Q3SpotLightSetAttenuation,
Q3SpotLightGetLocation,
Q3SpotLightSetLocation,
Q3SpotLightGetDirection,
Q3SpotLightSetDirection,
Q3SpotLightGetHotAngle,
Q3SpotLightSetHotAngle,
Q3SpotLightGetOuterAngle,
Q3SpotLightSetOuterAngle,
Q3SpotLightGetFallOff,
Q3SpotLightSetFallOff,
Q3SpotLightGetData,
Q3SpotLightSetData,
Q3LightGroupNew,
Q3ShaderGetUVTransform,
Q3ShaderSetUVTransform,
Q3ShaderGetUBoundary,
Q3ShaderSetUBoundary,
Q3ShaderGetVBoundary,
Q3ShaderSetVBoundary,
Q3BackfacingStyleNew,
Q3BackfacingStyleGet,
Q3BackfacingStyleSet,
Q3InterpolationStyleNew,
Q3InterpolationStyleGet,
Q3InterpolationStyleSet,
Q3FillStyleNew,
Q3FillStyleGet,
Q3FillStyleSet,
Q3OrientationStyleNew,
Q3OrientationStyleGet,
Q3OrientationStyleSet,
Q3TriMeshNew,
Q3TriMeshGetData,
Q3TriMeshSetData,
Q3TriMeshEmptyData,
Q3AttributeSetNew,
Q3AttributeSetAdd,
Q3AttributeSetGet,
Q3AttributeSetClear,
Q3AttributeSetContains,
Q3AttributeSetGetNextAttributeType,
Q3StorageGetSize,
Q3StorageGetData,
Q3StorageSetData,
Q3StorageGetType,
Q3PixmapDrawContextNew,
Q3MacDrawContextNew,
Q3DrawContextGetPane,
Q3Vector3DNormalize,
Q3Vector2DNormalize,
Q3Vector3DCross,
Q3Point2DDistance,
Q3Point3DDistance,
Q3Point3DCrossProductTri,
Q3Matrix3x3SetTranslate,
Q3Matrix4x4SetIdentity,
Q3Matrix4x4SetTranslate,
Q3Matrix4x4SetScale,
Q3Matrix4x4SetRotateX,
Q3Matrix4x4SetRotateY,
Q3Matrix4x4SetRotateZ,
Q3Matrix4x4SetRotateXyz,
Q3Matrix4x4Multiply,
Q3Matrix4x4Transpose,
Q3Matrix4x4Invert,
Q3Point3DTransform,
Q3Point3DTo3DTransformArray,
Q3Point3DTo4DTransformArray,
Q3Vector3DTransform,
Q3MatrixTransformNew,
Q3MatrixTransformSet,
Q3TransformGetMatrix,
Q3FileSetStorage,
Q3FileOpenRead,
Q3FileReadObject,
Q3FileIsEndOfFile,
Q3FileClose,
Q3GroupAddObject,
Q3GroupAddObjectBefore,
Q3GroupCountObjects,
Q3GroupGetFirstPosition,
Q3GroupGetNextPosition,
Q3GroupGetFirstPositionOfType,
Q3GroupGetPositionObject,
Q3GroupRemovePosition,
Q3ViewSetRenderer,
Q3ViewGetRenderer,
Q3ViewSetLightGroup,
Q3ViewGetLightGroup,
Q3ViewSetDrawContext,
Q3ViewGetDrawContext,
Q3ViewSetCamera,
Q3ViewGetCamera,
Q3ViewStartRendering,
Q3ViewEndRendering,
Q3ViewStartBoundingBox,
Q3ViewEndBoundingBox,
Q3ViewCancel,
Q3ShaderSubmit,
Q3StyleSubmit,
Q3BackfacingStyleSubmit,
Q3InterpolationStyleSubmit,
Q3FillStyleSubmit,
Q3OrientationStyleSubmit,
Q3FogStyleSubmit,
Q3TriMeshSubmit,
Q3MatrixTransformSubmit,
Q3ResetTransformSubmit,
Q3PushSubmit,
Q3PopSubmit,
Q3ObjectSubmit,
QADeviceGetFirstEngine,
QADeviceGetNextEngine,
QAEngineGestalt,
ISpElementNewVirtualFromNeeds,
ISpElementListNew,
ISpElementListAddElements,
ISpElementListGetNextEvent,
ISpElementListFlush,
ISpDevicesExtract,
ISpDevicesExtractByClass,
ISpDeviceGetDefinition,
ISpDeviceGetElementList,
ISpElementListExtract,
ISpElementGetInfo,
ISpElementGetSimpleState,
ISpGetVersion,
ISpStartup,
ISpShutdown,
ISpInit,
ISpStop,
ISpSuspend,
ISpResume,
ISpDevicesActivate,
ISpDevicesDeactivate,
ISpConfigure,
GlideSstQueryBoards,
QtEnterMovies,
QtExitMovies,
QtGetMoviesError,
QtGetMoviesStickyError,
QtClearMoviesStickyError,
QtGetGraphicsImporterForFile,
QtGraphicsImportGetBoundsRect,
QtGraphicsImportSetGWorld,
QtGraphicsImportDraw,
QtOpenMovieFile,
QtNewMovieFromFile,
QtGetMovieBox,
QtSetMovieBox,
QtSetMovieGWorld,
QtStartMovie,
QtStopMovie,
QtMoviesTask,
QtDisposeMovie,
QtIsMovieDone,
QtGoToBeginningOfMovie,
QtGoToEndOfMovie,
QtGetMovieDuration,
QtLoadMovieIntoRam,
QtCloseMovieFile,
CloseComponent,
NewRoutineDescriptor,
NewFatRoutineDescriptor,
DisposeRoutineDescriptor,
CallUniversalProc,
CallOSTrapUniversalProc,
NGetTrapAddress,
GetToolTrapAddress,
GetOSTrapAddress,
LMGetCurrentA5,
InsTime,
InsXTime,
PrimeTime,
RmvTime,
VInstall,
VRemove,
SlotVInstall,
SlotVRemove,
LegacyMemoryUtility(PpcLegacyMemoryUtilityOperation),
LegacyControl(PpcLegacyControlOperation),
LegacyWindow(PpcLegacyWindowOperation),
AppleEventCompatibility(PpcAppleEventCompatibilityOperation),
DialogCompatibility(PpcDialogCompatibilityOperation),
QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation),
SystemCompatibility(PpcSystemCompatibilityOperation),
FileCompatibility(PpcFileCompatibilityOperation),
AppleTalkCompatibility(PpcAppleTalkCompatibilityOperation),
PrintingCompatibility(PpcPrintingCompatibilityOperation),
SlotCompatibility,
StandardFileCompatibility(PpcStandardFileOperation),
SoundInputCompatibility(PpcSoundInputCompatibilityOperation),
SpeechCompatibility(PpcSpeechCompatibilityOperation),
QuickTimeCompatibility(PpcQuickTimeCompatibilityOperation),
InputSprocketCompatibility(PpcInputSprocketCompatibilityOperation),
MathCompatibility(PpcMathCompatibilityOperation),
StdCCompatibility(PpcStdCCompatibilityOperation),
ObjectSupportCompatibility,
ReturnError(i16),
ReturnNoErr,
ReturnOne,
NoOpPreserve,
UnresolvedWeak,
Unsupported,
}
/// Backward-compatible native-loader name for the shared event record.
pub type PpcQueuedEvent = QueuedEvent;
struct PpcHleFetchObserver<'a> {
histogram: Option<&'a mut PpcFetchHistogram>,
trace_fetches: bool,
trace_pc_range: Option<(u32, u32)>,
}
impl PpcFetchObserver for PpcHleFetchObserver<'_> {
fn on_fetch(&mut self, pc: u32, word: u32) {
if self.trace_fetches
|| self
.trace_pc_range
.map(|(start, end)| pc >= start && pc <= end)
.unwrap_or(false)
{
eprintln!("{}", format_ppc_trace_fetch(pc, word));
}
if let Some(histogram) = self.histogram.as_deref_mut() {
histogram.on_fetch(pc, word);
}
}
fn on_fetch_cpu(&mut self, cpu: &PpcCpu, word: u32) {
let pc = cpu.pc;
let in_range = self
.trace_pc_range
.map(|(start, end)| pc >= start && pc <= end)
.unwrap_or(false);
let r27_matches = ppc_trace_regs_r27_filter()
.map(|expected| cpu.gpr[27] == expected)
.unwrap_or(true);
let r3_matches = ppc_trace_regs_r3_filter()
.map(|expected| cpu.gpr[3] == expected)
.unwrap_or(true);
if ppc_trace_regs_enabled() && in_range && r27_matches && r3_matches {
eprintln!(
"[PPC-TRACE] fetch pc=${:08X} word=${:08X} lr=${:08X} sp=${:08X} rtoc=${:08X} r3=${:08X} r4=${:08X} r5=${:08X} r12=${:08X} r27=${:08X} r28=${:08X} r29=${:08X} r30=${:08X} r31=${:08X}",
pc,
word,
cpu.lr,
cpu.gpr[1],
cpu.gpr[2],
cpu.gpr[3],
cpu.gpr[4],
cpu.gpr[5],
cpu.gpr[12],
cpu.gpr[27],
cpu.gpr[28],
cpu.gpr[29],
cpu.gpr[30],
cpu.gpr[31],
);
if let Some(histogram) = self.histogram.as_deref_mut() {
histogram.on_fetch(pc, word);
}
return;
}
if ppc_trace_regs_enabled() && in_range {
if let Some(histogram) = self.histogram.as_deref_mut() {
histogram.on_fetch(pc, word);
}
return;
}
self.on_fetch(pc, word);
}
}
static PPC_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static PPC_TRACE_PC_RANGE: OnceLock<Option<(u32, u32)>> = OnceLock::new();
static PPC_HLE_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static PPC_GWORLD_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static SPROCKET_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static QD3D_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static QD3D_TRIMESH_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static QD3D_COLLISION_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static QD3D_DUMP_FRAME_ENABLED: OnceLock<bool> = OnceLock::new();
static QT_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static PPC_SOUND_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static PPC_TIMER_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static PPC_PT_IN_RECT_TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static PPC_RECENT_IMPORTS_ON_HALT_ENABLED: OnceLock<bool> = OnceLock::new();
static PPC_TRACE_REGS_ENABLED: OnceLock<bool> = OnceLock::new();
static PPC_TRACE_REGS_R27_FILTER: OnceLock<Option<u32>> = OnceLock::new();
static PPC_TRACE_REGS_R3_FILTER: OnceLock<Option<u32>> = OnceLock::new();
fn ppc_trace_enabled() -> bool {
*PPC_TRACE_ENABLED.get_or_init(|| std::env::var_os("SYSTEMLESS_PPC_TRACE").is_some())
}
fn ppc_trace_pc_range() -> Option<(u32, u32)> {
*PPC_TRACE_PC_RANGE.get_or_init(|| {
let value = std::env::var("SYSTEMLESS_PPC_TRACE_PC_RANGE").ok()?;
let mut parts = value.split(':');
let start = parts.next()?.trim();
let end = parts.next()?.trim();
let parse = |s: &str| u32::from_str_radix(s.trim_start_matches("0x"), 16).ok();
Some((parse(start)?, parse(end)?))
})
}
fn ppc_trace_regs_enabled() -> bool {
*PPC_TRACE_REGS_ENABLED.get_or_init(|| std::env::var_os("SYSTEMLESS_PPC_TRACE_REGS").is_some())
}
fn ppc_trace_regs_r27_filter() -> Option<u32> {
*PPC_TRACE_REGS_R27_FILTER.get_or_init(|| {
let value = std::env::var("SYSTEMLESS_PPC_TRACE_REGS_R27").ok()?;
let trimmed = value.trim();
let hex = trimmed
.strip_prefix("0x")
.or_else(|| trimmed.strip_prefix("0X"))
.or_else(|| trimmed.strip_prefix('$'))
.unwrap_or(trimmed);
u32::from_str_radix(hex, 16).ok()
})
}
fn ppc_trace_regs_r3_filter() -> Option<u32> {
*PPC_TRACE_REGS_R3_FILTER.get_or_init(|| {
let value = std::env::var("SYSTEMLESS_PPC_TRACE_REGS_R3").ok()?;
let trimmed = value.trim();
let hex = trimmed
.strip_prefix("0x")
.or_else(|| trimmed.strip_prefix("0X"))
.or_else(|| trimmed.strip_prefix('$'))
.unwrap_or(trimmed);
u32::from_str_radix(hex, 16).ok()
})
}
pub(super) fn ppc_hle_trace_enabled() -> bool {
*PPC_HLE_TRACE_ENABLED.get_or_init(|| std::env::var_os("SYSTEMLESS_PPC_HLE_TRACE").is_some())
}
pub(super) fn ppc_gworld_trace_enabled() -> bool {
*PPC_GWORLD_TRACE_ENABLED
.get_or_init(|| std::env::var_os("SYSTEMLESS_PPC_GWORLD_TRACE").is_some())
}
fn ppc_recent_imports_on_halt_enabled() -> bool {
*PPC_RECENT_IMPORTS_ON_HALT_ENABLED
.get_or_init(|| std::env::var_os("SYSTEMLESS_PPC_RECENT_IMPORTS_ON_HALT").is_some())
}
fn ppc_res_type_text(res_type: u32) -> String {
let bytes = res_type.to_be_bytes();
if bytes
.iter()
.all(|byte| byte.is_ascii_graphic() || *byte == b' ')
{
String::from_utf8_lossy(&bytes).into_owned()
} else {
format!("${res_type:08X}")
}
}
fn sprocket_trace_enabled() -> bool {
*SPROCKET_TRACE_ENABLED.get_or_init(|| std::env::var_os("SYSTEMLESS_SPROCKET_TRACE").is_some())
}
fn qd3d_trace_enabled() -> bool {
*QD3D_TRACE_ENABLED.get_or_init(|| std::env::var_os("SYSTEMLESS_QD3D_TRACE").is_some())
}
fn qd3d_trimesh_trace_enabled() -> bool {
*QD3D_TRIMESH_TRACE_ENABLED
.get_or_init(|| std::env::var_os("SYSTEMLESS_QD3D_TRIMESH_TRACE").is_some())
}
fn qd3d_collision_trace_enabled() -> bool {
*QD3D_COLLISION_TRACE_ENABLED
.get_or_init(|| std::env::var_os("SYSTEMLESS_QD3D_COLLISION_TRACE").is_some())
}
fn qd3d_dump_frame_enabled() -> bool {
*QD3D_DUMP_FRAME_ENABLED
.get_or_init(|| std::env::var_os("SYSTEMLESS_QD3D_DUMP_FRAME").is_some())
}
fn qt_trace_enabled() -> bool {
*QT_TRACE_ENABLED.get_or_init(|| std::env::var_os("SYSTEMLESS_QT_TRACE").is_some())
}
fn ppc_sound_trace_enabled() -> bool {
*PPC_SOUND_TRACE_ENABLED.get_or_init(|| std::env::var_os("SYSTEMLESS_TRACE_SOUND").is_some())
}
fn ppc_timer_trace_enabled() -> bool {
*PPC_TIMER_TRACE_ENABLED.get_or_init(|| std::env::var_os("SYSTEMLESS_TRACE_TIMER").is_some())
}
fn ppc_pt_in_rect_trace_enabled() -> bool {
*PPC_PT_IN_RECT_TRACE_ENABLED
.get_or_init(|| std::env::var_os("SYSTEMLESS_PPC_TRACE_PT_IN_RECT").is_some())
}
fn format_ppc_fourcc(value: u32) -> String {
value
.to_be_bytes()
.into_iter()
.map(|byte| {
if byte.is_ascii_graphic() || byte == b' ' {
char::from(byte)
} else {
'.'
}
})
.collect()
}
fn format_ppc_trace_fetch(pc: u32, word: u32) -> String {
format!("[PPC-TRACE] fetch pc=${:08X} word=${:08X}", pc, word)
}
fn format_ppc_trace_import(entry: &PpcHleImportTraceEntry) -> String {
format!(
"[PPC-TRACE] import #{} {}:{} pc=${:08X} lr=${:08X} rtoc=${:08X} sp=${:08X} target={:?}",
entry.import_index,
entry.library_name,
entry.symbol_name,
entry.pc,
entry.lr,
entry.rtoc,
entry.sp,
entry.dispatcher_target
)
}
fn format_ppc_trace_unknown_import(index: u32, pc: u32, lr: u32, rtoc: u32, sp: u32) -> String {
format!(
"[PPC-TRACE] import #{} <unknown> pc=${:08X} lr=${:08X} rtoc=${:08X} sp=${:08X}",
index, pc, lr, rtoc, sp
)
}
fn is_sprocket_import(binding: &PpcImportBinding) -> bool {
matches!(
binding.library_name.as_str(),
"DrawSprocketLib" | "InputSprocketLib"
)
}
fn format_hex_opt(value: Option<u32>) -> String {
value
.map(|value| format!("${:08X}", value))
.unwrap_or_else(|| "none".to_string())
}
fn format_rgb_opt(value: Option<PpcRgbColor>) -> String {
value
.map(|color| {
format!(
"${:04X}/${:04X}/${:04X}",
color.red, color.green, color.blue
)
})
.unwrap_or_else(|| "none".to_string())
}
fn dsp_gamma_kind_name(kind: PpcDspGammaFadeKind) -> &'static str {
match kind {
PpcDspGammaFadeKind::Manual => "manual",
PpcDspGammaFadeKind::In => "in",
PpcDspGammaFadeKind::Out => "out",
}
}
fn dsp_context_play_state_name(state: PpcDspContextPlayState) -> &'static str {
match state {
PpcDspContextPlayState::Active => "active",
PpcDspContextPlayState::Paused => "paused",
PpcDspContextPlayState::Inactive => "inactive",
}
}
fn format_dsp_last_fade(state: &PpcDrawSprocketState) -> String {
match (state.last_fade_kind, state.last_fade_percent) {
(Some(kind), Some(percent)) => format!(
"{} context={} percent={} zero={}",
dsp_gamma_kind_name(kind),
format_hex_opt(state.last_fade_context),
percent,
format_rgb_opt(state.last_fade_zero_color)
),
_ => "none".to_string(),
}
}
fn isp_element_kind_name(kind: u32) -> &'static str {
match kind {
PPC_ISP_ELEMENT_KIND_AXIS => "axis",
PPC_ISP_ELEMENT_KIND_BUTTON => "button",
PPC_ISP_ELEMENT_KIND_DPAD => "dpad",
PPC_ISP_ELEMENT_KIND_DELTA => "delta",
_ => "unknown",
}
}
fn isp_action_binding_name(binding: PpcInputSprocketActionBinding) -> &'static str {
match binding {
PpcInputSprocketActionBinding::AxisYaw => "axis/yaw",
PpcInputSprocketActionBinding::AxisPitch => "axis/pitch",
PpcInputSprocketActionBinding::AxisHorizontal => "axis/horizontal",
PpcInputSprocketActionBinding::AxisVertical => "axis/vertical",
PpcInputSprocketActionBinding::AxisDirectional => "axis/directional",
PpcInputSprocketActionBinding::ButtonLeft => "button/left",
PpcInputSprocketActionBinding::ButtonRight => "button/right",
PpcInputSprocketActionBinding::ButtonForward => "button/forward",
PpcInputSprocketActionBinding::ButtonBackward => "button/backward",
PpcInputSprocketActionBinding::ButtonCameraLeft => "button/camera-left",
PpcInputSprocketActionBinding::ButtonCameraRight => "button/camera-right",
PpcInputSprocketActionBinding::ButtonJump => "button/jump",
PpcInputSprocketActionBinding::ButtonFire => "button/fire",
PpcInputSprocketActionBinding::ButtonWeapon => "button/weapon",
PpcInputSprocketActionBinding::ButtonPickup => "button/pickup",
PpcInputSprocketActionBinding::ButtonJetUp => "button/jet-up",
PpcInputSprocketActionBinding::ButtonJetDown => "button/jet-down",
PpcInputSprocketActionBinding::ButtonPause => "button/pause",
PpcInputSprocketActionBinding::ButtonZoomIn => "button/zoom-in",
PpcInputSprocketActionBinding::ButtonZoomOut => "button/zoom-out",
PpcInputSprocketActionBinding::ButtonCameraMode => "button/camera-mode",
PpcInputSprocketActionBinding::ButtonToggleMusic => "button/music-toggle",
PpcInputSprocketActionBinding::ButtonToggleAmbientSound => "button/ambient-toggle",
PpcInputSprocketActionBinding::ButtonVolumeUp => "button/volume-up",
PpcInputSprocketActionBinding::ButtonVolumeDown => "button/volume-down",
PpcInputSprocketActionBinding::ButtonToggleGps => "button/gps-toggle",
PpcInputSprocketActionBinding::ButtonQuit => "button/quit",
PpcInputSprocketActionBinding::ButtonConfirm => "button/confirm",
PpcInputSprocketActionBinding::ButtonPrimary => "button/primary",
PpcInputSprocketActionBinding::DpadDirectional => "dpad/directional",
PpcInputSprocketActionBinding::DeltaYaw => "delta/yaw",
PpcInputSprocketActionBinding::DeltaPitch => "delta/pitch",
PpcInputSprocketActionBinding::Unknown => "unknown",
}
}
fn format_isp_trace_name(name: &str) -> String {
name.chars().flat_map(char::escape_default).collect()
}
fn format_isp_last_virtual_bindings(
input_sprocket: &PpcInputSprocketState,
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
) -> String {
let count = input_sprocket.last_virtual_need_count as usize;
if count == 0 || virtual_elements.is_empty() {
return "[]".to_string();
}
let start = virtual_elements.len().saturating_sub(count);
let entries: Vec<String> = virtual_elements[start..]
.iter()
.map(|record| {
format!(
"#{} {} '{}'={}",
record.need_index,
isp_element_kind_name(record.kind),
format_isp_trace_name(&record.need_name),
isp_action_binding_name(record.action_binding)
)
})
.collect();
format!("[{}]", entries.join(","))
}
fn format_hle_import_action(action: &PpcImportAction) -> String {
format_ppc_import_action(action)
}
fn ppc_import_action_with_extra_cycles(
action: PpcImportAction,
extra_cycles: u64,
) -> PpcImportAction {
if extra_cycles == 0 {
return action;
}
match action {
PpcImportAction::Return(value) => {
PpcImportAction::ReturnWithExtraCycles(value, extra_cycles)
}
PpcImportAction::ReturnPreserve => {
PpcImportAction::ReturnPreserveWithExtraCycles(extra_cycles)
}
PpcImportAction::ReturnPreserveWithExtraCycles(existing) => {
PpcImportAction::ReturnPreserveWithExtraCycles(existing.saturating_add(extra_cycles))
}
PpcImportAction::ReturnWithExtraCycles(value, existing) => {
PpcImportAction::ReturnWithExtraCycles(value, existing.saturating_add(extra_cycles))
}
_ => action,
}
}
fn ppc_import_extra_cycles_for_target(target: &PpcImportDispatcherTarget) -> u64 {
match target {
PpcImportDispatcherTarget::Q3ViewEndRendering => 0,
PpcImportDispatcherTarget::MathCeil
| PpcImportDispatcherTarget::MathSqrt
| PpcImportDispatcherTarget::MathExp
| PpcImportDispatcherTarget::MathSin
| PpcImportDispatcherTarget::MathCos
| PpcImportDispatcherTarget::MathAsin
| PpcImportDispatcherTarget::MathTan
| PpcImportDispatcherTarget::MathAtan
| PpcImportDispatcherTarget::MathAtan2
| PpcImportDispatcherTarget::MathPow
| PpcImportDispatcherTarget::MathFmod
| PpcImportDispatcherTarget::MathLog
| PpcImportDispatcherTarget::MathLog10 => PPC_MATH_HOT_IMPORT_EXTRA_CYCLES,
_ => 0,
}
}
fn ppc_import_extra_cycles_for_binding(binding: &PpcImportBinding) -> u64 {
if is_quickdraw_3d_library(&binding.library_name)
|| is_quickdraw_3d_accelerator_library(&binding.library_name)
{
return PPC_Q3_HOT_IMPORT_EXTRA_CYCLES;
}
ppc_import_extra_cycles_for_target(&binding.dispatcher_target)
}
fn format_sprocket_action(action: &PpcImportAction) -> String {
format_hle_import_action(action)
}
fn format_sprocket_trace(
entry: &PpcHleImportTraceEntry,
args: [u32; 6],
action: &str,
draw_sprocket: &PpcDrawSprocketState,
input_sprocket: &PpcInputSprocketState,
input_sprocket_virtual_elements: &[PpcInputSprocketVirtualElementRecord],
) -> String {
let state = if entry.library_name == "DrawSprocketLib" {
format!(
"dsp started={} reserved={} active={} state={} attrs={}x{} display_depth={} back_depth={} pages={} front={} back={} swaps={} last_swap={} fades={} last_fade={}",
draw_sprocket.started,
format_hex_opt(draw_sprocket.reserved_context),
format_hex_opt(draw_sprocket.active_context),
dsp_context_play_state_name(draw_sprocket.context_state),
draw_sprocket.context_attributes.width,
draw_sprocket.context_attributes.height,
draw_sprocket.context_attributes.display_depth,
draw_sprocket.context_attributes.back_buffer_depth,
draw_sprocket.context_attributes.page_count,
format_hex_opt(Some(draw_sprocket.front_buffer_gworld)),
format_hex_opt(Some(draw_sprocket.back_buffer_gworld)),
draw_sprocket.swap_count,
format_hex_opt(draw_sprocket.last_swap_context),
draw_sprocket.fade_count,
format_dsp_last_fade(draw_sprocket)
)
} else if entry.symbol_name == "ISpElement_NewVirtualFromNeeds" {
format!(
"isp initialized={} suspended={} keyboard={} mouse={} virtuals={} last_need_count={} last_needs={} last_elements={} configure_count={} last_bindings={}",
input_sprocket.initialized,
input_sprocket.suspended,
input_sprocket.keyboard_active,
input_sprocket.mouse_active,
input_sprocket.virtual_element_count,
input_sprocket.last_virtual_need_count,
format_hex_opt(Some(input_sprocket.last_virtual_needs_ptr)),
format_hex_opt(Some(input_sprocket.last_virtual_elements_out_ptr)),
input_sprocket.configure_count,
format_isp_last_virtual_bindings(input_sprocket, input_sprocket_virtual_elements)
)
} else {
format!(
"isp initialized={} suspended={} keyboard={} mouse={} virtuals={} last_need_count={} last_needs={} last_elements={} configure_count={}",
input_sprocket.initialized,
input_sprocket.suspended,
input_sprocket.keyboard_active,
input_sprocket.mouse_active,
input_sprocket.virtual_element_count,
input_sprocket.last_virtual_need_count,
format_hex_opt(Some(input_sprocket.last_virtual_needs_ptr)),
format_hex_opt(Some(input_sprocket.last_virtual_elements_out_ptr)),
input_sprocket.configure_count
)
};
format!(
"[SPROCKET-TRACE] {}:{} pc=${:08X} lr=${:08X} rtoc=${:08X} sp=${:08X} r3=${:08X} r4=${:08X} r5=${:08X} r6=${:08X} r7=${:08X} r8=${:08X} action={} {}",
entry.library_name,
entry.symbol_name,
entry.pc,
entry.lr,
entry.rtoc,
entry.sp,
args[0],
args[1],
args[2],
args[3],
args[4],
args[5],
action,
state
)
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct Qd3dTraceSnapshot {
objects: usize,
views: usize,
submissions: usize,
completed_frames: usize,
memory_storages: usize,
files: usize,
group_memberships: usize,
trimeshes: usize,
draw_contexts: usize,
textures: usize,
shaders: usize,
styles: usize,
cameras: usize,
lights: usize,
latest_object: Option<PpcQ3ObjectRecord>,
latest_submission: Option<PpcQ3SubmissionRecord>,
latest_frame_view: Option<u32>,
latest_frame_submissions: usize,
}
fn qd3d_trace_snapshot(
q3_objects: &[PpcQ3ObjectRecord],
q3_views: &[PpcQ3ViewStateRecord],
q3_submissions: &[PpcQ3SubmissionRecord],
q3_completed_frames: &[PpcQ3CompletedFrameRecord],
q3_state_only_completed_frame_batches: &[PpcQ3StateOnlyCompletedFrameBatch],
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
q3_files: &[PpcQ3FileRecord],
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_trimeshes: &[PpcQ3TriMeshRecord],
q3_draw_contexts: &[PpcQ3DrawContextRecord],
q3_mipmap_textures: &[PpcQ3MipmapTextureRecord],
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
q3_styles: &[PpcQ3StyleRecord],
q3_cameras: &[PpcQ3CameraRecord],
q3_lights: &[PpcQ3LightRecord],
) -> Qd3dTraceSnapshot {
let (latest_frame_view, latest_frame_submissions) = q3_completed_frames
.last()
.map(|frame| (Some(frame.view), frame.submissions.len()))
.unwrap_or((None, 0));
Qd3dTraceSnapshot {
objects: q3_objects.len(),
views: q3_views.len(),
submissions: q3_submissions.len(),
completed_frames: q3_completed_frames.len().saturating_add(
q3_state_only_completed_frame_total(q3_state_only_completed_frame_batches),
),
memory_storages: q3_memory_storages.len(),
files: q3_files.len(),
group_memberships: q3_group_memberships.len(),
trimeshes: q3_trimeshes.len(),
draw_contexts: q3_draw_contexts.len(),
textures: q3_mipmap_textures.len(),
shaders: q3_texture_shaders.len(),
styles: q3_styles.len(),
cameras: q3_cameras.len(),
lights: q3_lights.len(),
latest_object: q3_objects.last().copied(),
latest_submission: q3_submissions.last().copied(),
latest_frame_view,
latest_frame_submissions,
}
}
fn qd3d_trace_count(label: &str, before: usize, after: usize) -> String {
let delta = after as isize - before as isize;
format!("{}={}({:+})", label, after, delta)
}
fn q3_object_kind_name(kind: PpcQ3ObjectKind) -> &'static str {
match kind {
PpcQ3ObjectKind::Generic => "generic",
PpcQ3ObjectKind::MemoryStorage => "memory-storage",
}
}
fn q3_submission_kind_name(kind: PpcQ3SubmissionKind) -> &'static str {
match kind {
PpcQ3SubmissionKind::Shader => "shader",
PpcQ3SubmissionKind::Style => "style",
PpcQ3SubmissionKind::FogStyle => "fog-style",
PpcQ3SubmissionKind::TriMesh => "trimesh",
PpcQ3SubmissionKind::MatrixTransform => "matrix-transform",
PpcQ3SubmissionKind::ResetTransform => "reset-transform",
PpcQ3SubmissionKind::Push => "push",
PpcQ3SubmissionKind::Pop => "pop",
PpcQ3SubmissionKind::Object => "object",
}
}
fn format_qd3d_latest_object(snapshot: &Qd3dTraceSnapshot) -> String {
snapshot
.latest_object
.map(|object| {
format!(
"object={} kind={} type=${:08X} data=${:08X}/{}",
format_hex_opt(Some(object.object)),
q3_object_kind_name(object.kind),
object.object_type,
object.data_ptr,
object.data_size
)
})
.unwrap_or_else(|| "object=none".to_string())
}
fn format_qd3d_latest_submission(snapshot: &Qd3dTraceSnapshot) -> String {
snapshot
.latest_submission
.map(|submission| {
format!(
"submission={} view={} primary={} secondary={}",
q3_submission_kind_name(submission.kind),
format_hex_opt(Some(submission.view)),
format_hex_opt(Some(submission.primary)),
format_hex_opt(Some(submission.secondary))
)
})
.unwrap_or_else(|| "submission=none".to_string())
}
fn format_qd3d_latest_frame(snapshot: &Qd3dTraceSnapshot) -> String {
snapshot
.latest_frame_view
.map(|view| {
format!(
"frame_view={} frame_submissions={}",
format_hex_opt(Some(view)),
snapshot.latest_frame_submissions
)
})
.unwrap_or_else(|| "frame=none".to_string())
}
fn format_qd3d_trace(
entry: &PpcHleImportTraceEntry,
args: [u32; 6],
action: &str,
before: &Qd3dTraceSnapshot,
after: &Qd3dTraceSnapshot,
) -> String {
format!(
"[QD3D-TRACE] {}:{} pc=${:08X} lr=${:08X} rtoc=${:08X} sp=${:08X} r3=${:08X} r4=${:08X} r5=${:08X} r6=${:08X} r7=${:08X} r8=${:08X} action={} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}",
entry.library_name,
entry.symbol_name,
entry.pc,
entry.lr,
entry.rtoc,
entry.sp,
args[0],
args[1],
args[2],
args[3],
args[4],
args[5],
action,
qd3d_trace_count("objects", before.objects, after.objects),
qd3d_trace_count("views", before.views, after.views),
qd3d_trace_count("submissions", before.submissions, after.submissions),
qd3d_trace_count("frames", before.completed_frames, after.completed_frames),
qd3d_trace_count("storages", before.memory_storages, after.memory_storages),
qd3d_trace_count("files", before.files, after.files),
qd3d_trace_count("groups", before.group_memberships, after.group_memberships),
qd3d_trace_count("trimeshes", before.trimeshes, after.trimeshes),
qd3d_trace_count("draw_contexts", before.draw_contexts, after.draw_contexts),
qd3d_trace_count("textures", before.textures, after.textures),
qd3d_trace_count("shaders", before.shaders, after.shaders),
qd3d_trace_count("styles", before.styles, after.styles),
qd3d_trace_count("cameras", before.cameras, after.cameras),
qd3d_trace_count("lights", before.lights, after.lights),
format_qd3d_latest_object(after),
format_qd3d_latest_submission(after),
format_qd3d_latest_frame(after)
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcWatchRange {
start: u32,
len: u32,
}
impl PpcWatchRange {
fn contains(self, addr: u32) -> bool {
let start = u64::from(self.start);
let end = start + u64::from(self.len);
let addr = u64::from(addr);
addr >= start && addr < end
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcWatchWriteRecord {
pc: u32,
lr: u32,
rtoc: u32,
sp: u32,
addr: u32,
value: u8,
}
struct PpcWatchObserver {
range: PpcWatchRange,
}
impl PpcMemoryWriteObserver for PpcWatchObserver {
fn on_write(&mut self, pc: u32, lr: u32, rtoc: u32, sp: u32, addr: u32, value: u8) {
if self.range.contains(addr) {
eprintln!(
"{}",
format_ppc_watch_write(PpcWatchWriteRecord {
pc,
lr,
rtoc,
sp,
addr,
value,
})
);
}
}
}
static PPC_WATCH_RANGE: OnceLock<Option<PpcWatchRange>> = OnceLock::new();
fn ppc_watch_range() -> Option<PpcWatchRange> {
*PPC_WATCH_RANGE.get_or_init(|| {
let value = std::env::var_os("SYSTEMLESS_PPC_WATCH")?;
parse_ppc_watch_range_value(&value)
})
}
fn parse_ppc_watch_range_value(value: &std::ffi::OsStr) -> Option<PpcWatchRange> {
let value = value.to_str()?.trim();
if value.is_empty() {
return None;
}
let mut parts = value.split(':');
let start = parse_ppc_watch_addr(parts.next()?)?;
let len = match parts.next() {
Some(raw_len) => parse_ppc_watch_len(raw_len)?,
None => 1,
};
if parts.next().is_some() {
return None;
}
if len == 0 || u64::from(start) + u64::from(len) > (u64::from(u32::MAX) + 1) {
return None;
}
Some(PpcWatchRange { start, len })
}
fn parse_ppc_watch_addr(value: &str) -> Option<u32> {
let value = value
.trim()
.trim_start_matches('$')
.trim_start_matches("0x")
.trim_start_matches("0X");
if value.is_empty() {
return None;
}
u32::from_str_radix(value, 16).ok()
}
fn parse_ppc_watch_len(value: &str) -> Option<u32> {
let value = value.trim();
if value.is_empty() {
return None;
}
let len = value
.strip_prefix("0x")
.or_else(|| value.strip_prefix("0X"))
.map_or_else(
|| value.parse().ok(),
|hex| u32::from_str_radix(hex, 16).ok(),
)?;
(len != 0).then_some(len)
}
fn format_ppc_watch_write(record: PpcWatchWriteRecord) -> String {
format!(
"[PPC-WATCH] pc=${:08X} lr=${:08X} rtoc=${:08X} sp=${:08X} addr=${:08X} value=${:02X}",
record.pc, record.lr, record.rtoc, record.sp, record.addr, record.value
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) struct PpcCallbackTarget {
pub(super) entry: u32,
pub(super) rtoc: u32,
pub(super) proc_info: u32,
pub(super) routine_flags: u16,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcAppleEventDispatchAllocation {
resume_guest_call_depth: usize,
descriptors: u32,
event_handle: u32,
reply_handle: u32,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct PpcAppleEventState {
pub(crate) apple_event_launch_state: SharedProcessAppleEventLaunchState,
handlers: SharedProcessAppleEventHandlers,
pending_dispatches: Vec<PpcAppleEventDispatchAllocation>,
}
type PpcMenuTracking = ProcessMenuTrackingState;
type PpcSubmenuTracking = ProcessTrackedMenuPane;
#[derive(Debug, Clone, PartialEq, Eq)]
struct PpcPaletteAllocation {
palette: u32,
gdevice: u32,
entry_to_index: Vec<Option<u8>>,
entry_mappings: Vec<PpcPaletteEntryMapping>,
reserved_indices: Vec<u8>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PpcPaletteEntryMapping {
Unallocated,
MatchOnly(u8),
TolerantInstalled(u8),
AnimatedReserved(u8),
Explicit(u8),
}
impl PpcPaletteEntryMapping {
fn index(self) -> Option<u8> {
match self {
Self::Unallocated => None,
Self::MatchOnly(index)
| Self::TolerantInstalled(index)
| Self::AnimatedReserved(index)
| Self::Explicit(index) => Some(index),
}
}
fn animated_index(self) -> Option<u8> {
match self {
Self::AnimatedReserved(index) => Some(index),
_ => None,
}
}
fn owned_index(self) -> Option<u8> {
match self {
Self::TolerantInstalled(index) | Self::AnimatedReserved(index) => Some(index),
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PpcToolboxStartupState {
pub init_graf_count: u32,
pub init_graf_global_ptr: u32,
pub fonts_initialized: bool,
pub windows_initialized: bool,
pub menus_initialized: bool,
pub menu_bar_draw_count: u32,
pub host_menu_bar_hidden: bool,
pub(crate) pending_native_menu_selection: SharedNativeMenuSelection,
pub(crate) execution: ExecutionMenuViews,
/// Process-owned 68k switch marker/gateway and compatibility stack used
/// whenever native PowerPC enters classic code through Mixed Mode.
mixed_mode_m68k: SharedProcessMixedModeM68kState,
go_away_tracking: Option<PpcGoAwayTrackingState>,
drag_window_tracking: Option<PpcDragWindowTrackingState>,
grow_window_tracking: Option<PpcGrowWindowTrackingState>,
/// Retained native Standard File calls are resumed at the same import
/// frame after the host supplies a mouse or keyboard event.
standard_file_get_filtering: Option<PpcStandardFileFilteringState>,
standard_file_get_tracking: Option<PpcStandardFileGetTrackingState>,
standard_file_put_tracking: Option<PpcStandardFilePutTrackingState>,
pub text_edit_initialized: bool,
pub dialogs_initialized: bool,
pub dialog_resume_proc: u32,
pub flush_events_count: u32,
pub last_flush_event_mask: u16,
pub last_flush_stop_mask: u16,
pub dispose_dialog_count: u32,
pub last_disposed_dialog: u32,
/// Most recent EventRecord exposed through the native event imports.
pub(crate) last_event_record: Option<EventRecordSnapshot>,
pub(crate) event_queue_probe: EventQueueProbeSnapshot,
pub(crate) last_button_result: Option<bool>,
pub(crate) last_still_down_result: Option<bool>,
pub(crate) last_wait_mouse_up_result: Option<bool>,
pub(crate) activation_event_seen: bool,
pub(crate) update_event_seen: bool,
pub delay_deadline: Option<u32>,
pub next_ct_seed: u32,
pub(crate) last_quickdraw_error: SharedProcessValue<i16>,
pub open_region_port: u32,
pub open_region_save_handle: u32,
pub open_region_bounds: Option<(i16, i16, i16, i16)>,
/// Exact collected scanlines for framed shapes in an open region.
pub open_region_rows: Option<(i16, Vec<Vec<i16>>)>,
/// PicHandle, recording port, frame, and PICT v2 command stream.
open_picture: Option<(u32, u32, (i16, i16, i16, i16), Vec<u8>)>,
application_palette: u32,
application_palette_updates: u16,
palette_allocations: Vec<PpcPaletteAllocation>,
active_device_palettes: HashMap<u32, u32>,
known_gdevices: Vec<u32>,
indexed_screen_ctables: HashMap<u32, u32>,
indexed_screen_mode: Option<(u32, bool)>,
gworld_allocations: HashMap<u32, PpcGWorldAllocationRecord>,
quickdraw_back_indices: HashMap<u32, u8>,
pub clut_protected: [bool; 256],
pub clut_reserved: [bool; 256],
clut_protected_by_device: HashMap<u32, [bool; 256]>,
clut_reserved_by_device: HashMap<u32, [bool; 256]>,
pub quickdraw_pen_pattern: [u8; 8],
/// Current Color QuickDraw background pattern. A set bit selects the
/// foreground color and a clear bit selects the background color, as in
/// the classic `Pattern` record used by BackPat.
pub quickdraw_back_pattern: [u8; 8],
pub ae_interaction_allowed: u8,
pub(crate) stdc_signal_state: PpcStdSignalState,
}
impl Default for PpcToolboxStartupState {
fn default() -> Self {
Self {
init_graf_count: 0,
init_graf_global_ptr: 0,
fonts_initialized: false,
windows_initialized: false,
menus_initialized: false,
menu_bar_draw_count: 0,
host_menu_bar_hidden: false,
pending_native_menu_selection: SharedNativeMenuSelection::default(),
execution: ExecutionMenuViews::detached(),
mixed_mode_m68k: SharedProcessMixedModeM68kState::default(),
go_away_tracking: None,
drag_window_tracking: None,
grow_window_tracking: None,
standard_file_get_filtering: None,
standard_file_get_tracking: None,
standard_file_put_tracking: None,
text_edit_initialized: false,
dialogs_initialized: false,
dialog_resume_proc: 0,
flush_events_count: 0,
last_flush_event_mask: 0,
last_flush_stop_mask: 0,
dispose_dialog_count: 0,
last_disposed_dialog: 0,
last_event_record: None,
event_queue_probe: EventQueueProbeSnapshot::default(),
last_button_result: None,
last_still_down_result: None,
last_wait_mouse_up_result: None,
activation_event_seen: false,
update_event_seen: false,
delay_deadline: None,
next_ct_seed: 0,
last_quickdraw_error: SharedProcessValue::from_value(PPC_NO_ERR),
open_region_port: 0,
open_region_save_handle: 0,
open_region_bounds: None,
open_region_rows: None,
open_picture: None,
application_palette: 0,
application_palette_updates: 0,
palette_allocations: Vec::new(),
active_device_palettes: HashMap::new(),
known_gdevices: vec![PPC_MAIN_GDEVICE],
indexed_screen_ctables: HashMap::new(),
indexed_screen_mode: Some((PPC_MAIN_PIXEL_DEPTH, true)),
gworld_allocations: HashMap::new(),
quickdraw_back_indices: HashMap::new(),
clut_protected: [false; 256],
clut_reserved: [false; 256],
clut_protected_by_device: HashMap::new(),
clut_reserved_by_device: HashMap::new(),
quickdraw_pen_pattern: [0xff; 8],
quickdraw_back_pattern: [0x00; 8],
ae_interaction_allowed: 1,
stdc_signal_state: PpcStdSignalState::default(),
}
}
}
impl PpcToolboxStartupState {
pub(crate) fn retained_host_overlay_rects(&self) -> Vec<(i16, i16, i16, i16)> {
self.standard_file_get_tracking
.iter()
.map(|tracking| tracking.bounds)
.chain(
self.standard_file_put_tracking
.iter()
.map(|tracking| tracking.bounds),
)
.collect()
}
fn active_menu_definition(&self) -> Option<&MenuDefinitionTracking> {
self.execution
.menu()
.as_ref()
.and_then(PpcMenuTracking::active_definition)
.or(self.execution.menu().context().definition.as_ref())
}
fn with_active_menu_definition_mut<R>(
&self,
update: impl FnOnce(&mut MenuDefinitionTracking) -> R,
) -> Option<R> {
if self
.execution
.menu()
.as_ref()
.and_then(PpcMenuTracking::active_definition)
.is_some()
{
return self
.execution
.with_menu_state_mut(|tracking| tracking.active_definition_mut().map(update))
.flatten();
}
self.execution
.with_existing_menu_context_mut(|context| context.definition.as_mut().map(update))
.flatten()
}
fn clear_active_menu_definition(&mut self) {
if self
.execution
.with_menu_state_mut(|tracking| tracking.take_active_definition().is_some())
.unwrap_or(false)
{
return;
}
self.execution
.with_existing_menu_context_mut(|context| context.definition = None);
}
}
fn ppc_prepare_menu_definition_port(
startup: &mut PpcToolboxStartupState,
current_gworld: &mut u32,
current_gdevice: &mut u32,
) {
if startup.execution.menu().context().native_port.is_none() {
startup.execution.with_menu_context_mut(|context| {
context.native_port = Some((*current_gworld, *current_gdevice));
});
}
*current_gworld = PPC_MAIN_GWORLD;
*current_gdevice = PPC_MAIN_GDEVICE;
}
fn ppc_preserve_menu_callback_port(
startup: &mut PpcToolboxStartupState,
current_gworld: u32,
current_gdevice: u32,
) {
if startup.execution.menu().context().native_port.is_none() {
startup.execution.with_menu_context_mut(|context| {
context.native_port = Some((current_gworld, current_gdevice));
});
}
}
fn ppc_restore_menu_definition_port(
startup: &mut PpcToolboxStartupState,
current_gworld: &mut u32,
current_gdevice: &mut u32,
) {
if let Some((gworld, gdevice)) = startup
.execution
.with_existing_menu_context_mut(|context| context.native_port.take())
.flatten()
{
*current_gworld = gworld;
*current_gdevice = gdevice;
}
}
pub type PpcHandleRecord = ProcessHandleRecord;
pub type PpcPtrRecord = ProcessPtrRecord;
pub type PpcHandleStateRecord = ProcessHandleStateRecord;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcQ3SoftwareFrontBufferSurface {
front_buffer: PpcFrontBuffer,
span: Option<PpcSectionMemSpan>,
indexed_clut: Option<[[u16; 3]; 256]>,
}
impl PpcQ3SoftwareFrontBufferSurface {
fn new(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
indexed_clut: Option<[[u16; 3]; 256]>,
) -> Self {
let span = ppc_q3_front_buffer_span_len(front_buffer)
.and_then(|len| memory.writable_span(front_buffer.base_addr, len));
Self {
front_buffer,
span,
indexed_clut,
}
}
fn read_pixel(&self, memory: &mut PpcSectionMem, point: (i32, i32)) -> Option<u16> {
if self.front_buffer.depth == 8 {
let index = usize::from(ppc_quickdraw_read_pixel(memory, self.front_buffer, point)?);
let [red, green, blue] = *self.indexed_clut.as_ref()?.get(index)?;
return Some(((red >> 11) << 10) | ((green >> 11) << 5) | (blue >> 11));
}
if let (Some(span), Some(offset)) = (self.span, self.pixel_relative_offset(point)) {
return memory.read_u16_be_in_span(span, offset);
}
ppc_q3_read_software_pixel(memory, self.front_buffer, point)
}
fn write_pixel(&self, memory: &mut PpcSectionMem, point: (i32, i32), color: u16) -> bool {
if self.front_buffer.depth == 8 {
let Some(clut) = self.indexed_clut.as_ref() else {
return false;
};
return ppc_quickdraw_write_raw_pixel(
memory,
self.front_buffer,
point,
u16::from(ppc_rgb555_to_clut_index(color, clut)),
);
}
if let (Some(span), Some(offset)) = (self.span, self.pixel_relative_offset(point)) {
return memory.write_u16_be_in_span(span, offset, color).is_some();
}
ppc_q3_write_software_pixel(memory, self.front_buffer, point, color)
}
fn pixel_relative_offset(&self, point: (i32, i32)) -> Option<usize> {
ppc_q3_front_buffer_pixel_relative_offset(self.front_buffer, point)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) struct PpcPixMapBits {
pub(super) base_addr: u32,
pub(super) row_bytes: u32,
pub(super) top: i16,
pub(super) left: i16,
pub(super) bottom: i16,
pub(super) right: i16,
pub(super) width: u32,
pub(super) height: u32,
pub(super) depth: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcResolvedPixMapBits {
bits: PpcPixMapBits,
guest_bounds: bool,
authoritative_bounds: bool,
}
#[derive(Debug, Default)]
pub(crate) struct PpcProcessMemoryManager(SharedProcessMemoryManager);
#[cfg(test)]
struct PpcTestHeapCursor {
memory_manager: SharedProcessMemoryManager,
value: u32,
}
#[cfg(test)]
struct PpcTestHandles {
memory_manager: SharedProcessMemoryManager,
value: Vec<PpcHandleRecord>,
}
#[cfg(test)]
impl std::ops::Deref for PpcTestHandles {
type Target = Vec<PpcHandleRecord>;
fn deref(&self) -> &Self::Target {
&self.value
}
}
#[cfg(test)]
impl std::ops::DerefMut for PpcTestHandles {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.value
}
}
#[cfg(test)]
impl Drop for PpcTestHandles {
fn drop(&mut self) {
let mut memory_manager = self.memory_manager.borrow_mut();
let records: Vec<_> = self
.value
.iter()
.map(|record| {
(
*record,
memory_manager
.state_for_handle(record.handle)
.unwrap_or(0x40),
)
})
.collect();
memory_manager.register_native_handle_records(records);
}
}
#[cfg(test)]
impl std::ops::Deref for PpcTestHeapCursor {
type Target = u32;
fn deref(&self) -> &Self::Target {
&self.value
}
}
#[cfg(test)]
impl std::ops::DerefMut for PpcTestHeapCursor {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.value
}
}
#[cfg(test)]
impl Drop for PpcTestHeapCursor {
fn drop(&mut self) {
self.memory_manager
.borrow_mut()
.mutate_native_allocator(|allocator| {
allocator.heap.heap_cursor = self.value;
});
}
}
impl Clone for PpcProcessMemoryManager {
fn clone(&self) -> Self {
Self(self.0.detached_clone())
}
}
impl PpcProcessMemoryManager {
pub(crate) fn with_heap(heap_cursor: u32, heap_limit: u32) -> Self {
let memory_manager = Self::default();
{
let mut process_memory_manager = memory_manager.0.borrow_mut();
let process_memory_manager = process_memory_manager.native_mut();
process_memory_manager.publish_native_allocator(
ProcessNativeHeapState {
heap_base: PPC_HEAP_BASE,
heap_cursor,
heap_limit,
last_mem_error: PPC_NO_ERR,
heap_maximized: false,
master_pointer_blocks_requested: 0,
},
&[],
&[],
&[],
);
// Inside Macintosh: Memory (1992), pp. 2-83--2-85: the
// application limit is an API-visible heap/stack boundary, not
// the allocator's physical mapping ceiling.
process_memory_manager.set_application_heap_limit(heap_limit);
}
memory_manager
}
fn attach_to(&mut self, memory_manager: SharedProcessMemoryManager) {
self.0 = memory_manager;
}
fn ptr_eq(&self, memory_manager: &SharedProcessMemoryManager) -> bool {
self.0.ptr_eq(memory_manager)
}
fn heap_limit(&self, fallback: u32) -> u32 {
self.0
.borrow()
.native_heap_state()
.map_or(fallback, |heap| heap.heap_limit)
}
fn heap_cursor(&self, fallback: u32) -> u32 {
self.0
.borrow()
.native_heap_state()
.map_or(fallback, |heap| heap.heap_cursor)
}
fn last_mem_error(&self) -> i16 {
self.0
.borrow()
.native_heap_state()
.map_or(0, |heap| heap.last_mem_error)
}
fn application_heap_limit(&self, fallback: u32) -> u32 {
self.0
.borrow()
.application_heap_limit(fallback)
}
#[cfg(test)]
fn heap_cursor_mut(&self) -> PpcTestHeapCursor {
PpcTestHeapCursor {
memory_manager: self.0.clone(),
value: self.heap_cursor(PPC_HEAP_BASE),
}
}
#[cfg(test)]
fn handles_mut(&self) -> PpcTestHandles {
PpcTestHandles {
memory_manager: self.0.clone(),
value: self.0.borrow().native_handle_records().to_vec(),
}
}
fn handles(&self) -> Vec<PpcHandleRecord> {
self.0.borrow().native_handle_records().to_vec()
}
}
#[derive(Debug, Clone)]
pub struct PpcLoadedApp {
pub cpu: PpcCpu,
/// Mapped guest bytes shared by native and emulated 68k execution.
pub memory: crate::memory::GuestAddressSpace,
pub entry_pc: u32,
pub rtoc: u32,
pub stack_base: u32,
pub stack_size: u32,
pub stack_pointer: u32,
/// Process-scoped host pacing snapshot for the wrapping Macintosh clock.
/// Guest-visible time is always read from low-memory `Ticks`; this handle
/// only lets callback scheduling share the last observed value while a
/// native slice is active.
pub(crate) tick_state: SharedProcessTickState,
pub clock_cycles_per_tick: u32,
pub clock_cycle_phase: u32,
pub native_exception_handler: u32,
pub(crate) native_exception_stack: Vec<PpcNativeExceptionContext>,
pub(crate) stdc_qsort_stack: Vec<PpcQsortState>,
pub(crate) dialog_callback_stack: Vec<PpcDialogCallbackState>,
pub(crate) apple_events: PpcAppleEventState,
/// Standalone CFM seed; None after a runner moves it into its process.
/// Installed execution must receive the process service explicitly.
pub cfm: Option<PpcCfmState>,
pub(crate) controls: SharedProcessControlManager,
pub aliases: Vec<PpcAliasRecord>,
pub gworlds: Vec<PpcGWorldRecord>,
/// Process-owned state bits keyed by PixMapHandle. GWorld geometry,
/// allocation, and rendering records remain in `gworlds`.
pub(crate) gworld_pixel_states: SharedProcessQuickDrawPixelStates,
pub q3_objects: Vec<PpcQ3ObjectRecord>,
pub q3_object_refs: Vec<PpcQ3ObjectReferenceRecord>,
pub next_q3_object: u32,
pub q3_error_state: PpcQ3ErrorState,
pub q3_lifecycle: PpcQ3LifecycleState,
pub q3_memory_storages: Vec<PpcQ3MemoryStorageRecord>,
pub q3_files: Vec<PpcQ3FileRecord>,
pub q3_group_memberships: Vec<PpcQ3GroupMembershipRecord>,
pub q3_file_groups: Vec<PpcQ3FileGroupRecord>,
pub q3_views: Vec<PpcQ3ViewStateRecord>,
pub q3_submissions: Vec<PpcQ3SubmissionRecord>,
pub q3_view_transforms: Vec<PpcQ3ViewTransformRecord>,
pub q3_submission_transforms: Vec<PpcQ3SubmissionTransformRecord>,
pub q3_view_materials: Vec<PpcQ3ViewMaterialRecord>,
pub q3_submission_materials: Vec<PpcQ3SubmissionMaterialRecord>,
pub q3_submission_lights: Vec<PpcQ3SubmissionLightRecord>,
pub q3_view_state_stack: Vec<PpcQ3ViewStateSnapshotRecord>,
pub q3_completed_frames: Vec<PpcQ3CompletedFrameRecord>,
pub q3_retained_frames: Vec<PpcQ3RetainedFrameRecord>,
pub q3_state_only_completed_frame_batches: Vec<PpcQ3StateOnlyCompletedFrameBatch>,
pub q3_fog_styles: Vec<PpcQ3FogStyleRecord>,
pub q3_attributes: Vec<PpcQ3AttributeRecord>,
pub q3_shader_uv_transforms: Vec<PpcQ3ShaderUvTransformRecord>,
pub q3_shader_boundaries: Vec<PpcQ3ShaderBoundaryRecord>,
pub q3_mipmap_textures: Vec<PpcQ3MipmapTextureRecord>,
pub q3_texture_shaders: Vec<PpcQ3TextureShaderRecord>,
pub q3_renderer_preferences: Vec<PpcQ3RendererPreferenceRecord>,
pub q3_draw_contexts: Vec<PpcQ3DrawContextRecord>,
pub q3_trimeshes: Vec<PpcQ3TriMeshRecord>,
pub q3_styles: Vec<PpcQ3StyleRecord>,
pub q3_cameras: Vec<PpcQ3CameraRecord>,
pub q3_lights: Vec<PpcQ3LightRecord>,
pub input_sprocket: PpcInputSprocketState,
pub input_sprocket_virtual_elements: Vec<PpcInputSprocketVirtualElementRecord>,
pub toolbox_startup: PpcToolboxStartupState,
pub quicktime: PpcQuickTimeState,
pub sound: PpcSoundState,
pub(crate) timer_tasks: SharedProcessTimerTasks,
pub(crate) vbl_tasks: SharedProcessVblTasks,
pub(crate) callback_scheduling: SharedProcessCallbackScheduling,
pub(crate) process_file_system: SharedProcessFileSystem,
pub current_gworld: SharedProcessValue<u32>,
pub current_gdevice: SharedProcessValue<u32>,
pub(crate) quickdraw_op_colors: SharedProcessQuickDrawOpColors,
pub(crate) quickdraw_hilite_colors: SharedProcessQuickDrawHiliteColors,
pub screen_clut: SharedProcessDisplayClut,
pub color_manager_clut: SharedProcessDisplayClut,
pub(crate) display_gamma: SharedProcessDisplayGamma,
/// Whether QuickDraw draw state is canonical in the attached process's
/// current CGrafPort record and must be reloaded at each import boundary.
pub(crate) process_quickdraw_port_state_attached: bool,
pub quickdraw_fore_color: PpcRgbColor,
pub(crate) quickdraw_fore_indices: HashMap<u32, u8>,
pub quickdraw_back_color: PpcRgbColor,
pub quickdraw_pen_h: i16,
pub quickdraw_pen_v: i16,
pub quickdraw_text_mode: i16,
pub quickdraw_text_size: i16,
pub(crate) cursor_state: SharedProcessCursorState,
pub param_text: SharedProcessDialogText,
pub scrap: PpcScrapState,
pub list_manager: PpcListManagerState,
pub halt_pc: u32,
pub import_trap_base: u32,
pub import_count: u32,
pub imports: Vec<PpcImportBinding>,
pub section_bases: Vec<Option<u32>>,
pub input: PpcInputSnapshot,
pub(crate) process_input: SharedProcessInputState,
pub(crate) event_queue: SharedProcessEventQueue,
pub(crate) window_list: crate::process_context::SharedProcessWindowList,
pub(crate) process_memory_manager: PpcProcessMemoryManager,
pub draw_sprocket: PpcDrawSprocketState,
}
impl std::ops::Deref for PpcLoadedApp {
type Target = ProcessFileSystemState;
fn deref(&self) -> &Self::Target {
&self.process_file_system
}
}
#[cfg(test)]
impl PpcLoadedApp {
fn push_test_vfs_file(&mut self, file: PpcVfsFileRecord) {
self.process_file_system
.with_mut(|file_system| file_system.vfs_files.push(file));
}
fn push_test_open_file(&mut self, file: PpcFileRecord) {
self.process_file_system
.with_mut(|file_system| file_system.files.push(file));
}
fn push_test_deleted_vfs_file_path(&mut self, path: String) {
self.process_file_system
.with_mut(|file_system| file_system.deleted_vfs_file_paths.push(path));
}
fn set_test_next_file_ref_num(&mut self, next_file_ref_num: i16) {
self.process_file_system.with_mut(|file_system| {
file_system.next_file_ref_num = next_file_ref_num;
});
}
pub(crate) fn with_test_vfs_file_mut<R>(
&mut self,
index: usize,
operation: impl FnOnce(&mut PpcVfsFileRecord) -> R,
) -> Option<R> {
self.process_file_system
.with_mut(|file_system| file_system.vfs_files.get_mut(index).map(operation))
}
fn with_test_open_file_mut<R>(
&mut self,
index: usize,
operation: impl FnOnce(&mut PpcFileRecord) -> R,
) -> Option<R> {
self.process_file_system
.with_mut(|file_system| file_system.files.with_record_mut(index, operation))
}
fn insert_test_stdio_stream(
&mut self,
address: u32,
stream: crate::process_context::ProcessStdioStreamRecord,
) {
self.process_file_system
.with_mut(|file_system| file_system.stdio_streams.insert(address, stream));
}
fn publish_test_native_vfs_catalogue(&mut self) {
self.process_file_system
.with_mut(ProcessFileSystemState::publish_native_vfs_catalogue);
}
}
fn ppc_hle_import_trace_same_run(
left: &PpcHleImportTraceEntry,
right: &PpcHleImportTraceEntry,
) -> bool {
left.library_name == right.library_name && left.symbol_name == right.symbol_name
}
fn push_ppc_hle_import_trace_entry(
trace: &mut Vec<PpcHleImportTraceEntry>,
entry: PpcHleImportTraceEntry,
) {
if let Some(last) = trace.last_mut() {
if ppc_hle_import_trace_same_run(last, &entry) {
last.repeat_count = last.repeat_count.saturating_add(entry.repeat_count);
return;
}
}
trace.push(entry);
}
pub(super) fn ppc_set_current_resource_refnum(
memory: &mut PpcSectionMem,
current_resource_refnum: &mut i16,
refnum: i16,
) {
*current_resource_refnum = refnum;
let _ = memory.write_u16_be(PPC_CUR_RES_FILE_ADDR, refnum as u16);
}
impl PpcLoadedApp {
#[cfg(test)]
pub(crate) fn guest_calls(&self) -> &SharedGuestCallStack {
self.toolbox_startup.execution.calls()
}
#[cfg(test)]
pub(crate) fn is_constructed_from_migrated_handles(
&self,
handles: &crate::process_context::MigratedProcessHandles,
) -> bool {
self.tick_state.ptr_eq(&handles.ticks)
&& self
.toolbox_startup
.execution
.calls()
.ptr_eq(&handles.execution)
&& self.toolbox_startup.execution.is_coherent()
}
pub(crate) fn preflight_migrated_services(
&self,
context: &ProcessContext,
expected_process_tick_at_commit: u32,
) -> Result<
crate::process_context::MigratedServiceAdoption,
crate::process_context::MigratedServiceConflict,
> {
context.preflight_migrated_adoption(
&self.tick_state,
&self.toolbox_startup.execution,
expected_process_tick_at_commit,
)
}
pub(crate) fn commit_migrated_services(
&mut self,
context: &ProcessContext,
plan: crate::process_context::MigratedServiceAdoption,
) {
context.commit_migrated_adoption(
plan,
&mut self.tick_state,
&mut self.toolbox_startup.execution,
);
}
pub(crate) fn cfm_symbol_bindings(
&mut self,
) -> impl crate::cfm::CfmSymbolBindings + '_ {
PpcPersistedSymbolBindings::new(
&mut self.imports,
&mut self.import_count,
ppc_import_layout(),
&SystemlessPpcImportBindingPolicy,
)
}
#[cfg(test)]
fn set_test_resource_error(&mut self, error: i16) {
let _ = self
.memory
.write_u16_be(crate::memory::globals::addr::RES_ERR, error as u16);
}
#[cfg(test)]
fn test_resource_error(&mut self) -> i16 {
self.memory
.read_u16_be(crate::memory::globals::addr::RES_ERR)
.unwrap_or(0) as i16
}
/// Return the process Resource Manager's current resource file.
pub fn current_resource_refnum(&self) -> i16 {
*self.process_file_system.current_resource_file
}
/// Select the process Resource Manager's current resource file.
pub fn set_current_resource_refnum(&mut self, refnum: i16) {
let memory = &mut self.memory;
self.process_file_system
.current_resource_file
.with_mut(|current_file| ppc_set_current_resource_refnum(memory, current_file, refnum));
}
/// Return the fixed base of the process-owned native heap.
pub fn heap_base(&self) -> u32 {
self.process_memory_manager
.0
.borrow()
.native_heap_state()
.map_or(PPC_HEAP_BASE, |heap| heap.heap_base)
}
/// Return the next address in the process-owned native heap.
pub fn heap_cursor(&self) -> u32 {
self.process_memory_manager.heap_cursor(PPC_HEAP_BASE)
}
/// Return the upper bound of the process-owned native heap.
pub fn heap_limit(&self) -> u32 {
self.process_memory_manager.heap_limit(self.stack_base)
}
/// Return the process-owned application heap limit used by
/// `GetApplLimit`, distinct from the native heap mapping ceiling.
pub fn application_heap_limit(&self) -> u32 {
self.process_memory_manager
.application_heap_limit(self.stack_base)
}
/// Return the last process-owned native Memory Manager error.
pub fn last_mem_error(&self) -> i16 {
self.process_memory_manager.last_mem_error()
}
/// Report whether `MaxApplZone` has expanded the process-owned native heap.
pub fn heap_maximized(&self) -> bool {
self.process_memory_manager
.0
.borrow()
.native_heap_state()
.is_some_and(|heap| heap.heap_maximized)
}
/// Return the number of process-owned master-pointer growth requests.
pub fn master_pointer_blocks_requested(&self) -> u32 {
self.process_memory_manager
.0
.borrow()
.native_heap_state()
.map_or(0, |heap| heap.master_pointer_blocks_requested)
}
/// Return the process-owned native handle states for this adapter's handles.
pub fn handle_states(&self) -> Vec<PpcHandleStateRecord> {
let memory_manager = self.process_memory_manager.0.borrow();
memory_manager
.native_handle_records()
.iter()
.map(|record| memory_manager.native_handle_state(record.handle))
.collect()
}
/// Return the process-owned native relocatable allocation records.
pub fn handles(&self) -> Vec<PpcHandleRecord> {
self.process_memory_manager.handles()
}
/// Return the process-owned native pointer allocation records.
pub fn ptrs(&self) -> Vec<PpcPtrRecord> {
self.process_memory_manager
.0
.borrow()
.native_allocator_snapshot()
.map_or_else(Vec::new, |allocator| allocator.ptrs)
}
/// Return the process-owned native pointer free list.
pub fn free_ptr_blocks(&self) -> Vec<PpcPtrRecord> {
self.process_memory_manager
.0
.borrow()
.native_allocator_snapshot()
.map_or_else(Vec::new, |allocator| allocator.free_ptr_blocks)
}
/// Return the process-owned native handle free list.
pub fn free_handle_blocks(&self) -> Vec<PpcHandleRecord> {
self.process_memory_manager
.0
.borrow()
.native_allocator_snapshot()
.map_or_else(Vec::new, |allocator| allocator.free_handle_blocks)
}
#[cfg(test)]
fn replace_handle_states(&self, handle_states: Vec<PpcHandleStateRecord>) {
let mut memory_manager = self.process_memory_manager.0.borrow_mut();
let handles = memory_manager.native_handle_records().to_vec();
memory_manager.register_native_handle_records(handles.iter().map(|record| {
(
*record,
ppc_process_handle_state_bits(&handle_states, record.handle),
)
}));
for state in handle_states {
memory_manager.set_native_handle_state(state);
}
}
#[cfg(test)]
fn replace_ptr_allocator_records(
&self,
ptrs: Vec<PpcPtrRecord>,
free_ptr_blocks: Vec<PpcPtrRecord>,
) {
let mut memory_manager = self.process_memory_manager.0.borrow_mut();
if memory_manager.has_native_allocator() {
memory_manager.mutate_native_allocator(|allocator| {
allocator.ptrs = ptrs;
allocator.free_ptr_blocks = free_ptr_blocks;
});
} else {
memory_manager.publish_native_allocator(
ProcessNativeHeapState {
heap_base: PPC_HEAP_BASE,
heap_cursor: self.heap_cursor(),
heap_limit: self.stack_base,
last_mem_error: 0,
heap_maximized: false,
master_pointer_blocks_requested: 0,
},
&ptrs,
&free_ptr_blocks,
&[],
);
}
}
#[cfg(test)]
pub(crate) fn set_heap_cursor(&self, heap_cursor: u32) {
let mut memory_manager = self.process_memory_manager.0.borrow_mut();
if memory_manager.has_native_allocator() {
memory_manager.mutate_native_allocator(|allocator| {
allocator.heap.heap_cursor = heap_cursor;
});
} else {
memory_manager.publish_native_allocator(
ProcessNativeHeapState {
heap_base: PPC_HEAP_BASE,
heap_cursor,
heap_limit: self.stack_base,
last_mem_error: 0,
heap_maximized: false,
master_pointer_blocks_requested: 0,
},
&[],
&[],
&[],
);
}
}
#[cfg(test)]
fn with_ptr_allocator_records<R>(
&mut self,
f: impl FnOnce(&mut Self, &mut Vec<PpcPtrRecord>, &mut Vec<PpcPtrRecord>) -> R,
) -> R {
let mut ptrs = self.ptrs();
let mut free_ptr_blocks = self.free_ptr_blocks();
let result = f(self, &mut ptrs, &mut free_ptr_blocks);
self.replace_ptr_allocator_records(ptrs, free_ptr_blocks);
result
}
#[cfg(test)]
fn set_heap_limit(&self, heap_limit: u32) {
let mut memory_manager = self.process_memory_manager.0.borrow_mut();
if memory_manager.has_native_allocator() {
memory_manager.mutate_native_allocator(|allocator| {
allocator.heap.heap_limit = heap_limit;
});
} else {
memory_manager.publish_native_allocator(
ProcessNativeHeapState {
heap_base: PPC_HEAP_BASE,
heap_cursor: self.heap_cursor(),
heap_limit,
last_mem_error: 0,
heap_maximized: false,
master_pointer_blocks_requested: 0,
},
&[],
&[],
&[],
);
}
}
#[cfg(test)]
fn set_last_mem_error(&self, last_mem_error: i16) {
let mut memory_manager = self.process_memory_manager.0.borrow_mut();
if memory_manager.has_native_allocator() {
memory_manager.mutate_native_allocator(|allocator| {
allocator.heap.last_mem_error = last_mem_error;
});
} else {
memory_manager.publish_native_allocator(
ProcessNativeHeapState {
heap_base: PPC_HEAP_BASE,
heap_cursor: self.heap_cursor(),
heap_limit: self.stack_base,
last_mem_error,
heap_maximized: false,
master_pointer_blocks_requested: 0,
},
&[],
&[],
&[],
);
}
}
fn refresh_process_native_zone(
&mut self,
heap: ProcessNativeHeapState,
allocation_limit: u32,
) {
ppc_update_zone_free_bytes(&mut self.memory, heap.heap_cursor, allocation_limit);
}
pub(crate) fn prepare_shared_system_reservation(&mut self, base: u32, len: u32) -> bool {
if self.memory.has_readonly_allocation_exclusion(base, len) {
return true;
}
let start = u64::from(base);
let Some(end) = start.checked_add(u64::from(len)) else {
return false;
};
if len == 0 || end > (1u64 << 32) {
return false;
}
fn mapped_overlaps(memory: &mut PpcSectionMem, start: u64, end: u64) -> bool {
if start >= end {
return false;
}
memory.mapping_overlaps(
u32::try_from(start).expect("nonempty guest range starts below 2^32"),
u32::try_from(end - start).expect("subrange fits reservation length"),
)
}
// The public low-level loader has no runner reservation to exclude.
// Preserve that source-compatible path by attaching late only when
// every byte outside the future bump-heap tail is genuinely unmapped.
let future_start = u64::from(self.heap_cursor());
let future_end = u64::from(self.heap_limit());
let before_end = end.min(future_start);
let after_start = start.max(future_end);
if mapped_overlaps(&mut self.memory, start, before_end)
|| mapped_overlaps(&mut self.memory, after_start, end)
{
return false;
}
self.memory
.add_readonly_allocation_exclusion(base, len)
.is_some()
}
/// Grow the native allocation budget for a Finder-style preferred partition.
/// The sparse native address space keeps its fixed stack and Toolbox mappings;
/// those addresses must never become available to the expanding allocator.
/// Inside Macintosh: Processes (1994), pp. 1-3 and 2-18.
pub(crate) fn grow_application_partition(&mut self, partition_size: u32) {
let requested_heap = partition_size.saturating_sub(self.stack_size);
let heap_base = self.heap_base();
if requested_heap <= ppc_heap_free_capacity(&self.memory, heap_base, self.heap_limit()).0 {
return;
}
let fixed_end = PPC_DSP_BACK_SCREEN_BASE + ppc_main_screen_buffer_size();
let fixed_len = fixed_end - self.stack_base;
self.memory
.add_readonly_allocation_exclusion(self.stack_base, fixed_len)
.expect("native fixed mappings have a valid address range");
let mut limit = heap_base.saturating_add(requested_heap);
// Include each reserved gap in the address ceiling without counting its
// bytes as application memory (including the shared system reservation).
loop {
let available = ppc_heap_free_capacity(&self.memory, heap_base, limit).0;
if available >= requested_heap {
break;
}
let Some(next) = limit.checked_add(requested_heap - available) else {
return;
};
limit = next;
}
{
let mut manager = self.process_memory_manager.0.borrow_mut();
manager.native_mut().grow_native_heap_limit(limit);
manager.set_application_heap_limit(limit);
}
let _ = self
.memory
.write_u32_be(crate::memory::globals::addr::APPL_LIMIT, limit);
let _ = self.memory.write_u32_be(PPC_APPLICATION_ZONE, limit);
let _ = self.memory.write_u32_be(PPC_SYSTEM_ZONE, limit);
let cursor = self.heap_cursor();
ppc_update_zone_free_bytes(&mut self.memory, cursor, limit);
}
pub fn run_import_trace(&mut self, max_cycles: u64) -> (PpcRunResult, Vec<u32>) {
let mut trace = Vec::new();
let result = self.cpu.run_with_import_trace(
&mut self.memory,
max_cycles,
self.halt_pc,
self.import_trap_base,
self.import_count,
&mut trace,
);
(result, trace)
}
pub fn run_until_import_or_fault(&mut self, max_cycles: u64) -> PpcStartupProbe {
let mut first_import_index = None;
let result = self.cpu.run_with_imports(
&mut self.memory,
max_cycles,
self.halt_pc,
self.import_trap_base,
self.import_count,
|index, _cpu, _memory| {
first_import_index = Some(index);
PpcImportAction::Halt
},
);
PpcStartupProbe {
result,
first_import_index,
}
}
pub fn import_binding(&self, symbol_index: u32) -> Option<&PpcImportBinding> {
self.imports
.iter()
.find(|binding| binding.symbol_index == symbol_index)
}
pub fn set_input_snapshot(&mut self, input: PpcInputSnapshot) {
use crate::memory::globals::addr;
// Native mouse and keyboard drivers mirror the current device state
// into low memory. PowerPC applications may poll these globals
// directly instead of calling Button, GetMouse, or GetKeys.
let _ = self
.memory
.write_u8(addr::MB_STATE, if input.mouse_button { 0x00 } else { 0x80 });
let _ = self.memory.write_bytes(addr::KEY_MAP_LM, &input.key_map);
for point_addr in [addr::M_TEMP, addr::MOUSE_LOC, addr::MOUSE_LOC2] {
let _ = self.memory.write_u16_be(point_addr, input.mouse_v as u16);
let _ = self
.memory
.write_u16_be(point_addr + 2, input.mouse_h as u16);
}
self.input = input;
self.process_input.set_key_map_snapshot(input.key_map);
self.process_input
.set_mouse_state((input.mouse_v, input.mouse_h), input.mouse_button);
}
fn current_input_snapshot(&self) -> PpcInputSnapshot {
let key_map = self.process_input.key_map_snapshot();
let ((mouse_v, mouse_h), mouse_button) = self.process_input.mouse_state_snapshot();
PpcInputSnapshot {
key_map,
mouse_button,
mouse_v,
mouse_h,
}
}
pub fn set_event_queue<I>(&mut self, events: I)
where
I: IntoIterator<Item = PpcQueuedEvent>,
{
self.event_queue.clear();
self.event_queue.extend(events);
}
pub fn event_queue(&self) -> &VecDeque<PpcQueuedEvent> {
&self.event_queue
}
pub fn cursor_level(&self) -> i16 {
self.cursor_state.level()
}
pub fn cursor_data(&self) -> Option<([u8; 32], [u8; 32], i16, i16)> {
self.cursor_state.mono_parts()
}
pub(crate) fn attach_unconverted_process_services(&mut self, context: &mut ProcessContext) {
let mut attached_memory_manager = None;
context.attach_memory_manager(&mut attached_memory_manager);
let attached_memory_manager =
attached_memory_manager.expect("process context supplies a Memory Manager");
// A runner shares low memory before attaching the native adapter. If
// a classic adapter has already initialized a compatible ApplLimit,
// adopt that value as the process seed instead of allowing the
// detached native default to overwrite it. Reject values outside the
// native heap's physical range: a classic-only partition may use a
// different address ceiling and is not a valid native allocation
// boundary. Inside Macintosh: Memory (1992), pp. 2-83--2-85.
let low_memory_application_limit = self
.memory
.read_u32_be(crate::memory::globals::addr::APPL_LIMIT)
.filter(|limit| *limit != 0)
.filter(|limit| {
self.process_memory_manager
.0
.borrow()
.native_heap_state()
.is_none_or(|heap| *limit >= heap.heap_cursor && *limit <= heap.heap_limit)
});
if let Some(low_memory_application_limit) = low_memory_application_limit {
let mut memory_manager = attached_memory_manager.borrow_mut();
if !memory_manager.application_heap_limit_is_set() {
memory_manager.set_application_heap_limit(low_memory_application_limit);
}
}
if !self.process_memory_manager.ptr_eq(&attached_memory_manager) {
let standalone_memory_manager = self.process_memory_manager.0.borrow();
let memory_manager = attached_memory_manager.borrow();
memory_manager.assert_can_adopt_process_memory_manager(&standalone_memory_manager);
}
context.attach_file_system(&mut self.process_file_system);
self.process_file_system
.with_mut(ProcessFileSystemState::publish_native_vfs_catalogue);
context.attach_sound_manager(&mut self.sound.manager);
context.attach_callback_tasks(
&mut self.timer_tasks,
&mut self.vbl_tasks,
&mut self.callback_scheduling,
);
context.attach_scrap_state(&mut self.scrap.desktop);
context.attach_text_edit_manager(&mut self.scrap.text_edit);
context.attach_control_manager(&mut self.controls);
context.attach_list_manager(&mut self.list_manager);
context.attach_dialog_text(&mut self.param_text);
context.attach_cursor_state(&mut self.cursor_state);
context.activate_quickdraw_selection(&mut self.current_gworld, &mut self.current_gdevice);
context.attach_quickdraw_op_colors(&mut self.quickdraw_op_colors);
context.attach_quickdraw_hilite_colors(&mut self.quickdraw_hilite_colors);
self.process_quickdraw_port_state_attached = true;
context.attach_quickdraw_error(&mut self.toolbox_startup.last_quickdraw_error);
context.attach_quickdraw_pixel_states(&mut self.gworld_pixel_states);
context.attach_display_color_state(
&mut self.screen_clut,
&mut self.color_manager_clut,
&mut self.display_gamma,
);
context.attach_event_queue(&mut self.event_queue);
context.attach_window_list(&mut self.window_list);
context.attach_input_state(&mut self.process_input);
if !self.process_memory_manager.ptr_eq(&attached_memory_manager) {
{
let standalone_memory_manager = self.process_memory_manager.0.clone();
let mut standalone_memory_manager = standalone_memory_manager.borrow_mut();
let mut memory_manager = attached_memory_manager.borrow_mut();
memory_manager.adopt_process_memory_manager(&mut standalone_memory_manager);
if let Some(heap) = memory_manager.native_heap_state() {
let allocation_limit = memory_manager.native_allocation_limit(heap.heap_limit);
self.refresh_process_native_zone(heap, allocation_limit);
}
}
self.process_memory_manager
.attach_to(attached_memory_manager);
}
// APPL_LIMIT is a low-memory projection of the process-owned value.
// Synchronize it on attachment so a nested 68K callback and a later
// native import observe the same boundary immediately. Inside
// Macintosh: Memory (1992), pp. 2-83--2-85.
let application_heap_limit = self
.process_memory_manager
.application_heap_limit(self.stack_base);
let _ = self.memory.write_u32_be(
crate::memory::globals::addr::APPL_LIMIT,
application_heap_limit,
);
context
.attach_native_menu_selection(&mut self.toolbox_startup.pending_native_menu_selection);
context.attach_mixed_mode_m68k_state(&mut self.toolbox_startup.mixed_mode_m68k);
context.attach_apple_event_handlers(&mut self.apple_events.handlers);
context.attach_apple_event_launch_state(&mut self.apple_events.apple_event_launch_state);
}
/// Run one native operation with every process manager continuously attached.
#[cfg(test)]
pub(crate) fn with_process_state<R>(&mut self, f: impl FnOnce(&mut Self) -> R) -> R {
f(self)
}
/// Run one native operation with the continuously attached process Memory
/// Manager as its sole allocator owner.
#[cfg(test)]
pub(crate) fn with_process_memory_manager<R>(
&mut self,
f: impl FnOnce(&mut Self, &mut ProcessMemoryManager) -> R,
) -> R {
let memory_manager = self.process_memory_manager.0.clone();
self.with_process_state(|app| {
let mut memory_manager = memory_manager.borrow_mut();
f(app, &mut memory_manager)
})
}
/// Park the current native context and enter a PowerPC routine selected by
/// a 68k RoutineDescriptor. The new ABI frame protects the parked caller's
/// linkage and parameter areas while the shared continuation owns return.
pub(crate) fn activate_powerpc_from_m68k(
&mut self,
caller: &mut crate::cpu::M68kCpu,
) -> Option<()> {
let pending = self.toolbox_startup.execution.calls().pending_powerpc_from_m68k()?;
let parameter_slots = pending
.arguments
.as_slice()
.len()
.max(PPC_NATIVE_PARAMETER_GPR_COUNT);
let parameter_bytes = u32::try_from(parameter_slots).ok()?.checked_mul(4)?;
let required = PPC_PARAMETER_AREA_OFFSET.checked_add(parameter_bytes)?;
let frame_size = required.max(PPC_INITIAL_STACK_FRAME_SIZE).checked_add(15)? & !15;
let caller_sp = self.cpu.gpr[1];
let callback_sp = caller_sp.checked_sub(frame_size)? & !15;
// PowerPC System Software, 1-44–1-49: linkage and parameter areas
// belong to the caller's grow-down stack, including worker stacks.
let (stack_base, stack_limit) = self.toolbox_startup.execution.calls().native_stack_bounds(
self.stack_base,
self.stack_base.checked_add(self.stack_size)?,
)?;
if callback_sp < stack_base
|| caller_sp > stack_limit
|| !ppc_memory_can_write_bytes(&mut self.memory, callback_sp, frame_size)
|| !ppc_zero_guest_bytes(&mut self.memory, callback_sp, frame_size)
{
return None;
}
self.memory
.write_u32_be(callback_sp + PPC_LINKAGE_BACK_CHAIN_OFFSET, caller_sp)?;
self.memory
.write_u32_be(callback_sp + PPC_LINKAGE_SAVED_CR_OFFSET, self.cpu.cr)?;
self.memory
.write_u32_be(callback_sp + PPC_LINKAGE_SAVED_LR_OFFSET, self.cpu.lr)?;
self.memory
.write_u32_be(callback_sp + PPC_LINKAGE_SAVED_RTOC_OFFSET, self.cpu.gpr[2])?;
let pending = self.toolbox_startup.execution.calls().activate_powerpc_with_classic_caller(
&mut self.cpu,
caller,
PPC_GUEST_CALL_RETURN_PC,
)?;
self.cpu.gpr[1] = callback_sp;
self.cpu.pc = pending.target.entry;
self.cpu.lr = PPC_GUEST_CALL_RETURN_PC;
self.cpu.gpr[2] = pending.target.rtoc;
install_powerpc_call_arguments(
&mut self.cpu,
&mut self.memory,
pending.arguments.as_slice(),
)
}
/// Copy the live PowerPC Menu Manager list into the same frontend-neutral
/// model used by the 68k Toolbox implementation.
pub fn guest_menu_snapshot(&mut self) -> GuestMenuSnapshot {
let menu_list = ppc_current_menu_list(&mut self.memory);
ppc_guest_menu_snapshot(&mut self.memory, menu_list)
}
/// Validate and stage a command selected through a host-native menu.
pub fn queue_native_menu_selection(&mut self, menu_id: i16, item_number: i16) -> bool {
let menu_list = ppc_current_menu_list(&mut self.memory);
if ppc_menu_selection_result(&mut self.memory, menu_list, menu_id, item_number).is_none() {
return false;
}
self.toolbox_startup
.pending_native_menu_selection
.stage((menu_id, item_number));
true
}
pub fn set_tick_count(&mut self, tick_count: u32) {
// This explicit setter is a guest-memory operation for detached
// loader/test setup. Production execution reads `$016A` directly;
// no adapter scalar is projected back into guest memory implicitly.
self.tick_state.set_tick(tick_count);
let _ = self
.memory
.write_u32_be(crate::memory::globals::addr::TICKS, tick_count);
self.callback_scheduling.with_mut(|scheduling| {
scheduling.current_subtick = scheduling
.current_subtick
.max(u64::from(tick_count) * 1_000_000);
});
}
pub(crate) fn current_tick(&mut self) -> u32 {
let guest_ticks = self
.memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.unwrap_or_else(|| self.tick_state.current_tick());
self.tick_state.read_tick_count(guest_ticks);
guest_ticks
}
pub(crate) fn publish_tick(&mut self, candidate: u32) -> u32 {
// A guest store may have happened during the native slice. Import it
// before applying the host's next VBL candidate. Only the current
// value or its single next host VBL are valid candidates: a caller's
// pre-slice value may be arbitrarily stale after a direct guest store,
// and SharedProcessTickState's wrapping "newer" comparison alone
// cannot distinguish that stale value from legitimate forward time.
let guest_ticks = self.current_tick();
let tick = if candidate == guest_ticks || candidate == guest_ticks.wrapping_add(1) {
self.tick_state.publish_tick(candidate)
} else {
guest_ticks
};
let _ = self
.memory
.write_u32_be(crate::memory::globals::addr::TICKS, tick);
tick
}
/// Apply one tick from a host cycle epoch that has already been charged by
/// the runner. Unlike [`Self::publish_tick`], this is an explicit replay
/// operation: the runner owns the trusted baseline and elapsed-VBL count,
/// so intermediate ticks must be visible to callbacks even though the
/// guest bytes were advanced to the epoch's final tick before replay.
pub(crate) fn publish_host_epoch_tick(&mut self, tick: u32) -> u32 {
self.tick_state.set_tick(tick);
let _ = self
.memory
.write_u32_be(crate::memory::globals::addr::TICKS, tick);
tick
}
pub fn set_clock_cycle_timing(&mut self, cycles_per_tick: u32, cycle_phase: u32) {
self.clock_cycles_per_tick = cycles_per_tick.max(1);
self.clock_cycle_phase = cycle_phase.min(self.clock_cycles_per_tick.saturating_sub(1));
}
pub fn current_front_buffer(&self) -> Option<PpcFrontBuffer> {
ppc_front_buffer_for_gworld(&self.gworlds, *self.current_gworld)
}
pub fn presented_front_buffer(&self) -> Option<PpcFrontBuffer> {
if self.draw_sprocket.active_context.is_some() || self.draw_sprocket.swap_count > 0 {
ppc_front_buffer_for_gworld(&self.gworlds, self.draw_sprocket.front_buffer_gworld)
.or_else(|| ppc_front_buffer_for_gworld(&self.gworlds, PPC_MAIN_GWORLD))
} else {
ppc_front_buffer_for_gworld(&self.gworlds, PPC_MAIN_GWORLD)
}
}
/// Number of live Window Manager records, excluding screen and offscreen
/// graphics worlds.
pub fn window_count(&mut self) -> usize {
self.gworlds
.iter()
.filter(|record| {
!matches!(record.port, PPC_MAIN_GWORLD | PPC_DSP_BACK_GWORLD)
&& self
.memory
.read_u16_be(record.port.wrapping_add(PPC_CWINDOW_WINDOW_KIND_OFFSET))
.is_some_and(|kind| kind != 0)
})
.count()
}
/// Global content bounds of the frontmost visible Window Manager record.
pub fn window_bounds(&mut self) -> (i16, i16, i16, i16) {
ppc_front_visible_window(&mut self.memory, &self.gworlds)
.and_then(|window| {
ppc_window_global_content_bounds(&mut self.memory, &self.gworlds, window)
})
.unwrap_or((0, 0, 0, 0))
}
fn q3_render_target(&mut self, commands: &[PpcQ3SceneCommand]) -> Option<PpcQ3RenderTarget> {
commands
.iter()
.filter_map(|command| match command {
PpcQ3SceneCommand::TriMesh(command) => Some(command.view_state.draw_context),
PpcQ3SceneCommand::Submission(command) => Some(command.view_state.draw_context),
})
.filter(|draw_context| *draw_context != 0)
.find_map(|draw_context| self.q3_draw_context_render_target(draw_context))
.or_else(|| {
self.current_front_buffer()
.map(|front_buffer| PpcQ3RenderTarget {
front_buffer,
viewport: None,
clear_color: None,
source: PpcQ3RenderTargetSource::CurrentGWorld,
draw_context: None,
gworld: Some(*self.current_gworld),
})
})
}
#[cfg(test)]
fn q3_draw_context_front_buffer(&mut self, draw_context: u32) -> Option<PpcFrontBuffer> {
self.q3_draw_context_render_target(draw_context)
.map(|target| target.front_buffer)
}
fn q3_draw_context_render_target(&mut self, draw_context: u32) -> Option<PpcQ3RenderTarget> {
ppc_q3_live_draw_context_render_target(
&mut self.memory,
&self.q3_objects,
&self.q3_draw_contexts,
&self.gworlds,
draw_context,
)
}
pub fn read_front_buffer_row(
&mut self,
front_buffer: PpcFrontBuffer,
row: u32,
dst: &mut [u8],
) -> Option<()> {
if row >= front_buffer.height || dst.len() < front_buffer.row_bytes as usize {
return None;
}
let row_addr = front_buffer
.base_addr
.checked_add(row.checked_mul(front_buffer.row_bytes)?)?;
self.memory
.read_bytes_into(row_addr, &mut dst[..front_buffer.row_bytes as usize])?;
Some(())
}
pub fn q3_scene_commands(&mut self) -> Vec<PpcQ3SceneCommand> {
let submissions = self.q3_submissions.clone();
self.q3_scene_commands_from_slices(
&submissions,
&self.q3_submission_transforms.clone(),
&self.q3_submission_materials.clone(),
&self.q3_submission_lights.clone(),
&[],
)
}
fn q3_scene_commands_from_slices(
&mut self,
submissions: &[PpcQ3SubmissionRecord],
transforms: &[PpcQ3SubmissionTransformRecord],
materials: &[PpcQ3SubmissionMaterialRecord],
lights: &[PpcQ3SubmissionLightRecord],
retained_trimeshes: &[PpcQ3TriMeshRecord],
) -> Vec<PpcQ3SceneCommand> {
submissions
.iter()
.enumerate()
.filter_map(|(index, submission)| {
self.q3_scene_command_from_slices(
index,
submission,
transforms,
materials,
lights,
retained_trimeshes,
)
})
.collect()
}
pub fn capture_q3_scene_replay(
&mut self,
commands: Vec<PpcQ3SceneCommand>,
) -> PpcQ3SceneReplay {
let mut memory_regions = Vec::new();
for command in &commands {
match command {
PpcQ3SceneCommand::TriMesh(command) => {
self.capture_q3_trimesh_replay_memory(&mut memory_regions, command);
self.capture_q3_material_replay_memory(&mut memory_regions, &command.material);
}
PpcQ3SceneCommand::Submission(command) => {
self.capture_q3_material_replay_memory(&mut memory_regions, &command.material);
}
}
}
PpcQ3SceneReplay {
commands,
memory_regions,
}
}
pub fn render_q3_scene_commands_to_front_buffer(&mut self) -> PpcQ3SoftwareRenderStats {
let commands = self.q3_scene_commands();
self.render_q3_scene_commands_to_front_buffer_inner(commands)
}
/// Render a captured QD3D scene-command stream without reading the live
/// QD3D submission queues. The replay still uses this app's memory and
/// current render-target state for guest-buffer-backed geometry/texture data.
pub fn replay_q3_scene_commands_to_front_buffer(
&mut self,
commands: Vec<PpcQ3SceneCommand>,
) -> PpcQ3SoftwareRenderStats {
self.render_q3_scene_commands_to_front_buffer_inner(commands)
}
pub fn replay_q3_scene_replay_to_front_buffer(
&mut self,
replay: &PpcQ3SceneReplay,
) -> PpcQ3SoftwareRenderStats {
for region in &replay.memory_regions {
self.install_q3_scene_replay_memory_region(region);
}
self.replay_q3_scene_commands_to_front_buffer(replay.commands.clone())
}
pub fn render_completed_q3_frames_to_front_buffer(&mut self) -> PpcQ3SoftwareRenderStats {
self.render_completed_q3_frames_to_front_buffer_fast()
}
pub fn render_completed_q3_frames_to_front_buffer_fast(&mut self) -> PpcQ3SoftwareRenderStats {
let state_only_batches = std::mem::take(&mut self.q3_state_only_completed_frame_batches);
let frames = std::mem::take(&mut self.q3_completed_frames);
let mut stats = PpcQ3SoftwareRenderStats::default();
stats.add_state_only_batches(&state_only_batches);
let mut saw_missing_target = false;
let last_trimesh_frame = frames.iter().rposition(|frame| {
frame
.submissions
.iter()
.any(|submission| submission.kind == PpcQ3SubmissionKind::TriMesh)
});
for (frame_index, frame) in frames.into_iter().enumerate() {
if frame.submissions.is_empty() {
continue;
}
if !frame
.submissions
.iter()
.any(|submission| submission.kind == PpcQ3SubmissionKind::TriMesh)
|| Some(frame_index) != last_trimesh_frame
{
if let Some(target) = self.q3_completed_frame_render_target(&frame) {
stats.record_target(target);
}
stats.add_empty_frames(1);
continue;
}
let commands = self.q3_completed_frame_scene_commands(&frame);
let frame_stats = self.render_q3_scene_commands_to_front_buffer_inner(commands);
stats.merge_frame_stats(frame_stats, &mut saw_missing_target);
}
stats
}
pub fn render_completed_q3_frames_to_front_buffer_with_observer<F>(
&mut self,
mut observer: F,
) -> PpcQ3SoftwareRenderStats
where
F: FnMut(&PpcQ3CompletedFrameRecord, &PpcQ3SceneReplay),
{
let state_only_batches = std::mem::take(&mut self.q3_state_only_completed_frame_batches);
let frames = std::mem::take(&mut self.q3_completed_frames);
let mut stats = PpcQ3SoftwareRenderStats::default();
stats.add_state_only_batches(&state_only_batches);
let mut saw_missing_target = false;
for frame in frames {
if frame.submissions.is_empty() {
continue;
}
let commands = self.q3_completed_frame_scene_commands(&frame);
let replay = self.capture_q3_scene_replay(commands);
observer(&frame, &replay);
let frame_stats = self.replay_q3_scene_replay_to_front_buffer(&replay);
stats.merge_frame_stats(frame_stats, &mut saw_missing_target);
}
stats
}
/// Drain the newest completed triangle frame as GPU-ready primitives.
/// Unsupported QD3D state leaves the queue untouched so callers can use
/// `render_completed_q3_frames_to_front_buffer_fast` as an exact fallback.
pub fn take_completed_q3_gpu_frame(&mut self) -> Option<PpcQ3GpuFrame> {
let frame = self
.q3_completed_frames
.iter()
.rfind(|frame| {
frame
.submissions
.iter()
.any(|submission| submission.kind == PpcQ3SubmissionKind::TriMesh)
})?
.clone();
let commands = self.q3_completed_frame_scene_commands(&frame);
let gpu_frame = self.prepare_q3_gpu_frame(commands)?;
self.q3_completed_frames.clear();
self.q3_state_only_completed_frame_batches.clear();
Some(gpu_frame)
}
fn prepare_q3_gpu_frame(&mut self, commands: Vec<PpcQ3SceneCommand>) -> Option<PpcQ3GpuFrame> {
let target = self.q3_render_target(&commands)?;
let front_buffer = target.front_buffer;
if front_buffer.depth != 16 || front_buffer.width == 0 || front_buffer.height == 0 {
return None;
}
let viewport = target
.viewport
.unwrap_or_else(|| PpcQ3ViewportRect::full(front_buffer));
let viewport_bounds = viewport.inclusive_bounds()?;
let mut textures = Vec::new();
let mut draws = Vec::new();
for command in commands {
let PpcQ3SceneCommand::TriMesh(command) = command else {
continue;
};
if ppc_q3_software_fill_style(&command.material) != PPC_Q3_FILL_STYLE_FILLED {
return None;
}
let material = ppc_q3_software_material_sample(
&self.q3_objects,
&self.q3_memory_storages,
&command.material,
);
if material.fog_style.is_some()
|| command
.lights
.lights
.iter()
.any(|light| light.data.is_on != 0)
{
return None;
}
let transparency = material.transparency;
if (transparency.0 - transparency.1).abs() > 0.001
|| (transparency.0 - transparency.2).abs() > 0.001
{
return None;
}
let points = self.q3_software_trimesh_points(&command)?;
let triangles = self.q3_software_trimesh_triangles(&command, points.len());
if points.is_empty() || triangles.is_empty() {
continue;
}
let vertex_uvs = if material.texture.is_some() {
self.q3_software_trimesh_vertex_uvs(&command, points.len())?
} else {
vec![(0.0, 0.0); points.len()]
};
let vertex_diffuse =
self.q3_software_trimesh_vertex_diffuse_colors(&command, points.len());
let vertex_alpha = self.q3_software_trimesh_vertex_alphas(&command, points.len());
let triangle_diffuse = self.q3_software_trimesh_triangle_diffuse_colors(&command);
let triangle_alpha = self.q3_software_trimesh_triangle_alphas(&command);
let mut projected = points
.iter()
.copied()
.map(|point| ppc_q3_software_project_point(&command, front_buffer, viewport, point))
.collect::<Vec<_>>();
for (index, projected) in projected.iter_mut().enumerate() {
let Some(projected) = projected else {
continue;
};
projected.uv = vertex_uvs.get(index).copied();
projected.diffuse = vertex_diffuse
.as_ref()
.and_then(|colors| colors.get(index).copied());
projected.vertex_alpha = vertex_alpha
.as_ref()
.and_then(|alphas| alphas.get(index).copied());
}
let texture_index = match material.texture {
Some(texture) => {
let texture = ppc_q3_gpu_texture_from_software(
&mut self.memory,
texture,
material.shader_boundary,
)?;
let index = textures.len();
textures.push(texture);
Some(index)
}
None => None,
};
let interpolation_style = ppc_q3_software_interpolation_style(&command.material);
let backfacing_style = ppc_q3_software_backfacing_style(&command.material);
let orientation_style = ppc_q3_software_orientation_style(&command.material);
let mut vertices = Vec::with_capacity(triangles.len().saturating_mul(3));
let mut blend =
transparency.0 < 0.999 || ppc_q3_software_texture_may_blend(material.texture);
for triangle in triangles {
let mut triangle_vertices = [
projected.get(triangle.points[0]).copied().flatten()?,
projected.get(triangle.points[1]).copied().flatten()?,
projected.get(triangle.points[2]).copied().flatten()?,
];
if let Some(diffuse) = triangle_diffuse
.as_ref()
.and_then(|colors| colors.get(triangle.index).copied())
{
for vertex in &mut triangle_vertices {
if vertex.diffuse.is_none() {
vertex.diffuse = Some(diffuse);
}
}
}
if let Some(alpha) = triangle_alpha
.as_ref()
.and_then(|alphas| alphas.get(triangle.index).copied())
{
for vertex in &mut triangle_vertices {
if vertex.vertex_alpha.is_none() {
vertex.vertex_alpha = Some(alpha);
}
}
}
let clipped = ppc_q3_software_clip_projected_triangle(
command.camera,
front_buffer,
viewport,
triangle_vertices,
);
if clipped.len() < 3 {
continue;
}
let mut clipped = clipped
.into_iter()
.map(ppc_q3_software_projected_vertex_to_point)
.collect::<Vec<_>>();
if ppc_q3_software_culls_backfacing(backfacing_style, orientation_style, &clipped) {
continue;
}
ppc_q3_software_flip_backfacing_normals(
backfacing_style,
orientation_style,
&mut clipped,
);
let flat_diffuse = (interpolation_style == PPC_Q3_INTERPOLATION_STYLE_NONE)
.then(|| clipped.first().and_then(|vertex| vertex.diffuse))
.flatten();
let flat_alpha = (interpolation_style == PPC_Q3_INTERPOLATION_STYLE_NONE)
.then(|| clipped.first().and_then(|vertex| vertex.vertex_alpha))
.flatten();
for index in 1..clipped.len().saturating_sub(1) {
for point in [clipped[0], clipped[index], clipped[index + 1]] {
let diffuse = flat_diffuse.or(point.diffuse).unwrap_or(material.diffuse);
let vertex_alpha = flat_alpha.or(point.vertex_alpha).unwrap_or(1.0);
if vertex_alpha < 0.999 {
blend = true;
}
let uv = ppc_q3_software_transform_uv(
point.uv.unwrap_or((0.0, 0.0)),
material.uv_transform,
)?;
vertices.push(PpcQ3GpuVertex {
screen_x: point.x as f32,
screen_y: point.y as f32,
depth: point.z,
reciprocal_w: point.reciprocal_w,
uv: [uv.0, uv.1],
color: [
diffuse.0,
diffuse.1,
diffuse.2,
transparency.0 * vertex_alpha,
],
});
}
}
}
if !vertices.is_empty() {
draws.push(PpcQ3GpuDraw {
texture: texture_index,
vertices,
blend,
write_depth: !blend,
});
}
}
if draws.is_empty() {
return None;
}
Some(PpcQ3GpuFrame {
width: front_buffer.width,
height: front_buffer.height,
viewport: [
viewport_bounds.0,
viewport_bounds.1,
viewport_bounds.2,
viewport_bounds.3,
],
clear_color: target.clear_color.map(|color| {
let (red, green, blue) = ppc_q3_rgb555_to_color(color);
[red, green, blue, 1.0]
}),
textures,
draws,
})
}
fn render_q3_scene_commands_to_front_buffer_inner(
&mut self,
commands: Vec<PpcQ3SceneCommand>,
) -> PpcQ3SoftwareRenderStats {
let Some(target) = self.q3_render_target(&commands) else {
return PpcQ3SoftwareRenderStats::default();
};
let front_buffer = target.front_buffer;
let viewport = target
.viewport
.unwrap_or_else(|| PpcQ3ViewportRect::full(front_buffer));
if !matches!(front_buffer.depth, 8 | 16)
|| front_buffer.width == 0
|| front_buffer.height == 0
{
return PpcQ3SoftwareRenderStats::default();
}
let mut stats = PpcQ3SoftwareRenderStats::default();
stats.record_target(target);
let indexed_clut = (front_buffer.depth == 8).then(|| {
target
.gworld
.map(|gworld| {
ppc_live_gworld_clut(
&mut self.memory,
&self.gworlds,
gworld,
&self.screen_clut,
&self.color_manager_clut,
)
})
.unwrap_or(*self.color_manager_clut)
});
let surface =
PpcQ3SoftwareFrontBufferSurface::new(&mut self.memory, front_buffer, indexed_clut);
let mut depth_buffer = PpcQ3SoftwareDepthBuffer::new(front_buffer);
if let (Some(clear_color), Some((left, top, right, bottom))) =
(target.clear_color, viewport.inclusive_bounds())
{
for y in top..=bottom {
for x in left..=right {
let _ = surface.write_pixel(&mut self.memory, (x, y), clear_color);
}
}
}
let mut deferred_primitives = Vec::new();
for command in commands {
let command = match command {
PpcQ3SceneCommand::TriMesh(command) => command,
PpcQ3SceneCommand::Submission(_) => continue,
};
let Some(points) = self.q3_software_trimesh_points(&command) else {
continue;
};
if points.is_empty() {
continue;
}
let material = ppc_q3_software_material_sample(
&self.q3_objects,
&self.q3_memory_storages,
&command.material,
);
let uses_ambient_coefficients =
ppc_q3_software_uses_ambient_coefficients(&material, &command.lights);
let uses_normals = ppc_q3_software_uses_normals(&material, &command.lights);
let uses_specular_attributes =
ppc_q3_software_uses_specular_attributes(&material, &command.lights);
let vertex_uvs = if material.texture.is_some() {
self.q3_software_trimesh_vertex_uvs(&command, points.len())
} else {
None
};
let vertex_diffuse_colors =
self.q3_software_trimesh_vertex_diffuse_colors(&command, points.len());
let vertex_ambient_coefficients = if uses_ambient_coefficients {
self.q3_software_trimesh_vertex_ambient_coefficients(&command, points.len())
} else {
None
};
let vertex_specular_colors = if uses_specular_attributes {
self.q3_software_trimesh_vertex_specular_colors(&command, points.len())
} else {
None
};
let vertex_specular_controls = if uses_specular_attributes {
self.q3_software_trimesh_vertex_specular_controls(&command, points.len())
} else {
None
};
let vertex_highlight_states = if uses_specular_attributes {
self.q3_software_trimesh_vertex_highlight_states(&command, points.len())
} else {
None
};
let vertex_normals = if uses_normals {
self.q3_software_trimesh_vertex_normals(&command, points.len())
} else {
None
};
let mut projected: Vec<Option<PpcQ3SoftwareProjectedVertex>> = points
.iter()
.copied()
.map(|point| ppc_q3_software_project_point(&command, front_buffer, viewport, point))
.collect();
if let Some(vertex_uvs) = vertex_uvs {
for (projected, uv) in projected.iter_mut().zip(vertex_uvs) {
if let Some(projected) = projected {
projected.uv = Some(uv);
}
}
}
if let Some(vertex_diffuse_colors) = vertex_diffuse_colors {
for (projected, diffuse) in projected.iter_mut().zip(vertex_diffuse_colors) {
if let Some(projected) = projected {
projected.diffuse = Some(diffuse);
}
}
}
if let Some(vertex_ambient_coefficients) = vertex_ambient_coefficients {
for (projected, ambient_coefficient) in
projected.iter_mut().zip(vertex_ambient_coefficients)
{
if let Some(projected) = projected {
projected.ambient_coefficient = Some(ambient_coefficient);
}
}
}
if let Some(vertex_specular_colors) = vertex_specular_colors {
for (projected, specular_color) in projected.iter_mut().zip(vertex_specular_colors)
{
if let Some(projected) = projected {
projected.specular_color = Some(specular_color);
}
}
}
if let Some(vertex_specular_controls) = vertex_specular_controls {
for (projected, specular_control) in
projected.iter_mut().zip(vertex_specular_controls)
{
if let Some(projected) = projected {
projected.specular_control = Some(specular_control);
}
}
}
if let Some(vertex_highlight_states) = vertex_highlight_states {
for (projected, highlight_state) in
projected.iter_mut().zip(vertex_highlight_states)
{
if let Some(projected) = projected {
projected.highlight_state = Some(highlight_state);
}
}
}
if let Some(vertex_normals) = vertex_normals {
for (projected, normal) in projected.iter_mut().zip(vertex_normals) {
if let Some(projected) = projected {
projected.normal =
ppc_q3_software_transform_normal(normal, command.local_to_world);
}
}
}
if let Some(vertex_alphas) =
self.q3_software_trimesh_vertex_alphas(&command, points.len())
{
for (projected, alpha) in projected.iter_mut().zip(vertex_alphas) {
if let Some(projected) = projected {
projected.vertex_alpha = Some(alpha);
}
}
}
let triangles = self.q3_software_trimesh_triangles(&command, points.len());
let depth_clip = command.camera.is_some();
let backfacing_style = ppc_q3_software_backfacing_style(&command.material);
let orientation_style = ppc_q3_software_orientation_style(&command.material);
let interpolation_style = ppc_q3_software_interpolation_style(&command.material);
let fill_style = ppc_q3_software_fill_style(&command.material);
stats.commands = stats.commands.saturating_add(1);
stats.vertices = stats.vertices.saturating_add(points.len());
if triangles.is_empty() {
for vertex in projected.into_iter().flatten() {
if !ppc_q3_software_projected_vertex_depth_visible(depth_clip, vertex) {
continue;
}
let point = ppc_q3_software_projected_vertex_to_point(vertex);
if ppc_q3_software_primitive_deferred_for_transparency(&material, &[point]) {
deferred_primitives.push(PpcQ3SoftwareDeferredPrimitive::Point {
point,
material,
lights: command.lights.clone(),
sort_depth: point.z,
});
} else if ppc_q3_write_software_depth_material_pixel(
&mut self.memory,
surface,
&mut depth_buffer,
point,
&material,
&command.lights,
) {
stats.pixels = stats.pixels.saturating_add(1);
}
}
} else {
let triangle_diffuse_colors =
self.q3_software_trimesh_triangle_diffuse_colors(&command);
let triangle_ambient_coefficients = if uses_ambient_coefficients {
self.q3_software_trimesh_triangle_ambient_coefficients(&command)
} else {
None
};
let triangle_specular_colors = if uses_specular_attributes {
self.q3_software_trimesh_triangle_specular_colors(&command)
} else {
None
};
let triangle_specular_controls = if uses_specular_attributes {
self.q3_software_trimesh_triangle_specular_controls(&command)
} else {
None
};
let triangle_highlight_states = if uses_specular_attributes {
self.q3_software_trimesh_triangle_highlight_states(&command)
} else {
None
};
let triangle_normals = if uses_normals {
self.q3_software_trimesh_triangle_normals(&command)
} else {
None
};
let triangle_alphas = self.q3_software_trimesh_triangle_alphas(&command);
let edge_data = if fill_style == PPC_Q3_FILL_STYLE_EDGES {
let edges = self.q3_software_trimesh_edges(&command, points.len());
let edge_indices = ppc_q3_software_edge_index_map(&edges);
Some((
edge_indices,
self.q3_software_trimesh_edge_diffuse_colors(&command),
if uses_ambient_coefficients {
self.q3_software_trimesh_edge_ambient_coefficients(&command)
} else {
None
},
if uses_specular_attributes {
self.q3_software_trimesh_edge_specular_colors(&command)
} else {
None
},
if uses_specular_attributes {
self.q3_software_trimesh_edge_specular_controls(&command)
} else {
None
},
if uses_specular_attributes {
self.q3_software_trimesh_edge_highlight_states(&command)
} else {
None
},
if uses_normals {
self.q3_software_trimesh_edge_normals(&command)
.and_then(|normals| {
normals
.into_iter()
.map(|normal| {
ppc_q3_software_transform_normal(
normal,
command.local_to_world,
)
})
.collect::<Option<Vec<_>>>()
})
} else {
None
},
self.q3_software_trimesh_edge_alphas(&command),
))
} else {
None
};
for triangle in triangles {
let Some(a) = projected.get(triangle.points[0]).copied().flatten() else {
continue;
};
let Some(b) = projected.get(triangle.points[1]).copied().flatten() else {
continue;
};
let Some(c) = projected.get(triangle.points[2]).copied().flatten() else {
continue;
};
let mut vertices = [a, b, c];
if let Some(diffuse) = triangle_diffuse_colors
.as_ref()
.and_then(|colors| colors.get(triangle.index).copied())
{
for vertex in &mut vertices {
if vertex.diffuse.is_none() {
vertex.diffuse = Some(diffuse);
}
}
}
if let Some(alpha) = triangle_alphas
.as_ref()
.and_then(|alphas| alphas.get(triangle.index).copied())
{
for vertex in &mut vertices {
if vertex.vertex_alpha.is_none() {
vertex.vertex_alpha = Some(alpha);
}
}
}
if let Some(ambient_coefficient) = triangle_ambient_coefficients
.as_ref()
.and_then(|coefficients| coefficients.get(triangle.index).copied())
{
for vertex in &mut vertices {
if vertex.ambient_coefficient.is_none() {
vertex.ambient_coefficient = Some(ambient_coefficient);
}
}
}
if let Some(normal) = triangle_normals
.as_ref()
.and_then(|normals| normals.get(triangle.index).copied())
.and_then(|normal| {
ppc_q3_software_transform_normal(normal, command.local_to_world)
})
{
for vertex in &mut vertices {
if vertex.normal.is_none() {
vertex.normal = Some(normal);
}
}
}
if let Some(specular_color) = triangle_specular_colors
.as_ref()
.and_then(|colors| colors.get(triangle.index).copied())
{
for vertex in &mut vertices {
if vertex.specular_color.is_none() {
vertex.specular_color = Some(specular_color);
}
}
}
if let Some(specular_control) = triangle_specular_controls
.as_ref()
.and_then(|controls| controls.get(triangle.index).copied())
{
for vertex in &mut vertices {
if vertex.specular_control.is_none() {
vertex.specular_control = Some(specular_control);
}
}
}
if let Some(highlight_state) = triangle_highlight_states
.as_ref()
.and_then(|states| states.get(triangle.index).copied())
{
for vertex in &mut vertices {
if vertex.highlight_state.is_none() {
vertex.highlight_state = Some(highlight_state);
}
}
}
if uses_normals && vertices.iter().any(|vertex| vertex.normal.is_none()) {
// An unannotated TriMesh still has a geometric surface normal.
// Generate it in object space so it follows the same orientation
// and inverse-transpose transform as explicit normal attributes.
let normal = ppc_q3_software_geometric_normal(
triangle.points.map(|index| points[index]),
ppc_q3_software_orientation_style(&command.material),
)
.and_then(|normal| {
ppc_q3_software_transform_normal(normal, command.local_to_world)
});
for vertex in &mut vertices {
if vertex.normal.is_none() {
vertex.normal = normal;
}
}
}
let clipped = ppc_q3_software_clip_projected_triangle(
command.camera,
front_buffer,
viewport,
vertices,
);
if clipped.len() < 3 {
continue;
}
let mut clipped_points: Vec<PpcQ3SoftwareProjectedPoint> = clipped
.iter()
.copied()
.map(ppc_q3_software_projected_vertex_to_point)
.collect();
if ppc_q3_software_culls_backfacing(
backfacing_style,
orientation_style,
&clipped_points,
) {
continue;
}
ppc_q3_software_flip_backfacing_normals(
backfacing_style,
orientation_style,
&mut clipped_points,
);
match fill_style {
PPC_Q3_FILL_STYLE_POINTS => {
for point in clipped_points {
if ppc_q3_software_primitive_deferred_for_transparency(
&material,
&[point],
) {
deferred_primitives.push(
PpcQ3SoftwareDeferredPrimitive::Point {
point,
material,
lights: command.lights.clone(),
sort_depth: point.z,
},
);
} else if ppc_q3_write_software_depth_material_pixel(
&mut self.memory,
surface,
&mut depth_buffer,
point,
&material,
&command.lights,
) {
stats.pixels = stats.pixels.saturating_add(1);
}
}
}
PPC_Q3_FILL_STYLE_EDGES => {
let Some((
edge_indices,
edge_diffuse_colors,
edge_ambient_coefficients,
edge_specular_colors,
edge_specular_controls,
edge_highlight_states,
edge_normals,
edge_alphas,
)) = edge_data.as_ref()
else {
continue;
};
let edge_materials = ppc_q3_software_triangle_edge_materials(
edge_indices,
edge_diffuse_colors.as_deref(),
edge_ambient_coefficients.as_deref(),
edge_specular_colors.as_deref(),
edge_specular_controls.as_deref(),
edge_highlight_states.as_deref(),
edge_normals.as_deref(),
edge_alphas.as_deref(),
triangle.points,
);
stats.pixels = stats.pixels.saturating_add(
ppc_q3_draw_or_defer_software_edge_loop(
&mut self.memory,
surface,
&clipped_points,
&material,
&command.lights,
&edge_materials,
&mut deferred_primitives,
),
);
}
_ => {
for index in 1..clipped_points.len().saturating_sub(1) {
let fan_vertices = [
clipped_points[0],
clipped_points[index],
clipped_points[index + 1],
];
if ppc_q3_software_primitive_deferred_for_transparency(
&material,
&fan_vertices,
) {
deferred_primitives.push(
PpcQ3SoftwareDeferredPrimitive::Triangle {
vertices: fan_vertices,
material,
lights: command.lights.clone(),
interpolation_style,
sort_depth: ppc_q3_software_triangle_sort_depth(
fan_vertices,
),
},
);
} else {
stats.pixels =
stats.pixels.saturating_add(ppc_q3_draw_software_triangle(
&mut self.memory,
surface,
&mut depth_buffer,
fan_vertices,
&material,
&command.lights,
interpolation_style,
viewport,
true,
));
}
}
}
}
stats.triangles = stats.triangles.saturating_add(1);
}
}
}
deferred_primitives.sort_by(|a, b| {
b.sort_depth()
.partial_cmp(&a.sort_depth())
.unwrap_or(std::cmp::Ordering::Equal)
});
for primitive in deferred_primitives {
stats.pixels = stats.pixels.saturating_add(match primitive {
PpcQ3SoftwareDeferredPrimitive::Triangle {
vertices,
material,
lights,
interpolation_style,
..
} => ppc_q3_draw_software_triangle(
&mut self.memory,
surface,
&mut depth_buffer,
vertices,
&material,
&lights,
interpolation_style,
viewport,
false,
),
PpcQ3SoftwareDeferredPrimitive::Point {
point,
material,
lights,
..
} => usize::from(ppc_q3_draw_deferred_software_point(
&mut self.memory,
surface,
&mut depth_buffer,
point,
&material,
&lights,
)),
PpcQ3SoftwareDeferredPrimitive::Edge {
start,
end,
material,
lights,
..
} => ppc_q3_draw_deferred_software_material_line(
&mut self.memory,
surface,
&depth_buffer,
start,
end,
&material,
&lights,
),
});
}
stats
}
fn q3_completed_frame_scene_commands(
&mut self,
frame: &PpcQ3CompletedFrameRecord,
) -> Vec<PpcQ3SceneCommand> {
self.q3_scene_commands_from_slices(
&frame.submissions,
&frame.submission_transforms,
&frame.submission_materials,
&frame.submission_lights,
&frame.retained_trimeshes,
)
}
fn q3_completed_frame_render_target(
&self,
frame: &PpcQ3CompletedFrameRecord,
) -> Option<PpcQ3RenderTarget> {
ppc_q3_completed_frame_render_target(
&self.q3_objects,
&self.q3_views,
&self.q3_draw_contexts,
&self.gworlds,
*self.current_gworld,
frame,
)
}
fn q3_scene_command_from_slices(
&mut self,
index: usize,
submission: &PpcQ3SubmissionRecord,
transforms: &[PpcQ3SubmissionTransformRecord],
materials: &[PpcQ3SubmissionMaterialRecord],
lights: &[PpcQ3SubmissionLightRecord],
retained_trimeshes: &[PpcQ3TriMeshRecord],
) -> Option<PpcQ3SceneCommand> {
let view_state = self
.q3_views
.iter()
.find(|record| record.view == submission.view)
.copied()?;
let transform = Self::q3_submission_transform_from_slice(transforms, index, submission)?;
let material = Self::q3_submission_material_from_slice(materials, index, submission)?;
let lights = Self::q3_submission_lights_from_slice(lights, index, submission)?;
match submission.kind {
PpcQ3SubmissionKind::TriMesh => {
let geometry =
self.q3_scene_trimesh_geometry(submission.primary, retained_trimeshes)?;
let camera = if view_state.camera == 0 {
None
} else {
self.q3_cameras
.iter()
.find(|record| record.camera == view_state.camera)
.copied()
};
Some(PpcQ3SceneCommand::TriMesh(PpcQ3SceneTriMeshCommand {
submission_index: index,
view_state,
camera,
geometry,
local_to_world: transform.local_to_world,
material,
lights,
}))
}
_ => Some(PpcQ3SceneCommand::Submission(PpcQ3SceneSubmissionCommand {
submission_index: index,
view_state,
submission: *submission,
local_to_world: transform.local_to_world,
material,
lights,
})),
}
}
fn q3_submission_transform_from_slice(
transforms: &[PpcQ3SubmissionTransformRecord],
index: usize,
submission: &PpcQ3SubmissionRecord,
) -> Option<PpcQ3SubmissionTransformRecord> {
transforms
.get(index)
.filter(|record| ppc_q3_submission_transform_matches(record, submission))
.copied()
.or_else(|| {
transforms
.iter()
.find(|record| ppc_q3_submission_transform_matches(record, submission))
.copied()
})
}
fn q3_submission_material_from_slice(
materials: &[PpcQ3SubmissionMaterialRecord],
index: usize,
submission: &PpcQ3SubmissionRecord,
) -> Option<PpcQ3SubmissionMaterialRecord> {
materials
.get(index)
.filter(|record| ppc_q3_submission_material_matches(record, submission))
.cloned()
.or_else(|| {
materials
.iter()
.find(|record| ppc_q3_submission_material_matches(record, submission))
.cloned()
})
}
fn q3_submission_lights_from_slice(
lights: &[PpcQ3SubmissionLightRecord],
index: usize,
submission: &PpcQ3SubmissionRecord,
) -> Option<PpcQ3SubmissionLightRecord> {
lights
.get(index)
.filter(|record| ppc_q3_submission_light_matches(record, submission))
.cloned()
.or_else(|| {
lights
.iter()
.find(|record| ppc_q3_submission_light_matches(record, submission))
.cloned()
})
}
fn q3_scene_trimesh_geometry(
&mut self,
primary: u32,
retained_trimeshes: &[PpcQ3TriMeshRecord],
) -> Option<PpcQ3SceneTriMeshGeometry> {
if let Some(object) = self
.q3_objects
.iter()
.find(|record| record.object == primary && record.object_type == PPC_Q3_TYPE_TRIMESH)
.copied()
{
let data = self
.q3_trimeshes
.iter()
.find(|record| record.trimesh == primary)
.map(|record| record.data.clone())
.or_else(|| {
if object.data_ptr != 0 && object.data_size >= PPC_Q3_TRIMESH_DATA_SIZE {
self.q3_scene_read_bytes(object.data_ptr, PPC_Q3_TRIMESH_DATA_SIZE)
} else {
None
}
})?;
return Some(PpcQ3SceneTriMeshGeometry {
source: PpcQ3SceneTriMeshSource::Object(primary),
data,
});
}
if let Some(record) = retained_trimeshes
.iter()
.find(|record| record.trimesh == primary)
{
return Some(PpcQ3SceneTriMeshGeometry {
source: PpcQ3SceneTriMeshSource::Object(primary),
data: record.data.clone(),
});
}
self.q3_scene_read_bytes(primary, PPC_Q3_TRIMESH_DATA_SIZE)
.map(|data| PpcQ3SceneTriMeshGeometry {
source: PpcQ3SceneTriMeshSource::DataPtr(primary),
data,
})
}
fn q3_scene_read_bytes(&mut self, source_ptr: u32, byte_count: u32) -> Option<Vec<u8>> {
let mut data = Vec::with_capacity(byte_count as usize);
for offset in 0..byte_count {
data.push(self.memory.read_u8(source_ptr.checked_add(offset)?)?);
}
Some(data)
}
fn capture_q3_trimesh_replay_memory(
&mut self,
memory_regions: &mut Vec<PpcQ3SceneReplayMemoryRegion>,
command: &PpcQ3SceneTriMeshCommand,
) {
let point_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_POINTS_OFFSET)
.unwrap_or(0);
let triangle_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)
.unwrap_or(0);
let edge_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)
.unwrap_or(0);
if point_count != 0 && point_count <= PPC_Q3_SOFTWARE_RENDER_MAX_POINTS {
if let Some(points_ptr) =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_POINTS_OFFSET)
{
self.capture_q3_replay_memory_region(
memory_regions,
points_ptr,
point_count.saturating_mul(PPC_Q3_POINT3D_SIZE),
);
}
}
if triangle_count != 0 && triangle_count <= PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES {
if let Some(triangles_ptr) =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_TRIANGLES_OFFSET)
{
self.capture_q3_replay_memory_region(
memory_regions,
triangles_ptr,
triangle_count.saturating_mul(PPC_Q3_TRIMESH_TRIANGLE_DATA_SIZE),
);
}
}
if edge_count != 0 && edge_count <= PPC_Q3_SOFTWARE_RENDER_MAX_EDGES {
if let Some(edges_ptr) =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_EDGES_OFFSET)
{
self.capture_q3_replay_memory_region(
memory_regions,
edges_ptr,
edge_count.saturating_mul(PPC_Q3_TRIMESH_EDGE_DATA_SIZE),
);
}
}
self.capture_q3_trimesh_attribute_replay_memory(
memory_regions,
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
triangle_count,
);
self.capture_q3_trimesh_attribute_replay_memory(
memory_regions,
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
edge_count,
);
self.capture_q3_trimesh_attribute_replay_memory(
memory_regions,
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
point_count,
);
}
fn capture_q3_trimesh_attribute_replay_memory(
&mut self,
memory_regions: &mut Vec<PpcQ3SceneReplayMemoryRegion>,
geometry: &[u8],
count_offset: u32,
table_offset: u32,
element_count: u32,
) {
if element_count == 0 {
return;
}
let Some(attr_count) = ppc_q3_trimesh_header_u32(geometry, count_offset) else {
return;
};
let Some(attr_ptr) = ppc_q3_trimesh_header_u32(geometry, table_offset) else {
return;
};
if attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return;
}
self.capture_q3_replay_memory_region(
memory_regions,
attr_ptr,
attr_count.saturating_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE),
);
for index in 0..attr_count {
let Some(entry_ptr) =
attr_ptr.checked_add(index.saturating_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE))
else {
return;
};
let Some(attr_type) = self.memory.read_u32_be(entry_ptr) else {
continue;
};
let Some(data_ptr) = self.memory.read_u32_be(entry_ptr.saturating_add(4)) else {
continue;
};
if data_ptr == 0 {
continue;
}
let Some(attr_size) = ppc_q3_attribute_data_size(attr_type) else {
continue;
};
self.capture_q3_replay_memory_region(
memory_regions,
data_ptr,
element_count.saturating_mul(attr_size),
);
}
}
fn capture_q3_material_replay_memory(
&mut self,
memory_regions: &mut Vec<PpcQ3SceneReplayMemoryRegion>,
material: &PpcQ3SubmissionMaterialRecord,
) {
let Some(texture) =
ppc_q3_software_material_texture(&self.q3_objects, &self.q3_memory_storages, material)
else {
return;
};
let Some(last_row_offset) = texture
.height
.checked_sub(1)
.and_then(|height| height.checked_mul(texture.row_bytes))
else {
return;
};
let Some(used_row_bytes) = texture.width.checked_mul(texture.pixel_bytes) else {
return;
};
let Some(byte_count) = last_row_offset.checked_add(used_row_bytes) else {
return;
};
let Some(base_addr) = texture.image_base.checked_add(texture.image_offset) else {
return;
};
self.capture_q3_replay_memory_region(memory_regions, base_addr, byte_count);
}
fn capture_q3_replay_memory_region(
&mut self,
memory_regions: &mut Vec<PpcQ3SceneReplayMemoryRegion>,
base_addr: u32,
byte_count: u32,
) {
if base_addr == 0 || byte_count == 0 {
return;
}
let Ok(byte_count) = usize::try_from(byte_count) else {
return;
};
if let Some(region) = memory_regions
.iter_mut()
.find(|region| region.base_addr == base_addr)
{
if region.data.len() >= byte_count {
return;
}
let mut data = vec![0; byte_count];
if self.memory.read_bytes_into(base_addr, &mut data).is_some() {
region.data = data;
}
return;
}
let mut data = vec![0; byte_count];
if self.memory.read_bytes_into(base_addr, &mut data).is_some() {
memory_regions.push(PpcQ3SceneReplayMemoryRegion { base_addr, data });
}
}
fn install_q3_scene_replay_memory_region(&mut self, region: &PpcQ3SceneReplayMemoryRegion) {
if region.base_addr == 0 || region.data.is_empty() {
return;
}
if ppc_memory_can_write_bytes(
&mut self.memory,
region.base_addr,
u32::try_from(region.data.len()).unwrap_or(u32::MAX),
) && ppc_q3_write_bytes(&mut self.memory, region.base_addr, ®ion.data)
{
return;
}
self.memory
.add_region(region.base_addr, region.data.clone());
}
fn q3_software_trimesh_points(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<(f32, f32, f32)>> {
let count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_POINTS_OFFSET)?;
let points_ptr =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_POINTS_OFFSET)?;
if count == 0 || count > PPC_Q3_SOFTWARE_RENDER_MAX_POINTS || points_ptr == 0 {
return None;
}
let mut points = Vec::with_capacity(count as usize);
for index in 0..count {
let point_ptr = points_ptr.checked_add(index.checked_mul(PPC_Q3_POINT3D_SIZE)?)?;
point_ptr.checked_add(PPC_Q3_POINT3D_SIZE.saturating_sub(1))?;
let point = ppc_read_q3_vector3d(&mut self.memory, point_ptr)?;
if !ppc_q3_point_finite(point) {
return None;
}
points.push(point);
}
Some(points)
}
fn q3_software_trimesh_triangles(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Vec<PpcQ3SoftwareTriangle> {
let Some(count) =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)
else {
return Vec::new();
};
let Some(triangles_ptr) =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_TRIANGLES_OFFSET)
else {
return Vec::new();
};
if count == 0 || count > PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES || triangles_ptr == 0 {
return Vec::new();
}
let mut triangles = Vec::with_capacity(count as usize);
for index in 0..count {
let Some(triangle_offset) = index.checked_mul(PPC_Q3_TRIMESH_TRIANGLE_DATA_SIZE) else {
break;
};
let Some(triangle_ptr) = triangles_ptr.checked_add(triangle_offset) else {
break;
};
let Some(a) = self.memory.read_u32_be(triangle_ptr) else {
continue;
};
let Some(b_ptr) = triangle_ptr.checked_add(4) else {
continue;
};
let Some(c_ptr) = triangle_ptr.checked_add(8) else {
continue;
};
let Some(b) = self.memory.read_u32_be(b_ptr) else {
continue;
};
let Some(c) = self.memory.read_u32_be(c_ptr) else {
continue;
};
let Ok(a) = usize::try_from(a) else {
continue;
};
let Ok(b) = usize::try_from(b) else {
continue;
};
let Ok(c) = usize::try_from(c) else {
continue;
};
if a < point_count && b < point_count && c < point_count {
let Ok(index) = usize::try_from(index) else {
continue;
};
triangles.push(PpcQ3SoftwareTriangle {
index,
points: [a, b, c],
});
}
}
triangles
}
fn q3_software_trimesh_edges(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Vec<PpcQ3SoftwareEdge> {
let Some(count) =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)
else {
return Vec::new();
};
let Some(edges_ptr) =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_EDGES_OFFSET)
else {
return Vec::new();
};
if count == 0 || count > PPC_Q3_SOFTWARE_RENDER_MAX_EDGES || edges_ptr == 0 {
return Vec::new();
}
let mut edges = Vec::with_capacity(count as usize);
for index in 0..count {
let Some(edge_offset) = index.checked_mul(PPC_Q3_TRIMESH_EDGE_DATA_SIZE) else {
break;
};
let Some(edge_ptr) = edges_ptr.checked_add(edge_offset) else {
break;
};
let Some(a) = self.memory.read_u32_be(edge_ptr) else {
continue;
};
let Some(b_ptr) = edge_ptr.checked_add(4) else {
continue;
};
let Some(b) = self.memory.read_u32_be(b_ptr) else {
continue;
};
let Ok(a) = usize::try_from(a) else {
continue;
};
let Ok(b) = usize::try_from(b) else {
continue;
};
if a < point_count && b < point_count {
let Ok(index) = usize::try_from(index) else {
continue;
};
edges.push(PpcQ3SoftwareEdge {
index,
points: [a, b],
});
}
}
edges
}
fn q3_software_trimesh_triangle_diffuse_colors(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<(f32, f32, f32)>> {
let triangle_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
if triangle_count == 0
|| triangle_count > PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR && data_ptr != 0 {
let triangle_count = usize::try_from(triangle_count).ok()?;
return self.q3_software_read_vertex_colors(data_ptr, triangle_count);
}
}
None
}
fn q3_software_trimesh_triangle_ambient_coefficients(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<f32>> {
let triangle_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
if triangle_count == 0
|| triangle_count > PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT && data_ptr != 0 {
let triangle_count = usize::try_from(triangle_count).ok()?;
return self.q3_software_read_vertex_unit_scalars(data_ptr, triangle_count);
}
}
None
}
fn q3_software_trimesh_triangle_normals(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<(f32, f32, f32)>> {
let triangle_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
if triangle_count == 0
|| triangle_count > PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_NORMAL && data_ptr != 0 {
let triangle_count = usize::try_from(triangle_count).ok()?;
return self.q3_software_read_vertex_normals(data_ptr, triangle_count);
}
}
None
}
fn q3_software_trimesh_triangle_highlight_states(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<bool>> {
let triangle_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
if triangle_count == 0
|| triangle_count > PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE && data_ptr != 0 {
let triangle_count = usize::try_from(triangle_count).ok()?;
return self.q3_software_read_vertex_switches(data_ptr, triangle_count);
}
}
None
}
fn q3_software_trimesh_edge_diffuse_colors(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<(f32, f32, f32)>> {
let edge_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
if edge_count == 0
|| edge_count > PPC_Q3_SOFTWARE_RENDER_MAX_EDGES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR && data_ptr != 0 {
let edge_count = usize::try_from(edge_count).ok()?;
return self.q3_software_read_vertex_colors(data_ptr, edge_count);
}
}
None
}
fn q3_software_trimesh_edge_ambient_coefficients(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<f32>> {
let edge_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
if edge_count == 0
|| edge_count > PPC_Q3_SOFTWARE_RENDER_MAX_EDGES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT && data_ptr != 0 {
let edge_count = usize::try_from(edge_count).ok()?;
return self.q3_software_read_vertex_unit_scalars(data_ptr, edge_count);
}
}
None
}
fn q3_software_trimesh_edge_specular_colors(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<(f32, f32, f32)>> {
let edge_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
if edge_count == 0
|| edge_count > PPC_Q3_SOFTWARE_RENDER_MAX_EDGES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR && data_ptr != 0 {
let edge_count = usize::try_from(edge_count).ok()?;
return self.q3_software_read_vertex_colors(data_ptr, edge_count);
}
}
None
}
fn q3_software_trimesh_edge_specular_controls(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<f32>> {
let edge_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
if edge_count == 0
|| edge_count > PPC_Q3_SOFTWARE_RENDER_MAX_EDGES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL && data_ptr != 0 {
let edge_count = usize::try_from(edge_count).ok()?;
return self.q3_software_read_vertex_scalars(data_ptr, edge_count);
}
}
None
}
fn q3_software_trimesh_edge_normals(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<(f32, f32, f32)>> {
let edge_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
if edge_count == 0
|| edge_count > PPC_Q3_SOFTWARE_RENDER_MAX_EDGES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_NORMAL && data_ptr != 0 {
let edge_count = usize::try_from(edge_count).ok()?;
return self.q3_software_read_vertex_normals(data_ptr, edge_count);
}
}
None
}
fn q3_software_trimesh_edge_highlight_states(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<bool>> {
let edge_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
if edge_count == 0
|| edge_count > PPC_Q3_SOFTWARE_RENDER_MAX_EDGES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE && data_ptr != 0 {
let edge_count = usize::try_from(edge_count).ok()?;
return self.q3_software_read_vertex_switches(data_ptr, edge_count);
}
}
None
}
fn q3_software_trimesh_triangle_specular_colors(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<(f32, f32, f32)>> {
let triangle_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
if triangle_count == 0
|| triangle_count > PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR && data_ptr != 0 {
let triangle_count = usize::try_from(triangle_count).ok()?;
return self.q3_software_read_vertex_colors(data_ptr, triangle_count);
}
}
None
}
fn q3_software_trimesh_triangle_specular_controls(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<f32>> {
let triangle_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
if triangle_count == 0
|| triangle_count > PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL && data_ptr != 0 {
let triangle_count = usize::try_from(triangle_count).ok()?;
return self.q3_software_read_vertex_scalars(data_ptr, triangle_count);
}
}
None
}
fn q3_software_trimesh_triangle_alphas(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<f32>> {
let triangle_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
)?;
if triangle_count == 0
|| triangle_count > PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR && data_ptr != 0 {
let triangle_count = usize::try_from(triangle_count).ok()?;
return self.q3_software_read_vertex_alphas(data_ptr, triangle_count);
}
}
None
}
fn q3_software_trimesh_edge_alphas(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
) -> Option<Vec<f32>> {
let edge_count =
ppc_q3_trimesh_header_u32(&command.geometry.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)?;
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
)?;
if edge_count == 0
|| edge_count > PPC_Q3_SOFTWARE_RENDER_MAX_EDGES
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR && data_ptr != 0 {
let edge_count = usize::try_from(edge_count).ok()?;
return self.q3_software_read_vertex_alphas(data_ptr, edge_count);
}
}
None
}
fn q3_software_trimesh_vertex_uvs(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Option<Vec<(f32, f32)>> {
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
if attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
let mut shading_uvs = None;
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if data_ptr == 0 {
continue;
}
match attr_type {
PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV => {
return self.q3_software_read_vertex_uvs(data_ptr, point_count);
}
PPC_Q3_ATTRIBUTE_TYPE_SHADING_UV if shading_uvs.is_none() => {
shading_uvs = self.q3_software_read_vertex_uvs(data_ptr, point_count);
}
_ => {}
}
}
shading_uvs
}
fn q3_software_read_vertex_uvs(
&mut self,
data_ptr: u32,
point_count: usize,
) -> Option<Vec<(f32, f32)>> {
let count = u32::try_from(point_count).ok()?;
let mut uvs = Vec::with_capacity(point_count);
for index in 0..count {
let uv_ptr = data_ptr.checked_add(index.checked_mul(PPC_Q3_VECTOR2D_SIZE)?)?;
let uv = ppc_read_q3_vector2d(&mut self.memory, uv_ptr)?;
if !uv.0.is_finite() || !uv.1.is_finite() {
return None;
}
uvs.push(uv);
}
Some(uvs)
}
fn q3_software_trimesh_vertex_diffuse_colors(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Option<Vec<(f32, f32, f32)>> {
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
if attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR && data_ptr != 0 {
return self.q3_software_read_vertex_colors(data_ptr, point_count);
}
}
None
}
fn q3_software_trimesh_vertex_ambient_coefficients(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Option<Vec<f32>> {
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
if attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT && data_ptr != 0 {
return self.q3_software_read_vertex_unit_scalars(data_ptr, point_count);
}
}
None
}
fn q3_software_read_vertex_colors(
&mut self,
data_ptr: u32,
point_count: usize,
) -> Option<Vec<(f32, f32, f32)>> {
let count = u32::try_from(point_count).ok()?;
let mut colors = Vec::with_capacity(point_count);
for index in 0..count {
let color_ptr = data_ptr.checked_add(index.checked_mul(PPC_Q3_POINT3D_SIZE)?)?;
let color = ppc_read_q3_color_rgb(&mut self.memory, color_ptr)?;
if !ppc_q3_color_finite(color) {
return None;
}
colors.push(color);
}
Some(colors)
}
fn q3_software_trimesh_vertex_specular_colors(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Option<Vec<(f32, f32, f32)>> {
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
if attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR && data_ptr != 0 {
return self.q3_software_read_vertex_colors(data_ptr, point_count);
}
}
None
}
fn q3_software_trimesh_vertex_specular_controls(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Option<Vec<f32>> {
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
if attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL && data_ptr != 0 {
return self.q3_software_read_vertex_scalars(data_ptr, point_count);
}
}
None
}
fn q3_software_trimesh_vertex_highlight_states(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Option<Vec<bool>> {
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
if attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE && data_ptr != 0 {
return self.q3_software_read_vertex_switches(data_ptr, point_count);
}
}
None
}
fn q3_software_read_vertex_scalars(
&mut self,
data_ptr: u32,
point_count: usize,
) -> Option<Vec<f32>> {
let count = u32::try_from(point_count).ok()?;
let mut values = Vec::with_capacity(point_count);
for index in 0..count {
let scalar_ptr = data_ptr.checked_add(index.checked_mul(4)?)?;
let value = ppc_read_f32_be(&mut self.memory, scalar_ptr)?;
if !value.is_finite() {
return None;
}
values.push(value.max(0.0));
}
Some(values)
}
fn q3_software_read_vertex_unit_scalars(
&mut self,
data_ptr: u32,
point_count: usize,
) -> Option<Vec<f32>> {
self.q3_software_read_vertex_scalars(data_ptr, point_count)
.map(|mut values| {
for value in &mut values {
*value = value.clamp(0.0, 1.0);
}
values
})
}
fn q3_software_read_vertex_switches(
&mut self,
data_ptr: u32,
point_count: usize,
) -> Option<Vec<bool>> {
let count = u32::try_from(point_count).ok()?;
let mut values = Vec::with_capacity(point_count);
for index in 0..count {
let scalar_ptr = data_ptr.checked_add(index.checked_mul(4)?)?;
let value = self.memory.read_u32_be(scalar_ptr)?;
values.push(value != 0);
}
Some(values)
}
fn q3_software_trimesh_vertex_normals(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Option<Vec<(f32, f32, f32)>> {
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
if attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_NORMAL && data_ptr != 0 {
return self.q3_software_read_vertex_normals(data_ptr, point_count);
}
}
None
}
fn q3_software_read_vertex_normals(
&mut self,
data_ptr: u32,
point_count: usize,
) -> Option<Vec<(f32, f32, f32)>> {
let count = u32::try_from(point_count).ok()?;
let mut normals = Vec::with_capacity(point_count);
for index in 0..count {
let normal_ptr = data_ptr.checked_add(index.checked_mul(PPC_Q3_POINT3D_SIZE)?)?;
let normal = ppc_read_q3_vector3d(&mut self.memory, normal_ptr)?;
normals.push(ppc_q3_vector3d_normalized_value(normal)?);
}
Some(normals)
}
fn q3_software_trimesh_vertex_alphas(
&mut self,
command: &PpcQ3SceneTriMeshCommand,
point_count: usize,
) -> Option<Vec<f32>> {
let attr_count = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
let attr_ptr = ppc_q3_trimesh_header_u32(
&command.geometry.data,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
)?;
if attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return None;
}
for index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let attr_type = self.memory.read_u32_be(entry_ptr)?;
let data_ptr = self.memory.read_u32_be(entry_ptr.checked_add(4)?)?;
if attr_type == PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR && data_ptr != 0 {
return self.q3_software_read_vertex_alphas(data_ptr, point_count);
}
}
None
}
fn q3_software_read_vertex_alphas(
&mut self,
data_ptr: u32,
point_count: usize,
) -> Option<Vec<f32>> {
let count = u32::try_from(point_count).ok()?;
let mut alphas = Vec::with_capacity(point_count);
for index in 0..count {
let color_ptr = data_ptr.checked_add(index.checked_mul(PPC_Q3_POINT3D_SIZE)?)?;
let color = ppc_read_q3_color_rgb(&mut self.memory, color_ptr)?;
alphas.push(ppc_q3_software_transparency_color_alpha(color)?);
}
Some(alphas)
}
fn assert_cfm_execution_owner(&self, process_cfm: Option<&PpcCfmState>) {
assert!(
process_cfm.is_some() || self.cfm.is_some(),
"installed native execution requires process CFM services"
);
assert!(
process_cfm.is_none() || self.cfm.is_none(),
"move the standalone CFM seed before using process services"
);
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn run_with_process_services(
&mut self,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
memory_manager: &mut ProcessMemoryManager,
cfm: &mut PpcCfmState,
) -> PpcHleRunProbe {
self.run_with_hle_imports_with_trace(
max_cycles,
trace_imports,
trace_fetches,
Some(memory_manager),
Some(cfm),
)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn run_sound_completion_callback_with_process_services(
&mut self,
completion: PpcSoundCompletionRecord,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
memory_manager: &mut ProcessMemoryManager,
cfm: &mut PpcCfmState,
) -> PpcSoundCompletionCallProbe {
self.run_sound_completion_callback_inner(
completion,
max_cycles,
trace_imports,
trace_fetches,
Some(memory_manager),
Some(cfm),
)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn fire_timer_tasks_for_ticks_with_process_services(
&mut self,
start_tick: u32,
elapsed_ticks: u32,
max_callbacks: usize,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
memory_manager: &mut ProcessMemoryManager,
cfm: &mut PpcCfmState,
) -> Vec<PpcTimerCallbackProbe> {
self.fire_timer_tasks_for_ticks_inner(
start_tick,
elapsed_ticks,
max_callbacks,
max_cycles,
trace_imports,
trace_fetches,
Some(memory_manager),
Some(cfm),
)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn fire_vbl_tasks_for_ticks_with_process_services(
&mut self,
start_tick: u32,
elapsed_ticks: u32,
max_callbacks: usize,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
memory_manager: &mut ProcessMemoryManager,
cfm: &mut PpcCfmState,
) -> Vec<PpcVblCallbackProbe> {
self.fire_vbl_tasks_for_ticks_inner(
start_tick,
elapsed_ticks,
max_callbacks,
max_cycles,
trace_imports,
trace_fetches,
Some(memory_manager),
Some(cfm),
)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn run_sound_doubleback_callback_with_process_services(
&mut self,
doubleback: PpcSoundDoubleBackRecord,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
memory_manager: &mut ProcessMemoryManager,
cfm: &mut PpcCfmState,
) -> PpcSoundCompletionCallProbe {
self.run_sound_doubleback_callback_inner(
doubleback,
max_cycles,
trace_imports,
trace_fetches,
Some(memory_manager),
Some(cfm),
)
}
pub fn run_with_hle_imports(&mut self, max_cycles: u64) -> PpcHleRunProbe {
self.run_with_hle_imports_with_trace(max_cycles, false, false, None, None)
}
pub fn run_with_hle_import_trace(&mut self, max_cycles: u64) -> PpcHleRunProbe {
self.run_with_hle_imports_with_trace(max_cycles, true, false, None, None)
}
pub fn run_with_hle_import_fetch_histogram(&mut self, max_cycles: u64) -> PpcHleRunProbe {
self.run_with_hle_imports_with_trace(max_cycles, false, true, None, None)
}
pub fn run_with_hle_import_trace_and_fetch_histogram(
&mut self,
max_cycles: u64,
) -> PpcHleRunProbe {
self.run_with_hle_imports_with_trace(max_cycles, true, true, None, None)
}
#[cfg(test)]
pub(crate) fn run_with_process_memory_manager(
&mut self,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
memory_manager: &mut ProcessMemoryManager,
) -> PpcHleRunProbe {
self.run_with_hle_imports_with_trace(
max_cycles,
trace_imports,
trace_fetches,
Some(memory_manager),
None,
)
}
pub fn run_sound_completion_callback(
&mut self,
completion: PpcSoundCompletionRecord,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
) -> PpcSoundCompletionCallProbe {
self.run_sound_completion_callback_inner(
completion,
max_cycles,
trace_imports,
trace_fetches,
None,
None,
)
}
/// PowerPC System Software (1994), pp. 1-44–1-49: asynchronous
/// callbacks need a private frame below the interrupted 224-byte Red Zone.
/// Validate the engine owner's allocation and the complete writable frame
/// before touching linkage, parameters or the interrupted registers.
fn prepare_interrupt_callback_frame(&mut self, rtoc: u32) -> Option<u32> {
let interrupted_sp = self.cpu.gpr[1];
let frame_sp = interrupted_sp
.checked_sub(PPC_INTERRUPT_RED_ZONE_SIZE)?
.checked_sub(PPC_INITIAL_STACK_FRAME_SIZE)?
& !15;
let (base, limit) = self.toolbox_startup.execution.calls().native_stack_bounds(
self.stack_base,
self.stack_base.checked_add(self.stack_size)?,
)?;
if frame_sp < base
|| interrupted_sp > limit
|| !ppc_memory_can_write_bytes(&mut self.memory, frame_sp, PPC_INITIAL_STACK_FRAME_SIZE)
{
return None;
}
if !ppc_zero_guest_bytes(&mut self.memory, frame_sp, PPC_INITIAL_STACK_FRAME_SIZE) {
return None;
}
self.memory
.write_u32_be(frame_sp + PPC_LINKAGE_BACK_CHAIN_OFFSET, interrupted_sp)?;
self.memory
.write_u32_be(frame_sp + PPC_LINKAGE_SAVED_CR_OFFSET, self.cpu.cr)?;
self.memory
.write_u32_be(frame_sp + PPC_LINKAGE_SAVED_LR_OFFSET, self.cpu.lr)?;
self.memory
.write_u32_be(frame_sp + PPC_LINKAGE_SAVED_RTOC_OFFSET, rtoc)?;
Some(frame_sp)
}
fn interrupt_callback_stack_fault(&self) -> PpcHleRunProbe {
PpcHleRunProbe {
result: PpcRunResult::MemoryFault {
pc: self.cpu.pc,
addr: ppc_interrupt_callback_stack_pointer(self.cpu.gpr[1]),
was_write: true,
cycles: 0,
},
handled_import_count: 0,
last_import_index: None,
unsupported_import_index: None,
import_trace: Vec::new(),
draw_sprocket_trace: Vec::new(),
input_sprocket_trace: Vec::new(),
fetch_histogram: None,
}
}
fn run_sound_completion_callback_inner(
&mut self,
completion: PpcSoundCompletionRecord,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
process_memory_manager: Option<&mut ProcessMemoryManager>,
mut process_cfm: Option<&mut PpcCfmState>,
) -> PpcSoundCompletionCallProbe {
self.assert_cfm_execution_owner(process_cfm.as_deref());
let saved_context = self.cpu.capture_execution_context();
let default_rtoc = if saved_context.architectural().gpr[2] != 0 {
saved_context.architectural().gpr[2]
} else {
self.rtoc
};
let target = ppc_resolve_callback_target(
&mut self.memory,
completion.completion,
default_rtoc,
None,
)
.unwrap_or(PpcCallbackTarget {
entry: completion.completion,
rtoc: default_rtoc,
proc_info: 0,
routine_flags: 0,
});
let mut entered = false;
let probe = if let Some(callback_sp) = self.prepare_interrupt_callback_frame(default_rtoc) {
self.cpu.invalidate_reservation();
entered = true;
self.cpu.pc = target.entry;
self.cpu.lr = self.halt_pc;
self.cpu.gpr[1] = callback_sp;
self.cpu.gpr[2] = target.rtoc;
let command_ptr = completion.command.and_then(|command| {
// The PowerPC SndCallBackProcPtr signature is
// (SndChannelPtr, SndCommand *). Keep the copied command in the
// final eight bytes of the 64-byte callback frame, after its
// linkage and eight-word parameter areas and before the
// interrupted routine's protected Red Zone.
let command_ptr = self.cpu.gpr[1].checked_add(
PPC_PARAMETER_AREA_OFFSET + PPC_NATIVE_PARAMETER_GPR_COUNT as u32 * 4,
)?;
self.memory.write_u16_be(command_ptr, command.command)?;
self.memory
.write_u16_be(command_ptr + 2, command.param1 as u16)?;
self.memory.write_u32_be(command_ptr + 4, command.param2)?;
Some(command_ptr)
});
let _ = install_powerpc_call_arguments(
&mut self.cpu,
&mut self.memory,
&[completion.channel, command_ptr.unwrap_or(0)],
);
self.run_with_hle_imports_with_trace(
max_cycles,
trace_imports,
trace_fetches,
process_memory_manager,
process_cfm.as_deref_mut(),
)
} else {
self.interrupt_callback_stack_fault()
};
let end_pc = self.cpu.pc;
let end_sp = self.cpu.gpr[1];
let end_r3 = self.cpu.gpr[3];
let cycles = ppc_run_result_cycles(probe.result);
if entered {
self.cpu.install_execution_context(saved_context);
}
PpcSoundCompletionCallProbe {
invocation: PpcSoundCompletionInvocationRecord {
file_playback_index: completion.file_playback_index,
channel: completion.channel,
completion: completion.completion,
callback_entry: target.entry,
callback_rtoc: target.rtoc,
tick: completion.tick,
instruction_count: completion.instruction_count,
scheduled_tick: completion.scheduled_tick,
scheduled_instruction_count: completion.scheduled_instruction_count,
cycles,
end_pc,
end_sp,
end_r3,
result: probe.result,
unsupported_import_index: probe.unsupported_import_index,
},
import_trace: probe.import_trace,
fetch_histogram: probe.fetch_histogram,
}
}
pub fn fire_timer_tasks_for_ticks(
&mut self,
start_tick: u32,
elapsed_ticks: u32,
max_callbacks: usize,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
) -> Vec<PpcTimerCallbackProbe> {
self.fire_timer_tasks_for_ticks_inner(
start_tick,
elapsed_ticks,
max_callbacks,
max_cycles,
trace_imports,
trace_fetches,
None,
None,
)
}
#[allow(clippy::too_many_arguments)]
fn fire_timer_tasks_for_ticks_inner(
&mut self,
start_tick: u32,
elapsed_ticks: u32,
max_callbacks: usize,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
mut process_memory_manager: Option<&mut ProcessMemoryManager>,
mut process_cfm: Option<&mut PpcCfmState>,
) -> Vec<PpcTimerCallbackProbe> {
self.assert_cfm_execution_owner(process_cfm.as_deref());
let mut probes = Vec::new();
if elapsed_ticks == 0 || self.timer_tasks.is_empty() || max_callbacks == 0 {
return probes;
}
for tick_offset in 0..elapsed_ticks {
let current_tick = start_tick.wrapping_add(tick_offset).wrapping_add(1);
let current_tick = self.publish_tick(current_tick);
self.callback_scheduling.with_mut(|scheduling| {
scheduling.current_subtick = u64::from(current_tick) * 1_000_000;
});
loop {
if probes.len() >= max_callbacks {
return probes;
}
let Some(task) = self
.timer_tasks
.iter()
.copied()
.filter(|task| {
task.architecture == CallbackTaskArchitecture::PowerPc
&& task.active
&& task.last_fired_tick != Some(current_tick)
&& current_tick.wrapping_sub(task.fire_at_tick) < 0x8000_0000
})
.min_by_key(|task| task.fire_at_tick)
else {
break;
};
self.timer_tasks.with_mut(|timer_tasks| {
if let Some(installed) = timer_tasks
.iter_mut()
.find(|installed| installed.task_ptr == task.task_ptr)
{
installed.active = false;
installed.last_fired_tick = Some(current_tick);
}
});
let q_type = self.memory.read_u16_be(task.task_ptr + 4).unwrap_or(0);
let _ = self.memory.write_u16_be(task.task_ptr + 4, q_type & 0x7fff);
if task.callback != 0 {
probes.push(self.run_timer_callback(
task.task_ptr,
task.callback,
max_cycles,
trace_imports,
trace_fetches,
process_memory_manager.as_deref_mut(),
process_cfm.as_deref_mut(),
));
}
}
}
probes
}
fn run_timer_callback(
&mut self,
task_ptr: u32,
callback: u32,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
process_memory_manager: Option<&mut ProcessMemoryManager>,
mut process_cfm: Option<&mut PpcCfmState>,
) -> PpcTimerCallbackProbe {
self.assert_cfm_execution_owner(process_cfm.as_deref());
let saved_context = self.cpu.capture_execution_context();
let saved_current_resource_refnum = self.current_resource_refnum();
let default_rtoc = if saved_context.architectural().gpr[2] != 0 {
saved_context.architectural().gpr[2]
} else {
self.rtoc
};
let target = ppc_resolve_callback_target(&mut self.memory, callback, default_rtoc, None)
.unwrap_or(PpcCallbackTarget {
entry: callback,
rtoc: default_rtoc,
proc_info: 0,
routine_flags: 0,
});
let mut entered = false;
let probe = if let Some(callback_sp) = self.prepare_interrupt_callback_frame(default_rtoc) {
self.cpu.invalidate_reservation();
entered = true;
self.cpu.pc = target.entry;
self.cpu.lr = self.halt_pc;
self.cpu.gpr[1] = callback_sp;
self.cpu.gpr[2] = target.rtoc;
// Inside Macintosh: Processes (1994), pp. 3-21--3-22: the Time
// Manager passes the expired TMTask record to its callback. Mixed
// Mode marshals that pointer into the native PowerPC argument area.
let _ = install_powerpc_call_arguments(&mut self.cpu, &mut self.memory, &[task_ptr]);
self.run_with_hle_imports_with_trace(
max_cycles,
trace_imports,
trace_fetches,
process_memory_manager,
process_cfm.as_deref_mut(),
)
} else {
self.interrupt_callback_stack_fault()
};
let end_pc = self.cpu.pc;
let end_sp = self.cpu.gpr[1];
let end_r3 = self.cpu.gpr[3];
let cycles = ppc_run_result_cycles(probe.result);
if entered {
self.cpu.install_execution_context(saved_context);
}
self.set_current_resource_refnum(saved_current_resource_refnum);
PpcTimerCallbackProbe {
invocation: PpcTimerCallbackInvocationRecord {
task_ptr,
callback,
callback_entry: target.entry,
callback_rtoc: target.rtoc,
tick: self.current_tick(),
cycles,
end_pc,
end_sp,
end_r3,
result: probe.result,
unsupported_import_index: probe.unsupported_import_index,
},
import_trace: probe.import_trace,
fetch_histogram: probe.fetch_histogram,
}
}
pub fn fire_vbl_tasks_for_ticks(
&mut self,
start_tick: u32,
elapsed_ticks: u32,
max_callbacks: usize,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
) -> Vec<PpcVblCallbackProbe> {
self.fire_vbl_tasks_for_ticks_inner(
start_tick,
elapsed_ticks,
max_callbacks,
max_cycles,
trace_imports,
trace_fetches,
None,
None,
)
}
#[allow(clippy::too_many_arguments)]
fn fire_vbl_tasks_for_ticks_inner(
&mut self,
start_tick: u32,
elapsed_ticks: u32,
max_callbacks: usize,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
mut process_memory_manager: Option<&mut ProcessMemoryManager>,
mut process_cfm: Option<&mut PpcCfmState>,
) -> Vec<PpcVblCallbackProbe> {
self.assert_cfm_execution_owner(process_cfm.as_deref());
let mut probes = Vec::new();
let has_dsp_vbl = self.draw_sprocket.vbl_proc.is_some()
&& self.draw_sprocket.context_state == PpcDspContextPlayState::Active;
if elapsed_ticks == 0
|| (self.vbl_tasks.is_empty() && !has_dsp_vbl)
|| max_callbacks == 0
{
return probes;
}
for tick_offset in 0..elapsed_ticks {
let current_tick = self.publish_tick(
start_tick.wrapping_add(tick_offset).wrapping_add(1),
);
self.callback_scheduling.with_mut(|scheduling| {
scheduling.current_subtick = u64::from(current_tick) * 1_000_000;
});
if let (Some(context), Some(vbl_proc)) = (
self.draw_sprocket.active_context,
self.draw_sprocket.vbl_proc,
) {
if self.draw_sprocket.context_state == PpcDspContextPlayState::Active {
let refcon = self.draw_sprocket.vbl_refcon.unwrap_or(0);
if probes.len() < max_callbacks {
probes.push(self.run_draw_sprocket_vbl_callback(
context,
refcon,
vbl_proc,
max_cycles,
trace_imports,
trace_fetches,
process_memory_manager.as_deref_mut(),
process_cfm.as_deref_mut(),
));
}
}
}
let tasks = (*self.vbl_tasks).clone();
for task in tasks {
if task.architecture != CallbackTaskArchitecture::PowerPc {
continue;
}
if probes.len() >= max_callbacks {
return probes;
}
let Some(count) = self.memory.read_u16_be(task.task_ptr + 10) else {
continue;
};
if count == 0 {
continue;
}
let next_count = count.saturating_sub(1);
let _ = self.memory.write_u16_be(task.task_ptr + 10, next_count);
if next_count != 0 {
continue;
}
let callback = self.memory.read_u32_be(task.task_ptr + 6).unwrap_or(0);
if callback == 0 {
continue;
}
probes.push(self.run_vbl_callback(
task.task_ptr,
callback,
max_cycles,
trace_imports,
trace_fetches,
process_memory_manager.as_deref_mut(),
process_cfm.as_deref_mut(),
));
// Inside Macintosh: Processes (1994), pp. 4-7–4-8: a VBL
// task must reset vblCount from its callback or the Vertical
// Retrace Manager removes the task after that execution.
if self.memory.read_u16_be(task.task_ptr + 10) == Some(0) {
self.vbl_tasks.with_mut(|vbl_tasks| {
vbl_tasks.retain(|installed| installed.task_ptr != task.task_ptr);
ppc_sync_vbl_task_links(&mut self.memory, vbl_tasks);
});
}
}
}
probes
}
fn run_vbl_callback(
&mut self,
task_ptr: u32,
callback: u32,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
process_memory_manager: Option<&mut ProcessMemoryManager>,
mut process_cfm: Option<&mut PpcCfmState>,
) -> PpcVblCallbackProbe {
self.assert_cfm_execution_owner(process_cfm.as_deref());
let saved_context = self.cpu.capture_execution_context();
let saved_current_resource_refnum = self.current_resource_refnum();
let default_rtoc = if saved_context.architectural().gpr[2] != 0 {
saved_context.architectural().gpr[2]
} else {
self.rtoc
};
let target = ppc_resolve_callback_target(&mut self.memory, callback, default_rtoc, None)
.unwrap_or(PpcCallbackTarget {
entry: callback,
rtoc: default_rtoc,
proc_info: 0,
routine_flags: 0,
});
let mut entered = false;
let probe = if let Some(callback_sp) = self.prepare_interrupt_callback_frame(default_rtoc) {
self.cpu.invalidate_reservation();
entered = true;
self.cpu.pc = target.entry;
self.cpu.lr = self.halt_pc;
self.cpu.gpr[1] = callback_sp;
self.cpu.gpr[2] = target.rtoc;
// Inside Macintosh: Processes (1994), p. 4-12: the Vertical Retrace
// Manager passes the VBL task record in A0 so a repetitive task can
// reset vblCount. Inside Macintosh: PowerPC System Software (1994),
// pp. 2-32–2-33 documents the register-based routine convention that
// Mixed Mode uses to marshal that four-byte A0 parameter to native PPC.
let _ = install_powerpc_call_arguments(&mut self.cpu, &mut self.memory, &[task_ptr]);
self.run_with_hle_imports_with_trace(
max_cycles,
trace_imports,
trace_fetches,
process_memory_manager,
process_cfm.as_deref_mut(),
)
} else {
self.interrupt_callback_stack_fault()
};
let end_pc = self.cpu.pc;
let end_sp = self.cpu.gpr[1];
let end_r3 = self.cpu.gpr[3];
let cycles = ppc_run_result_cycles(probe.result);
if entered {
self.cpu.install_execution_context(saved_context);
}
self.set_current_resource_refnum(saved_current_resource_refnum);
PpcVblCallbackProbe {
invocation: PpcVblCallbackInvocationRecord {
task_ptr,
callback,
callback_entry: target.entry,
callback_rtoc: target.rtoc,
tick: self.current_tick(),
cycles,
end_pc,
end_sp,
end_r3,
result: probe.result,
unsupported_import_index: probe.unsupported_import_index,
},
import_trace: probe.import_trace,
fetch_histogram: probe.fetch_histogram,
}
}
fn run_draw_sprocket_vbl_callback(
&mut self,
context: u32,
refcon: u32,
callback: u32,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
process_memory_manager: Option<&mut ProcessMemoryManager>,
mut process_cfm: Option<&mut PpcCfmState>,
) -> PpcVblCallbackProbe {
self.assert_cfm_execution_owner(process_cfm.as_deref());
let saved_context = self.cpu.capture_execution_context();
let saved_current_resource_refnum = self.current_resource_refnum();
let default_rtoc = if saved_context.architectural().gpr[2] != 0 {
saved_context.architectural().gpr[2]
} else {
self.rtoc
};
let target = ppc_resolve_callback_target(&mut self.memory, callback, default_rtoc, None)
.unwrap_or(PpcCallbackTarget {
entry: callback,
rtoc: default_rtoc,
proc_info: 0,
routine_flags: 0,
});
let mut entered = false;
let probe = if let Some(callback_sp) = self.prepare_interrupt_callback_frame(default_rtoc) {
self.cpu.invalidate_reservation();
entered = true;
self.cpu.pc = target.entry;
self.cpu.lr = self.halt_pc;
self.cpu.gpr[1] = callback_sp;
self.cpu.gpr[2] = target.rtoc;
let _ = install_powerpc_call_arguments(&mut self.cpu, &mut self.memory, &[context, refcon]);
self.run_with_hle_imports_with_trace(
max_cycles,
trace_imports,
trace_fetches,
process_memory_manager,
process_cfm.as_deref_mut(),
)
} else {
self.interrupt_callback_stack_fault()
};
let end_pc = self.cpu.pc;
let end_sp = self.cpu.gpr[1];
let end_r3 = self.cpu.gpr[3];
let cycles = ppc_run_result_cycles(probe.result);
if entered {
self.cpu.install_execution_context(saved_context);
}
self.set_current_resource_refnum(saved_current_resource_refnum);
PpcVblCallbackProbe {
invocation: PpcVblCallbackInvocationRecord {
task_ptr: 0,
callback,
callback_entry: target.entry,
callback_rtoc: target.rtoc,
tick: self.current_tick(),
cycles,
end_pc,
end_sp,
end_r3,
result: probe.result,
unsupported_import_index: probe.unsupported_import_index,
},
import_trace: probe.import_trace,
fetch_histogram: probe.fetch_histogram,
}
}
pub fn run_sound_doubleback_callback(
&mut self,
doubleback: PpcSoundDoubleBackRecord,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
) -> PpcSoundCompletionCallProbe {
self.run_sound_doubleback_callback_inner(
doubleback,
max_cycles,
trace_imports,
trace_fetches,
None,
None,
)
}
fn run_sound_doubleback_callback_inner(
&mut self,
doubleback: PpcSoundDoubleBackRecord,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
process_memory_manager: Option<&mut ProcessMemoryManager>,
mut process_cfm: Option<&mut PpcCfmState>,
) -> PpcSoundCompletionCallProbe {
self.assert_cfm_execution_owner(process_cfm.as_deref());
let saved_context = self.cpu.capture_execution_context();
let default_rtoc = if saved_context.architectural().gpr[2] != 0 {
saved_context.architectural().gpr[2]
} else {
self.rtoc
};
let target =
ppc_resolve_callback_target(&mut self.memory, doubleback.callback, default_rtoc, None)
.unwrap_or(PpcCallbackTarget {
entry: doubleback.callback,
rtoc: default_rtoc,
proc_info: 0,
routine_flags: 0,
});
let mut entered = false;
let probe = if let Some(callback_sp) = self.prepare_interrupt_callback_frame(default_rtoc) {
self.cpu.invalidate_reservation();
entered = true;
self.cpu.pc = target.entry;
self.cpu.lr = self.halt_pc;
self.cpu.gpr[1] = callback_sp;
self.cpu.gpr[2] = target.rtoc;
let _ = install_powerpc_call_arguments(
&mut self.cpu,
&mut self.memory,
&[doubleback.channel, doubleback.exhausted_buffer],
);
self.run_with_hle_imports_with_trace(
max_cycles,
trace_imports,
trace_fetches,
process_memory_manager,
process_cfm.as_deref_mut(),
)
} else {
self.interrupt_callback_stack_fault()
};
let end_pc = self.cpu.pc;
let end_sp = self.cpu.gpr[1];
let end_r3 = self.cpu.gpr[3];
let cycles = ppc_run_result_cycles(probe.result);
if entered {
self.cpu.install_execution_context(saved_context);
}
PpcSoundCompletionCallProbe {
invocation: PpcSoundCompletionInvocationRecord {
file_playback_index: u32::MAX,
channel: doubleback.channel,
completion: doubleback.callback,
callback_entry: target.entry,
callback_rtoc: target.rtoc,
tick: doubleback.tick,
instruction_count: doubleback.instruction_count,
scheduled_tick: doubleback.tick,
scheduled_instruction_count: doubleback.instruction_count,
cycles,
end_pc,
end_sp,
end_r3,
result: probe.result,
unsupported_import_index: probe.unsupported_import_index,
},
import_trace: probe.import_trace,
fetch_histogram: probe.fetch_histogram,
}
}
fn run_with_hle_imports_with_trace(
&mut self,
max_cycles: u64,
trace_imports: bool,
trace_fetches: bool,
process_memory_manager: Option<&mut ProcessMemoryManager>,
mut process_cfm: Option<&mut PpcCfmState>,
) -> PpcHleRunProbe {
self.assert_cfm_execution_owner(process_cfm.as_deref());
let guest_calls = self.toolbox_startup.execution.calls().shared_handle();
// Wakeup selects and prepares a saved context before any native step.
guest_calls.resume_ready_task();
if !guest_calls.current_task_is_running()
|| guest_calls.has_classic_task_handoff()
|| (guest_calls.has_pending_task_handoff()
&& !guest_calls.prepare_native_task(&mut self.cpu))
{
return PpcHleRunProbe {
result: PpcRunResult::CycleLimit { cycles: 0 },
handled_import_count: 0,
last_import_index: None,
unsupported_import_index: None,
import_trace: Vec::new(),
draw_sprocket_trace: Vec::new(),
input_sprocket_trace: Vec::new(),
fetch_histogram: None,
};
}
let standalone_memory_manager = process_memory_manager
.is_none()
.then(|| self.process_memory_manager.0.clone());
let mut standalone_memory_manager_borrow;
let process_memory_manager = if let Some(memory_manager) = process_memory_manager {
memory_manager
} else {
standalone_memory_manager_borrow = standalone_memory_manager
.as_ref()
.expect("standalone process Memory Manager created")
.borrow_mut();
assert!(
standalone_memory_manager_borrow.has_native_allocator(),
"loaded adapter owns a native allocator before execution"
);
&mut standalone_memory_manager_borrow
};
let mut import_run_state = PpcImportRunState::from_parts(
std::mem::take(&mut self.imports),
self.import_count,
ppc_import_layout(),
);
let q3_start_rendering_import_index = import_run_state
.bindings()
.iter()
.find(|binding| {
binding.dispatcher_target == PpcImportDispatcherTarget::Q3ViewStartRendering
})
.map(|binding| binding.symbol_index);
let q3_end_rendering_import_index = import_run_state
.bindings()
.iter()
.find(|binding| {
binding.dispatcher_target == PpcImportDispatcherTarget::Q3ViewEndRendering
})
.map(|binding| binding.symbol_index);
let input = self.current_input_snapshot();
let event_queue = std::mem::take(&mut self.event_queue);
let process_memory_manager = process_memory_manager.native_mut();
let _ = self.current_tick();
let tick_state = self.tick_state.shared_handle();
let clock_cycles_per_tick = self.clock_cycles_per_tick;
let clock_cycle_phase = self.clock_cycle_phase;
let mut process_file_system = self.process_file_system.shared_handle();
let current_resource_refnum = process_file_system
.current_resource_file
.shared_handle();
let mut last_resource_error = self
.memory
.read_u16_be(crate::memory::globals::addr::RES_ERR)
.unwrap_or(0) as i16;
let resource_policy = process_file_system.policy.shared_handle();
let native_exception_handler = Cell::new(self.native_exception_handler);
let mut native_exception_stack = std::mem::take(&mut self.native_exception_stack);
let mut stdc_qsort_stack = std::mem::take(&mut self.stdc_qsort_stack);
let mut dialog_callback_stack = std::mem::take(&mut self.dialog_callback_stack);
let mut apple_events = std::mem::take(&mut self.apple_events);
let mut standalone_cfm = if process_cfm.is_none() {
self.cfm.take()
} else {
None
};
let cfm = if let Some(cfm) = process_cfm.as_deref_mut() {
cfm
} else {
standalone_cfm.as_mut().expect("standalone CFM seed exists")
};
let (mut cfm_connections, mut cfm_library_fragments, mut next_cfm_connection_id) = (
&mut cfm.connections,
&mut cfm.library_fragments,
&mut cfm.next_connection_id,
);
let controls = std::mem::take(&mut self.controls);
let mut aliases = std::mem::take(&mut self.aliases);
let mut gworlds = std::mem::take(&mut self.gworlds);
let gworld_pixel_states = self.gworld_pixel_states.shared_handle();
let window_list = self.window_list.shared_handle();
if window_list.is_empty() {
window_list.with_mut(|windows| {
windows.extend(
gworlds
.iter()
.rev()
.map(|record| record.port)
.filter(|port| !matches!(*port, PPC_MAIN_GWORLD | PPC_DSP_BACK_GWORLD)),
);
});
}
let mut q3_objects = std::mem::take(&mut self.q3_objects);
let mut q3_object_refs = std::mem::take(&mut self.q3_object_refs);
let mut next_q3_object = self.next_q3_object;
let mut q3_error_state = self.q3_error_state;
let mut q3_lifecycle = self.q3_lifecycle;
let mut q3_memory_storages = std::mem::take(&mut self.q3_memory_storages);
let mut q3_files = std::mem::take(&mut self.q3_files);
let mut q3_group_memberships = std::mem::take(&mut self.q3_group_memberships);
let mut q3_file_groups = std::mem::take(&mut self.q3_file_groups);
let mut q3_views = std::mem::take(&mut self.q3_views);
let mut q3_submissions = std::mem::take(&mut self.q3_submissions);
let mut q3_view_transforms = std::mem::take(&mut self.q3_view_transforms);
let mut q3_submission_transforms = std::mem::take(&mut self.q3_submission_transforms);
let mut q3_view_materials = std::mem::take(&mut self.q3_view_materials);
let mut q3_submission_materials = std::mem::take(&mut self.q3_submission_materials);
let mut q3_submission_lights = std::mem::take(&mut self.q3_submission_lights);
let mut q3_view_state_stack = std::mem::take(&mut self.q3_view_state_stack);
let mut q3_completed_frames = std::mem::take(&mut self.q3_completed_frames);
let mut q3_retained_frames = std::mem::take(&mut self.q3_retained_frames);
let mut q3_state_only_completed_frame_batches =
std::mem::take(&mut self.q3_state_only_completed_frame_batches);
let mut q3_fog_styles = std::mem::take(&mut self.q3_fog_styles);
let mut q3_attributes = std::mem::take(&mut self.q3_attributes);
let mut q3_shader_uv_transforms = std::mem::take(&mut self.q3_shader_uv_transforms);
let mut q3_shader_boundaries = std::mem::take(&mut self.q3_shader_boundaries);
let mut q3_mipmap_textures = std::mem::take(&mut self.q3_mipmap_textures);
let mut q3_texture_shaders = std::mem::take(&mut self.q3_texture_shaders);
let mut q3_renderer_preferences = std::mem::take(&mut self.q3_renderer_preferences);
let mut q3_draw_contexts = std::mem::take(&mut self.q3_draw_contexts);
let mut q3_trimeshes = std::mem::take(&mut self.q3_trimeshes);
let mut q3_styles = std::mem::take(&mut self.q3_styles);
let mut q3_cameras = std::mem::take(&mut self.q3_cameras);
let mut q3_lights = std::mem::take(&mut self.q3_lights);
let mut input_sprocket = self.input_sprocket;
let mut input_sprocket_virtual_elements =
std::mem::take(&mut self.input_sprocket_virtual_elements);
let mut toolbox_startup = std::mem::take(&mut self.toolbox_startup);
let mut quicktime = std::mem::take(&mut self.quicktime);
let mut sound = std::mem::take(&mut self.sound);
let timer_tasks = std::mem::take(&mut self.timer_tasks);
let vbl_tasks = std::mem::take(&mut self.vbl_tasks);
let callback_scheduling = self.callback_scheduling.shared_handle();
// Keep File and Resource Manager records in their process-owned
// managers for the whole native execution slice. The classic
// adapter can enter through Mixed Mode while an import is running,
// so taking these records out and restoring them at slice teardown
// would leave the process temporarily with an empty manager view.
// (Inside Macintosh: Files, 1992, pp. 1-7–1-9; Inside Macintosh
// Volume I, 1985, pp. I-109–I-110.)
let current_gworld = self.current_gworld.shared_handle();
let current_gdevice = self.current_gdevice.shared_handle();
let quickdraw_op_colors = self.quickdraw_op_colors.shared_handle();
let quickdraw_hilite_colors = self.quickdraw_hilite_colors.shared_handle();
let screen_clut = self.screen_clut.shared_handle();
let color_manager_clut = self.color_manager_clut.shared_handle();
let display_gamma = self.display_gamma.shared_handle();
let mut quickdraw_fore_color = self.quickdraw_fore_color;
let mut quickdraw_fore_indices = std::mem::take(&mut self.quickdraw_fore_indices);
let mut quickdraw_back_color = self.quickdraw_back_color;
let mut quickdraw_pen_h = self.quickdraw_pen_h;
let mut quickdraw_pen_v = self.quickdraw_pen_v;
let mut quickdraw_text_mode = self.quickdraw_text_mode;
let mut quickdraw_text_size = self.quickdraw_text_size;
let process_quickdraw_port_state_attached = self.process_quickdraw_port_state_attached;
let cursor_state = std::mem::take(&mut self.cursor_state);
let vfs_volumes = self.vfs_volumes.shared_handle();
let vfs_directories = self.vfs_directories.shared_handle();
let next_vfs_dir_id = self.next_vfs_dir_id.shared_handle();
let default_dir_id = self.default_dir_id.shared_handle();
let working_directories = self.working_directories.shared_handle();
let next_working_directory_ref_num = self
.next_working_directory_ref_num
.shared_handle();
let application_working_directory_ref_num = self
.application_working_directory_ref_num
.shared_handle();
let param_text = self.param_text.shared_handle();
let mut scrap = std::mem::take(&mut self.scrap);
let list_manager = std::mem::take(&mut self.list_manager);
let mut draw_sprocket = self.draw_sprocket;
let mut handled_import_count = 0u32;
let mut last_import_index = None;
let mut unsupported_import_index = None;
let mut import_trace = Vec::new();
let mut draw_sprocket_trace = Vec::new();
let mut input_sprocket_trace = Vec::new();
let mut fetch_histogram = PpcFetchHistogram::new();
let trace_ppc = ppc_trace_enabled();
let trace_sprocket = sprocket_trace_enabled();
let trace_qd3d = qd3d_trace_enabled();
let trace_pc_range = ppc_trace_pc_range();
let trace_recent_on_halt = ppc_recent_imports_on_halt_enabled();
let mut recent_imports = VecDeque::<PpcHleImportTraceEntry>::new();
let mut idle_poll_counts = HashMap::<u32, u32>::new();
let mut tick_count_idle_poll = PpcTickCountIdlePollState::default();
let needs_fetch_observer = trace_fetches || trace_ppc || trace_pc_range.is_some();
let mut fetch_observer = PpcHleFetchObserver {
histogram: if trace_fetches {
Some(&mut fetch_histogram)
} else {
None
},
trace_fetches: trace_ppc,
trace_pc_range,
};
let result = {
type Mem = PpcSectionMem;
let mut handle_import = |elapsed, index, cpu: &mut PpcCpu, memory: &mut Mem| {
if index == PPC_THREAD_RETURN_IMPORT_INDEX {
// ThreadEntryProc returns its result in R3. Retire only
// after validating the successor and result destination.
// Inside Macintosh: Thread Manager (1999), pp. 59–60.
let task = guest_calls.current_task();
let result = cpu.gpr[3];
if let Ok(retirement) =
guest_calls.retire_native_thread(task, cpu, false, |context| {
context.result_destination == 0
|| memory
.write_u32_be(context.result_destination, result)
.is_some()
})
{
ppc_release_retired_thread_storage(
process_memory_manager,
retirement,
false,
);
}
return PpcImportAction::Yield(1);
}
if index == PPC_GUEST_CALL_RETURN_IMPORT_INDEX {
let mut resource_call = None;
if toolbox_startup.execution.menu().ready_call(GuestIsa::PowerPc).is_some()
|| guest_calls
.ready_menu_bar_build(GuestIsa::PowerPc)
.is_some()
|| guest_calls.complete_powerpc_resuming_operation(
cpu,
process_memory_manager,
|operation, result| match operation {
crate::guest_call::ManagerContinuation::Menu(
crate::guest_call::MenuManagerContinuation::Definition(operation),
) => {
operation.complete(memory);
result
}
crate::guest_call::ManagerContinuation::Menu(
crate::guest_call::MenuManagerContinuation::Hook(_),
) => unreachable!("MenuHook completes after native caller restore"),
crate::guest_call::ManagerContinuation::Cfm(CfmOperation::Load(
load,
)) => ppc_complete_cfm_load(load, result, memory, &mut cfm_connections),
crate::guest_call::ManagerContinuation::Cfm(
CfmOperation::Resource(call),
) => match call.complete(result, &mut cfm_connections, memory) {
Ok(call) => {
resource_call = Some(call);
0
}
Err(error) => ppc_i16_result(error.os_error()),
},
},
) {
if guest_calls.ready_menu_bar_build(GuestIsa::PowerPc).is_some() {
let heap = process_memory_manager.native_heap_state()
.expect("native allocator registered during execution");
let mut cursor = heap.heap_cursor;
let limit =
process_memory_manager.native_allocation_limit(heap.heap_limit);
return ppc_continue_menu_bar_build(
cpu,
process_memory_manager,
memory,
&mut cursor,
limit,
&mut toolbox_startup,
&process_file_system.resource_manager.vfs_resources,
*current_resource_refnum,
);
}
if let Some((_call, _scope)) = toolbox_startup.execution.resume_menu_call(GuestIsa::PowerPc) {
let heap = process_memory_manager.native_heap_state()
.expect("native allocator registered during execution");
let mut cursor = heap.heap_cursor;
let limit = process_memory_manager.native_allocation_limit(heap.heap_limit);
return current_gworld.with_mut(|current_gworld| {
current_gdevice.with_mut(|current_gdevice| {
ppc_step_menu_tracking(
cpu,
process_memory_manager,
memory,
&mut cursor,
limit,
&gworlds,
&screen_clut,
&mut toolbox_startup,
current_gworld,
current_gdevice,
input,
&process_file_system.resource_manager.vfs_resources,
*current_resource_refnum,
)
.unwrap_or(PpcImportAction::Halt)
})
});
}
if let Some(call) = resource_call {
if let Err(error) = ppc_invoke_prepared_resource(
cpu,
memory,
&guest_calls,
call,
cpu.pc,
) {
cpu.gpr[3] = ppc_i16_result(error);
}
return PpcImportAction::Continue;
}
let native_heap = process_memory_manager
.native_heap_state()
.expect("native allocator registered during execution");
let mut heap_cursor = native_heap.heap_cursor;
let mut last_mem_error = native_heap.last_mem_error;
let handles =
&mut process_memory_manager.native_handle_records().to_vec();
ppc_complete_apple_event_dispatch(
&mut apple_events,
guest_calls.depth(),
&mut *process_memory_manager,
memory,
&mut heap_cursor,
&mut last_mem_error,
handles,
);
process_memory_manager.set_native_mem_error(last_mem_error);
return PpcImportAction::Continue;
}
if guest_calls.complete_powerpc_for_m68k(cpu) {
return PpcImportAction::Halt;
}
unsupported_import_index = Some(index);
return PpcImportAction::Halt;
}
last_import_index = Some(index);
// A Mixed Mode callback can advance process time while the
// native slice is suspended. Refresh the whole-tick baseline
// before every import so TickCount and EventRecord.when use
// the same canonical process clock while retaining this
// slice's native cycle phase.
let process_tick = memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.map(|guest_ticks| tick_state.read_tick_count(guest_ticks))
.unwrap_or_else(|| tick_state.current_tick());
let mut import_tick_count = ppc_virtual_tick_count(
process_tick,
clock_cycles_per_tick,
clock_cycle_phase,
elapsed,
);
let is_tick_count_import = import_run_state
.binding_cloned(index)
.is_some_and(|binding| {
binding.dispatcher_target == PpcImportDispatcherTarget::TickCount
});
if !is_tick_count_import {
tick_count_idle_poll.reset();
}
if !trace_imports && !trace_ppc && !trace_qd3d {
if q3_start_rendering_import_index == Some(index) {
let action =
PpcImportAction::Return(u32::from(ppc_q3_view_start_rendering(
cpu,
&mut q3_views,
&q3_objects,
&mut q3_submissions,
&mut q3_submission_transforms,
&mut q3_submission_materials,
&mut q3_submission_lights,
&mut q3_error_state,
)));
handled_import_count = handled_import_count.saturating_add(1);
return ppc_import_action_with_extra_cycles(
action,
PPC_Q3_HOT_IMPORT_EXTRA_CYCLES,
);
}
if q3_end_rendering_import_index == Some(index) {
let action = dispatch_q3_view_end_rendering_import(
cpu,
&mut q3_views,
&q3_objects,
&mut q3_submissions,
&mut q3_submission_transforms,
&mut q3_submission_materials,
&mut q3_submission_lights,
&mut q3_completed_frames,
&mut q3_retained_frames,
&mut q3_state_only_completed_frame_batches,
&q3_draw_contexts,
&q3_trimeshes,
&gworlds,
*current_gworld,
&mut q3_error_state,
input.is_idle(),
);
handled_import_count = handled_import_count.saturating_add(1);
return ppc_import_action_with_extra_cycles(
action,
PPC_Q3_HOT_IMPORT_EXTRA_CYCLES,
);
}
}
let binding = import_run_state.binding_cloned(index);
let Some(binding) = binding else {
unsupported_import_index = Some(index);
if trace_ppc {
eprintln!(
"{}",
format_ppc_trace_unknown_import(
index, cpu.pc, cpu.lr, cpu.gpr[2], cpu.gpr[1]
)
);
}
return PpcImportAction::Halt;
};
let binding = &binding;
if trace_recent_on_halt {
let entry = PpcHleImportTraceEntry {
import_index: index,
library_name: binding.library_name.clone(),
symbol_name: binding.symbol_name.clone(),
pc: cpu.pc,
lr: cpu.lr,
rtoc: cpu.gpr[2],
sp: cpu.gpr[1],
dispatcher_target: binding.dispatcher_target.clone(),
repeat_count: 1,
};
match recent_imports.back_mut() {
Some(last) if ppc_hle_import_trace_same_run(last, &entry) => {
last.repeat_count = last.repeat_count.saturating_add(1);
}
_ => recent_imports.push_back(entry),
}
while recent_imports.len() > 64 {
recent_imports.pop_front();
}
}
if !trace_ppc
&& (binding.dispatcher_target != PpcImportDispatcherTarget::TickCount
|| !trace_imports)
&& matches!(
binding.dispatcher_target,
PpcImportDispatcherTarget::Button
| PpcImportDispatcherTarget::StillDown
| PpcImportDispatcherTarget::WaitMouseUp
| PpcImportDispatcherTarget::GetKeys
| PpcImportDispatcherTarget::TickCount
| PpcImportDispatcherTarget::Microseconds
)
{
if trace_imports {
push_ppc_hle_import_trace_entry(
&mut import_trace,
PpcHleImportTraceEntry {
import_index: index,
library_name: binding.library_name.clone(),
symbol_name: binding.symbol_name.clone(),
pc: cpu.pc,
lr: cpu.lr,
rtoc: cpu.gpr[2],
sp: cpu.gpr[1],
dispatcher_target: binding.dispatcher_target.clone(),
repeat_count: 1,
},
);
}
let action = match binding.dispatcher_target {
PpcImportDispatcherTarget::Button => {
toolbox_startup.last_button_result = Some(input.mouse_button);
dispatch_button_import(cpu, input, Some(&mut idle_poll_counts))
}
PpcImportDispatcherTarget::StillDown => {
toolbox_startup.last_still_down_result =
Some(ppc_still_down_result(input, &event_queue));
dispatch_still_down_import(
cpu,
input,
&event_queue,
Some(&mut idle_poll_counts),
)
}
PpcImportDispatcherTarget::WaitMouseUp => {
let result = event_queue
.with_mut(|queue| ppc_wait_mouse_up_result(input, queue));
toolbox_startup.last_wait_mouse_up_result = Some(result);
PpcImportAction::Return(u32::from(result))
}
PpcImportDispatcherTarget::GetKeys => {
dispatch_getkeys_import(cpu, memory, input, Some(&mut idle_poll_counts))
}
PpcImportDispatcherTarget::TickCount => dispatch_tick_count_import(
cpu,
import_tick_count,
ppc_cycles_until_next_tick(
clock_cycles_per_tick,
clock_cycle_phase,
elapsed,
)
.min(max_cycles.saturating_sub(elapsed)),
Some(&mut tick_count_idle_poll),
),
PpcImportDispatcherTarget::Microseconds => dispatch_microseconds_import(
cpu,
memory,
ppc_virtual_microseconds(
process_tick,
clock_cycles_per_tick,
clock_cycle_phase,
elapsed,
),
Some(&mut idle_poll_counts),
),
_ => unreachable!(),
};
handled_import_count = handled_import_count.saturating_add(1);
return action;
}
if !trace_ppc && !trace_qd3d {
if q3_start_rendering_import_index == Some(index) {
if trace_imports {
push_ppc_hle_import_trace_entry(
&mut import_trace,
PpcHleImportTraceEntry {
import_index: index,
library_name: binding.library_name.clone(),
symbol_name: binding.symbol_name.clone(),
pc: cpu.pc,
lr: cpu.lr,
rtoc: cpu.gpr[2],
sp: cpu.gpr[1],
dispatcher_target: binding.dispatcher_target.clone(),
repeat_count: 1,
},
);
}
let action =
PpcImportAction::Return(u32::from(ppc_q3_view_start_rendering(
cpu,
&mut q3_views,
&q3_objects,
&mut q3_submissions,
&mut q3_submission_transforms,
&mut q3_submission_materials,
&mut q3_submission_lights,
&mut q3_error_state,
)));
handled_import_count = handled_import_count.saturating_add(1);
return ppc_import_action_with_extra_cycles(
action,
ppc_import_extra_cycles_for_binding(binding),
);
}
if q3_end_rendering_import_index == Some(index) {
if trace_imports {
push_ppc_hle_import_trace_entry(
&mut import_trace,
PpcHleImportTraceEntry {
import_index: index,
library_name: binding.library_name.clone(),
symbol_name: binding.symbol_name.clone(),
pc: cpu.pc,
lr: cpu.lr,
rtoc: cpu.gpr[2],
sp: cpu.gpr[1],
dispatcher_target: binding.dispatcher_target.clone(),
repeat_count: 1,
},
);
}
let action = dispatch_q3_view_end_rendering_import(
cpu,
&mut q3_views,
&q3_objects,
&mut q3_submissions,
&mut q3_submission_transforms,
&mut q3_submission_materials,
&mut q3_submission_lights,
&mut q3_completed_frames,
&mut q3_retained_frames,
&mut q3_state_only_completed_frame_batches,
&q3_draw_contexts,
&q3_trimeshes,
&gworlds,
*current_gworld,
&mut q3_error_state,
input.is_idle(),
);
handled_import_count = handled_import_count.saturating_add(1);
return ppc_import_action_with_extra_cycles(
action,
ppc_import_extra_cycles_for_binding(binding),
);
}
}
let trace_this_sprocket = trace_sprocket && is_sprocket_import(binding);
let trace_this_qd3d = trace_qd3d
&& (is_quickdraw_3d_library(&binding.library_name)
|| is_quickdraw_3d_accelerator_library(&binding.library_name));
let entry = if trace_imports || trace_ppc || trace_this_sprocket || trace_this_qd3d
{
let entry = PpcHleImportTraceEntry {
import_index: index,
library_name: binding.library_name.clone(),
symbol_name: binding.symbol_name.clone(),
pc: cpu.pc,
lr: cpu.lr,
rtoc: cpu.gpr[2],
sp: cpu.gpr[1],
dispatcher_target: binding.dispatcher_target.clone(),
repeat_count: 1,
};
if trace_ppc {
eprintln!("{}", format_ppc_trace_import(&entry));
}
if trace_imports {
push_ppc_hle_import_trace_entry(&mut import_trace, entry.clone());
}
Some(entry)
} else {
None
};
let import_args = [
cpu.gpr[3], cpu.gpr[4], cpu.gpr[5], cpu.gpr[6], cpu.gpr[7], cpu.gpr[8],
];
let qd3d_before = if trace_this_qd3d {
Some(qd3d_trace_snapshot(
&q3_objects,
&q3_views,
&q3_submissions,
&q3_completed_frames,
&q3_state_only_completed_frame_batches,
&q3_memory_storages,
&q3_files,
&q3_group_memberships,
&q3_trimeshes,
&q3_draw_contexts,
&q3_mipmap_textures,
&q3_texture_shaders,
&q3_styles,
&q3_cameras,
&q3_lights,
))
} else {
None
};
// ResErr is canonical process low memory. Refresh it at each
// import boundary so a preceding 68K callback is visible to
// native Resource Manager entry points immediately.
last_resource_error = memory
.read_u16_be(crate::memory::globals::addr::RES_ERR)
.unwrap_or(last_resource_error as u16) as i16;
let native_heap = process_memory_manager
.native_heap_state()
.expect("native allocator registered during execution");
let mut heap_cursor = native_heap.heap_cursor;
let native_heap_ceiling = native_heap.heap_limit;
// Allocation and capacity imports observe ApplLimit inside
// the mapped native heap. Keep the physical ceiling separate
// for SetApplLimit validation and stack protection. Inside
// Macintosh: Memory (1992), pp. 2-42--2-44 and 2-83--2-85.
let heap_limit = process_memory_manager
.native_allocation_limit(native_heap_ceiling);
let mut last_mem_error = native_heap.last_mem_error;
if process_quickdraw_port_state_attached {
ppc_restore_process_port_draw_state(
memory,
*current_gworld,
&mut quickdraw_fore_color,
&mut quickdraw_back_color,
&mut quickdraw_pen_h,
&mut quickdraw_pen_v,
&mut quickdraw_text_mode,
&mut quickdraw_text_size,
);
}
let action = if binding.dispatcher_target == PpcImportDispatcherTarget::GetKeys {
Some(dispatch_getkeys_import(
cpu,
memory,
input,
Some(&mut idle_poll_counts),
))
} else if let Some(action) = dispatch_qd3d::dispatch_q3_math_import_fast(
dispatch_qd3d::PpcQ3MathDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
q3_objects: &mut q3_objects,
next_q3_object: &mut next_q3_object,
q3_error_state: &mut q3_error_state,
},
) {
Some(action)
} else if let Some(action) = dispatch_qd3d::dispatch_q3_shader_style_import_fast(
dispatch_qd3d::PpcQ3ShaderStyleDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
q3_objects: &mut q3_objects,
q3_object_refs: &mut q3_object_refs,
q3_error_state: &mut q3_error_state,
next_q3_object: &mut next_q3_object,
q3_texture_shaders: &mut q3_texture_shaders,
q3_mipmap_textures: &mut q3_mipmap_textures,
q3_shader_uv_transforms: &mut q3_shader_uv_transforms,
q3_shader_boundaries: &mut q3_shader_boundaries,
q3_styles: &mut q3_styles,
},
) {
Some(action)
} else if let Some(action) = dispatch_qd3d::dispatch_q3_scene_import_fast(
dispatch_qd3d::PpcQ3SceneDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
q3_objects: &mut q3_objects,
next_q3_object: &mut next_q3_object,
q3_cameras: &mut q3_cameras,
q3_lights: &mut q3_lights,
q3_error_state: &mut q3_error_state,
},
) {
Some(action)
} else if let Some(action) =
dispatch_qd3d::dispatch_q3_object_renderer_import_fast(
dispatch_qd3d::PpcQ3ObjectRendererDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
stores: PpcQ3ObjectStores {
q3_objects: &mut q3_objects,
q3_object_refs: &mut q3_object_refs,
q3_renderer_preferences: &mut q3_renderer_preferences,
q3_files: &mut q3_files,
q3_group_memberships: &mut q3_group_memberships,
q3_file_groups: &mut q3_file_groups,
q3_views: &mut q3_views,
q3_submissions: &mut q3_submissions,
q3_view_transforms: &mut q3_view_transforms,
q3_submission_transforms: &mut q3_submission_transforms,
q3_view_materials: &mut q3_view_materials,
q3_submission_materials: &mut q3_submission_materials,
q3_submission_lights: &mut q3_submission_lights,
q3_view_state_stack: &mut q3_view_state_stack,
q3_completed_frames: &mut q3_completed_frames,
q3_retained_frames: &mut q3_retained_frames,
q3_fog_styles: &mut q3_fog_styles,
q3_memory_storages: &mut q3_memory_storages,
q3_attributes: &mut q3_attributes,
q3_shader_uv_transforms: &mut q3_shader_uv_transforms,
q3_shader_boundaries: &mut q3_shader_boundaries,
q3_mipmap_textures: &mut q3_mipmap_textures,
q3_texture_shaders: &mut q3_texture_shaders,
q3_draw_contexts: &mut q3_draw_contexts,
q3_trimeshes: &mut q3_trimeshes,
q3_styles: &mut q3_styles,
q3_cameras: &mut q3_cameras,
q3_lights: &mut q3_lights,
},
q3_error_state: &mut q3_error_state,
next_q3_object: &mut next_q3_object,
},
)
{
Some(action)
} else if let Some(action) = dispatch_qd3d::dispatch_q3_object_group_import_fast(
dispatch_qd3d::PpcQ3ObjectGroupDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
q3_objects: &q3_objects,
q3_object_refs: &mut q3_object_refs,
q3_group_memberships: &q3_group_memberships,
q3_file_groups: &q3_file_groups,
q3_lights: &q3_lights,
q3_error_state: &mut q3_error_state,
},
) {
Some(action)
} else if let Some(action) = dispatch_simple_hot_import_fast(
&binding.dispatcher_target,
cpu,
memory,
ppc_virtual_microseconds(
process_tick,
clock_cycles_per_tick,
clock_cycle_phase,
elapsed,
),
) {
Some(action)
} else if let Some(action) = dispatch_qd3d::dispatch_q3_submit_import_fast(
dispatch_qd3d::PpcQ3SubmitDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
q3_objects: &q3_objects,
q3_group_memberships: &q3_group_memberships,
q3_views: &mut q3_views,
q3_view_transforms: &mut q3_view_transforms,
q3_submissions: &mut q3_submissions,
q3_submission_transforms: &mut q3_submission_transforms,
q3_view_materials: &mut q3_view_materials,
q3_submission_materials: &mut q3_submission_materials,
q3_submission_lights: &mut q3_submission_lights,
q3_view_state_stack: &mut q3_view_state_stack,
q3_attributes: &q3_attributes,
q3_styles: &q3_styles,
q3_shader_boundaries: &q3_shader_boundaries,
q3_shader_uv_transforms: &q3_shader_uv_transforms,
q3_texture_shaders: &q3_texture_shaders,
q3_mipmap_textures: &q3_mipmap_textures,
q3_trimeshes: &q3_trimeshes,
q3_fog_styles: &mut q3_fog_styles,
q3_lights: &q3_lights,
q3_error_state: &mut q3_error_state,
},
) {
Some(action)
} else {
// Borrow process-owned File and Resource Manager records
// only for this import. A Mixed Mode continuation may
// expose another adapter between imports, so no mutable
// reference into an UnsafeCell-backed process collection
// may outlive this dispatch call or be retained in its
// returned action.
let action = process_file_system.with_mut(|file_system| {
let launched_app_path = file_system.launched_app_path.clone();
let ProcessFileSystemState {
files,
writable_refnums,
stdio_streams,
vfs_files,
deleted_vfs_file_paths,
resource_manager,
next_file_ref_num,
..
} = file_system;
screen_clut.with_mut(|screen_clut| {
color_manager_clut.with_mut(|color_manager_clut| {
event_queue.with_mut(|event_queue| {
controls.with_mut(|controls| {
list_manager.with_mut(|list_manager| {
writable_refnums.with_mut(|writable_refnums| {
vfs_directories.with_mut(|vfs_directories| {
working_directories.with_mut(|working_directories| {
next_working_directory_ref_num.with_mut(|next_working_directory_ref_num| {
application_working_directory_ref_num.with_mut(|application_working_directory_ref_num| {
next_vfs_dir_id.with_mut(|next_vfs_dir_id| {
current_resource_refnum.with_mut(|current_resource_refnum| {
resource_manager.with_mut(|resource_manager| {
let ProcessResourceManagerState {
resource_files,
vfs_resource_files,
vfs_resources,
..
} = resource_manager;
current_gworld.with_mut(|current_gworld| {
current_gdevice.with_mut(|current_gdevice| {
files.with_mut(|files| {
dispatch_supported_import(PpcDispatchContext {
binding,
cpu,
memory,
process_memory_manager: &mut *process_memory_manager,
heap_cursor: &mut heap_cursor,
heap_limit,
native_heap_ceiling,
last_mem_error: &mut last_mem_error,
tick_count: &mut import_tick_count,
cycles_per_tick: clock_cycles_per_tick,
current_resource_refnum,
last_resource_error: &mut last_resource_error,
resource_policy: &resource_policy,
native_exception_handler: &native_exception_handler,
stdc_qsort_stack: &mut stdc_qsort_stack,
dialog_callback_stack: &mut dialog_callback_stack,
apple_events: &mut apple_events,
cfm_connections: &mut cfm_connections,
cfm_library_fragments: &mut cfm_library_fragments,
next_cfm_connection_id: &mut next_cfm_connection_id,
import_run_state: &mut import_run_state,
controls,
aliases: &mut aliases,
gworlds: &mut gworlds,
gworld_pixel_states: &gworld_pixel_states,
window_list: &window_list,
q3_objects: &mut q3_objects,
q3_object_refs: &mut q3_object_refs,
next_q3_object: &mut next_q3_object,
q3_error_state: &mut q3_error_state,
q3_lifecycle: &mut q3_lifecycle,
q3_memory_storages: &mut q3_memory_storages,
q3_files: &mut q3_files,
q3_group_memberships: &mut q3_group_memberships,
q3_file_groups: &mut q3_file_groups,
q3_views: &mut q3_views,
q3_submissions: &mut q3_submissions,
q3_view_transforms: &mut q3_view_transforms,
q3_submission_transforms: &mut q3_submission_transforms,
q3_view_materials: &mut q3_view_materials,
q3_submission_materials: &mut q3_submission_materials,
q3_submission_lights: &mut q3_submission_lights,
q3_view_state_stack: &mut q3_view_state_stack,
q3_completed_frames: &mut q3_completed_frames,
q3_retained_frames: &mut q3_retained_frames,
q3_state_only_completed_frame_batches:
&mut q3_state_only_completed_frame_batches,
q3_fog_styles: &mut q3_fog_styles,
q3_attributes: &mut q3_attributes,
q3_shader_uv_transforms: &mut q3_shader_uv_transforms,
q3_shader_boundaries: &mut q3_shader_boundaries,
q3_mipmap_textures: &mut q3_mipmap_textures,
q3_texture_shaders: &mut q3_texture_shaders,
q3_renderer_preferences: &mut q3_renderer_preferences,
q3_draw_contexts: &mut q3_draw_contexts,
q3_trimeshes: &mut q3_trimeshes,
q3_styles: &mut q3_styles,
q3_cameras: &mut q3_cameras,
q3_lights: &mut q3_lights,
input_sprocket: &mut input_sprocket,
input_sprocket_virtual_elements:
&mut input_sprocket_virtual_elements,
toolbox_startup: &mut toolbox_startup,
quicktime: &mut quicktime,
sound: &mut sound,
timer_tasks: &timer_tasks,
vbl_tasks: &vbl_tasks,
callback_scheduling: &callback_scheduling,
files,
writable_refnums,
vfs_files,
stdio_streams,
deleted_vfs_file_paths,
resource_files,
vfs_resource_files,
vfs_resources,
next_file_ref_num,
current_gworld,
current_gdevice,
quickdraw_op_colors: &quickdraw_op_colors,
quickdraw_hilite_colors: &quickdraw_hilite_colors,
screen_clut,
color_manager_clut,
display_gamma: &display_gamma,
quickdraw_fore_color: &mut quickdraw_fore_color,
quickdraw_fore_indices: &mut quickdraw_fore_indices,
quickdraw_back_color: &mut quickdraw_back_color,
quickdraw_pen_h: &mut quickdraw_pen_h,
quickdraw_pen_v: &mut quickdraw_pen_v,
quickdraw_text_mode: &mut quickdraw_text_mode,
quickdraw_text_size: &mut quickdraw_text_size,
cursor_state: &cursor_state,
vfs_volumes: &vfs_volumes,
vfs_directories,
next_vfs_dir_id,
default_dir_id: *default_dir_id,
working_directories,
next_working_directory_ref_num,
application_working_directory_ref_num,
launched_app_path: launched_app_path.as_deref(),
param_text: ¶m_text,
scrap: &mut scrap,
list_manager,
input,
event_queue,
draw_sprocket: &mut draw_sprocket,
})
})
})
})
})
})
})
})
})
})
})
})
})
})
})
})
})
});
action
};
ppc_sync_process_window_list(memory, &window_list);
// MemError is process Memory Manager state even when a
// Toolbox helper reports it through the native ABI cache.
// Publish at the import boundary so a following 68K callback
// observes the result immediately, not at slice teardown.
process_memory_manager.set_native_mem_error(last_mem_error);
let _ = memory.write_u16_be(
crate::memory::globals::addr::RES_ERR,
last_resource_error as u16,
);
// Resource records are the native Resource Manager's parsed
// view, while the classic adapter opens the same process fork
// through its byte map. Publish every dirty parsed mutation at
// the import boundary so a following 68K callback observes it
// without waiting for runner teardown or host persistence.
process_file_system.resource_manager.with_mut(|resource_manager| {
ppc_publish_resource_fork_bytes(
&mut resource_manager.vfs_resource_files,
&resource_manager.vfs_resources,
true,
);
});
let current_default_dir_id = *default_dir_id;
let updated_default_dir_id = memory
.read_u32_be(crate::memory::globals::addr::CUR_DIR_STORE)
.unwrap_or(current_default_dir_id);
default_dir_id.with_mut(|default_dir_id| {
*default_dir_id = updated_default_dir_id;
});
match action {
Some(action) => {
let action = ppc_import_action_with_extra_cycles(
action,
ppc_import_extra_cycles_for_binding(binding),
);
if trace_imports {
if let (Some(action_name), Some(result)) = (
ppc_draw_sprocket_action_name(&binding.dispatcher_target),
ppc_i16_return_value(&action),
) {
draw_sprocket_trace.push(ppc_draw_sprocket_trace_entry(
index,
cpu.pc,
memory,
cpu,
action_name,
result,
&draw_sprocket,
));
}
}
if trace_imports
&& binding.dispatcher_target
== PpcImportDispatcherTarget::ISpElementGetSimpleState
&& matches!(action, PpcImportAction::Return(0))
{
if let Some(entry) = ppc_isp_simple_state_trace_entry(
index,
cpu.pc,
cpu,
memory,
input,
input_sprocket,
&input_sprocket_virtual_elements,
) {
input_sprocket_trace.push(entry);
}
}
if trace_this_sprocket {
if let Some(entry) = entry.as_ref() {
eprintln!(
"{}",
format_sprocket_trace(
entry,
import_args,
&format_sprocket_action(&action),
&draw_sprocket,
&input_sprocket,
&input_sprocket_virtual_elements
)
);
}
}
if trace_this_qd3d {
if let (Some(entry), Some(before)) =
(entry.as_ref(), qd3d_before.as_ref())
{
let after = qd3d_trace_snapshot(
&q3_objects,
&q3_views,
&q3_submissions,
&q3_completed_frames,
&q3_state_only_completed_frame_batches,
&q3_memory_storages,
&q3_files,
&q3_group_memberships,
&q3_trimeshes,
&q3_draw_contexts,
&q3_mipmap_textures,
&q3_texture_shaders,
&q3_styles,
&q3_cameras,
&q3_lights,
);
eprintln!(
"{}",
format_qd3d_trace(
entry,
import_args,
&format_hle_import_action(&action),
before,
&after
)
);
}
}
handled_import_count = handled_import_count.saturating_add(1);
guest_calls.externalize_powerpc_action(cpu, action)
}
None => {
if trace_this_sprocket {
if let Some(entry) = entry.as_ref() {
eprintln!(
"{}",
format_sprocket_trace(
entry,
import_args,
"unsupported",
&draw_sprocket,
&input_sprocket,
&input_sprocket_virtual_elements
)
);
}
}
if trace_this_qd3d {
if let (Some(entry), Some(before)) =
(entry.as_ref(), qd3d_before.as_ref())
{
let after = qd3d_trace_snapshot(
&q3_objects,
&q3_views,
&q3_submissions,
&q3_completed_frames,
&q3_state_only_completed_frame_batches,
&q3_memory_storages,
&q3_files,
&q3_group_memberships,
&q3_trimeshes,
&q3_draw_contexts,
&q3_mipmap_textures,
&q3_texture_shaders,
&q3_styles,
&q3_cameras,
&q3_lights,
);
eprintln!(
"{}",
format_qd3d_trace(
entry,
import_args,
"unsupported",
before,
&after
)
);
}
}
unsupported_import_index = Some(index);
PpcImportAction::Halt
}
}
};
let mut total_cycles = 0u64;
loop {
let remaining_cycles = max_cycles.saturating_sub(total_cycles);
if remaining_cycles == 0 {
break PpcRunResult::CycleLimit {
cycles: total_cycles,
};
}
let step_result = if let Some(range) = ppc_watch_range() {
let mut write_observer = PpcWatchObserver { range };
self.cpu.run_with_imports_and_observers_and_cycle_handler(
&mut self.memory,
remaining_cycles,
self.halt_pc,
self.import_trap_base,
PPC_IMPORT_SLOT_COUNT,
&mut fetch_observer,
&mut write_observer,
&mut handle_import,
)
} else if needs_fetch_observer {
self.cpu
.run_with_imports_and_fetch_observer_and_cycle_handler(
&mut self.memory,
remaining_cycles,
self.halt_pc,
self.import_trap_base,
PPC_IMPORT_SLOT_COUNT,
&mut fetch_observer,
&mut handle_import,
)
} else {
self.cpu.run_with_imports_and_cycle_handler(
&mut self.memory,
remaining_cycles,
self.halt_pc,
self.import_trap_base,
PPC_IMPORT_SLOT_COUNT,
&mut handle_import,
)
};
total_cycles = total_cycles.saturating_add(ppc_run_result_cycles(step_result));
match step_result {
PpcRunResult::Exception { pc, exception, .. }
if native_exception_handler.get() != 0
&& ppc_native_exception_kind(exception).is_some() =>
{
let Some(context) = ppc_begin_native_exception(
&mut self.cpu,
&mut self.memory,
self.stack_base,
native_exception_handler.get(),
pc,
PpcNativeExceptionCause::Processor(exception),
) else {
break ppc_run_result_with_cycles(step_result, total_cycles);
};
native_exception_stack.push(context);
}
PpcRunResult::MemoryFault {
pc,
addr,
was_write,
..
} if native_exception_handler.get() != 0 => {
let Some(context) = ppc_begin_native_exception(
&mut self.cpu,
&mut self.memory,
self.stack_base,
native_exception_handler.get(),
pc,
PpcNativeExceptionCause::UnmappedMemory {
address: addr,
was_write,
},
) else {
break ppc_run_result_with_cycles(step_result, total_cycles);
};
native_exception_stack.push(context);
}
PpcRunResult::Halted { pc, .. }
if pc == self.halt_pc && !native_exception_stack.is_empty() =>
{
let context = native_exception_stack.pop().expect("checked nonempty");
let handler_result = self.cpu.gpr[3];
let restored =
ppc_restore_native_exception(&mut self.cpu, &mut self.memory, context)
.is_some();
if handler_result == 0 && restored {
continue;
}
native_exception_stack.clear();
break ppc_native_exception_result(context, total_cycles);
}
PpcRunResult::CycleLimit { .. } => {
break ppc_run_result_with_cycles(step_result, total_cycles);
}
_ => {
native_exception_stack.clear();
break ppc_run_result_with_cycles(step_result, total_cycles);
}
}
}
};
drop(fetch_observer);
// Native execution never projects a scalar baseline back into guest
// memory. Low-memory `Ticks` remains the source of truth, including
// when a nested Mixed Mode callback changed it during this slice.
self.native_exception_handler = native_exception_handler.get();
self.native_exception_stack = native_exception_stack;
self.stdc_qsort_stack = stdc_qsort_stack;
self.dialog_callback_stack = dialog_callback_stack;
self.apple_events = apple_events;
self.cfm = standalone_cfm;
(self.imports, self.import_count) = import_run_state.into_parts();
self.controls = controls;
self.aliases = aliases;
self.gworlds = gworlds;
self.q3_objects = q3_objects;
self.q3_object_refs = q3_object_refs;
self.next_q3_object = next_q3_object;
self.q3_error_state = q3_error_state;
self.q3_lifecycle = q3_lifecycle;
self.q3_memory_storages = q3_memory_storages;
self.q3_files = q3_files;
self.q3_group_memberships = q3_group_memberships;
self.q3_file_groups = q3_file_groups;
self.q3_views = q3_views;
self.q3_submissions = q3_submissions;
self.q3_view_transforms = q3_view_transforms;
self.q3_submission_transforms = q3_submission_transforms;
self.q3_view_materials = q3_view_materials;
self.q3_submission_materials = q3_submission_materials;
self.q3_submission_lights = q3_submission_lights;
self.q3_view_state_stack = q3_view_state_stack;
self.q3_completed_frames = q3_completed_frames;
self.q3_retained_frames = q3_retained_frames;
self.q3_state_only_completed_frame_batches = q3_state_only_completed_frame_batches;
self.q3_fog_styles = q3_fog_styles;
self.q3_attributes = q3_attributes;
self.q3_shader_uv_transforms = q3_shader_uv_transforms;
self.q3_shader_boundaries = q3_shader_boundaries;
self.q3_mipmap_textures = q3_mipmap_textures;
self.q3_texture_shaders = q3_texture_shaders;
self.q3_renderer_preferences = q3_renderer_preferences;
self.q3_draw_contexts = q3_draw_contexts;
self.q3_trimeshes = q3_trimeshes;
self.q3_styles = q3_styles;
self.q3_cameras = q3_cameras;
self.q3_lights = q3_lights;
self.input_sprocket = input_sprocket;
self.input_sprocket_virtual_elements = input_sprocket_virtual_elements;
self.toolbox_startup = toolbox_startup;
self.quicktime = quicktime;
self.sound = sound;
self.timer_tasks = timer_tasks;
self.vbl_tasks = vbl_tasks;
self.quickdraw_fore_color = quickdraw_fore_color;
self.quickdraw_fore_indices = quickdraw_fore_indices;
self.quickdraw_back_color = quickdraw_back_color;
self.quickdraw_pen_h = quickdraw_pen_h;
self.quickdraw_pen_v = quickdraw_pen_v;
self.quickdraw_text_mode = quickdraw_text_mode;
self.quickdraw_text_size = quickdraw_text_size;
self.cursor_state = cursor_state;
process_file_system.with_mut(ProcessFileSystemState::publish_native_vfs_catalogue);
self.scrap = scrap;
self.list_manager = list_manager;
self.event_queue = event_queue;
self.draw_sprocket = draw_sprocket;
if trace_recent_on_halt && !matches!(result, PpcRunResult::CycleLimit { .. }) {
let indirect = self.cpu.gpr[12];
eprintln!(
"[PPC-RECENT-IMPORTS] result={result:?} pc=${:08X} lr=${:08X} ctr=${:08X} r2=${:08X} r12=${:08X} indirect=({:?}, {:?})",
self.cpu.pc,
self.cpu.lr,
self.cpu.ctr,
self.cpu.gpr[2],
indirect,
self.memory.read_u32_be(indirect),
self.memory.read_u32_be(indirect.wrapping_add(4)),
);
for entry in &recent_imports {
eprintln!("{}", format_ppc_trace_import(entry));
}
}
PpcHleRunProbe {
result,
handled_import_count,
last_import_index,
unsupported_import_index,
import_trace,
draw_sprocket_trace,
input_sprocket_trace,
fetch_histogram: trace_fetches.then_some(fetch_histogram),
}
}
pub fn seed_vfs_directories(
&mut self,
directories: Vec<PpcVfsDirectory>,
default_dir_id: u32,
next_dir_id: u32,
) {
let max_seeded_dir_id = directories
.iter()
.map(|directory| directory.dir_id)
.max()
.unwrap_or(PPC_ROOT_DIR_ID);
self.vfs_directories.replace(directories);
self.default_dir_id
.with_mut(|current_dir_id| *current_dir_id = default_dir_id);
let _ = self
.memory
.write_u32_be(crate::memory::globals::addr::CUR_DIR_STORE, default_dir_id);
let next_dir_id = next_dir_id
.max(max_seeded_dir_id.saturating_add(1))
.max(PPC_FIRST_DYNAMIC_DIR_ID);
self.next_vfs_dir_id
.with_mut(|cursor| *cursor = next_dir_id);
}
pub fn seed_vfs_volumes(&mut self, volumes: Vec<PpcVfsVolumeRecord>) {
let next_ref_num = volumes
.iter()
.map(|volume| volume.ref_num)
.min()
.unwrap_or(PPC_BOOT_VOLUME_REF_NUM)
.saturating_sub(1)
.min(-2);
self.next_vfs_volume_ref_num
.with_mut(|cursor| *cursor = next_ref_num);
self.vfs_volumes.replace(volumes);
}
pub fn set_launched_app_path(&mut self, path: impl Into<String>) {
let path = ppc_normalize_vfs_path(&path.into());
self.process_file_system
.with_mut(|file_system| file_system.launched_app_path = Some(path));
self.refresh_apple_event_launch_capability();
}
pub fn launched_app_path(&self) -> Option<&str> {
self.process_file_system.launched_app_path.as_deref()
}
pub fn seed_cfm_library_fragments(&mut self, fragments: Vec<PpcCfmLibraryFragment>) {
self.cfm
.as_mut()
.expect("seed CFM libraries before process installation")
.library_fragments = fragments;
}
pub fn seed_vfs_files_and_resources(
&mut self,
files: Vec<PpcVfsFileRecord>,
resource_files: Vec<PpcVfsResourceFileRecord>,
resources: Vec<PpcVfsResourceRecord>,
) {
ppc_register_vfs_resource_fonts(&resources);
self.process_file_system.with_mut(|file_system| {
file_system.vfs_files.replace(files);
file_system.deleted_vfs_file_paths.clear();
file_system.with_resource_manager_mut(|resource_manager| {
resource_manager.vfs_resource_files.replace(resource_files);
resource_manager.vfs_resources = resources;
ppc_publish_resource_fork_bytes(
&mut resource_manager.vfs_resource_files,
&resource_manager.vfs_resources,
false,
);
});
});
self.refresh_apple_event_launch_capability();
}
pub(crate) fn launch_size_resource(&self) -> Option<ApplicationSizeResource> {
self.launched_app_path().and_then(|path| {
[0, -1].into_iter().find_map(|id| {
self.vfs_resources
.iter()
.find(|resource| {
resource.path.eq_ignore_ascii_case(path)
&& resource.res_type == u32::from_be_bytes(*b"SIZE")
&& resource.res_id == id
})
.and_then(|resource| ApplicationSizeResource::parse(&resource.data))
.filter(|size| size.preferred_partition_size().is_some())
})
})
}
fn refresh_apple_event_launch_capability(&mut self) {
let size_resource = self.launch_size_resource();
let high_level_event_aware =
size_resource.is_some_and(ApplicationSizeResource::is_high_level_event_aware);
self.apple_events
.apple_event_launch_state
.set_high_level_event_aware(high_level_event_aware);
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] launch AppleEvents aware={} path={:?} SIZE={:?}",
high_level_event_aware,
self.launched_app_path(),
size_resource,
);
}
}
/// Prepare resource forks extracted by InstallerMaker for native launch.
///
/// InstallerMaker can leave an ordinary resource fork on the destination
/// file while storing additional resources in a shared `qDir`/data-fork
/// pair. Its installed forks can also contain compressed resources that
/// rely on the installer to decode them. The in-process Resource Manager
/// handles both cases lazily; native launchers need complete, decoded
/// forks before handing the tree to a real Mac environment.
pub fn prepare_vfs_resource_forks_for_native_export(&mut self) -> usize {
self.process_file_system.with_mut(|file_system| {
let ProcessFileSystemState {
vfs_files,
resource_manager,
..
} = file_system;
resource_manager.with_mut(|resource_manager| {
let ProcessResourceManagerState {
vfs_resource_files,
vfs_resources,
..
} = resource_manager;
let paths = vfs_resource_files
.iter()
.map(|file| file.path.clone())
.collect::<Vec<_>>();
for path in &paths {
ppc_materialize_resource_records_for_path(
vfs_resource_files,
vfs_resources,
path,
);
}
for path in &paths {
ppc_materialize_quilt_resources_for_existing_path(
vfs_files,
vfs_resource_files,
vfs_resources,
path,
);
}
let mut prepared_count = 0usize;
for path in paths {
let has_parseable_fork = vfs_resource_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(&path))
.and_then(|file| file.raw_data.as_deref())
.and_then(|bytes| ResourceFork::parse(bytes))
.is_some();
let mut path_resource_count = 0usize;
for resource in vfs_resources
.iter_mut()
.filter(|resource| resource.path.eq_ignore_ascii_case(&path))
{
resource.raw_data = None;
resource.raw_attrs = None;
path_resource_count += 1;
}
if !has_parseable_fork && path_resource_count == 0 {
continue;
}
ppc_mark_resource_file_contents_dirty(vfs_resource_files, &path);
prepared_count += 1;
}
prepared_count
})
})
}
pub fn take_deleted_vfs_file_paths(&mut self) -> Vec<String> {
self.process_file_system.with_mut(|file_system| {
file_system.publish_native_vfs_catalogue();
std::mem::take(&mut file_system.deleted_vfs_file_paths)
})
}
pub fn take_dirty_vfs_files(&mut self) -> Vec<PpcVfsFileExport> {
self.process_file_system.with_mut(|file_system| {
let mut exports = Vec::new();
for file in file_system
.vfs_files
.iter_mut()
.filter(|file| file.dirty && !file.path.is_empty())
{
exports.push(PpcVfsFileExport {
path: file.path.clone(),
data: file.data.shared_handle(),
creator: file.creator,
file_type: file.file_type,
finder_flags: file.finder_flags,
});
file.dirty = false;
}
exports
})
}
pub fn take_dirty_vfs_directories(&mut self) -> Vec<PpcVfsDirectoryExport> {
self.vfs_directories.with_mut(|directories| {
let mut exports = Vec::new();
for directory in directories
.iter_mut()
.filter(|directory| directory.dirty && !directory.path.is_empty())
{
exports.push(PpcVfsDirectoryExport {
path: directory.path.clone(),
creator: directory.creator,
file_type: directory.file_type,
finder_flags: directory.finder_flags,
});
directory.dirty = false;
}
exports
})
}
pub fn take_dirty_vfs_resource_forks(&mut self) -> Vec<PpcVfsResourceForkExport> {
self.process_file_system
.with_resource_manager_mut(|resource_manager| {
let mut exports = Vec::new();
let ProcessResourceManagerState {
vfs_resource_files,
vfs_resources,
..
} = resource_manager;
ppc_publish_resource_fork_bytes(vfs_resource_files, vfs_resources, true);
let dirty_indices = vfs_resource_files
.iter()
.enumerate()
.filter_map(|(index, file)| {
(file.dirty && !file.path.is_empty()).then_some(index)
})
.collect::<Vec<_>>();
for index in dirty_indices {
let file = &vfs_resource_files[index];
let path = file.path.clone();
let data = vfs_resource_files.fork(&path).map(|bytes| bytes.to_vec());
if let Some(data) = data {
exports.push(PpcVfsResourceForkExport {
path,
data,
creator: file.creator,
file_type: file.file_type,
finder_flags: file.finder_flags,
});
vfs_resource_files[index].dirty = false;
}
}
exports
})
}
}
fn ppc_serialized_resource_fork(
file: &PpcVfsResourceFileRecord,
vfs_resources: &[PpcVfsResourceRecord],
) -> Option<Vec<u8>> {
if let Some(raw_data) = file.raw_data.as_ref() {
return Some(raw_data.to_vec());
}
let entries = vfs_resources
.iter()
.filter(|resource| resource.path.eq_ignore_ascii_case(&file.path))
.map(|resource| {
let (data, attrs) = match (&resource.raw_data, resource.raw_attrs) {
(Some(raw_data), Some(raw_attrs)) => (raw_data.clone(), raw_attrs),
_ => (resource.data.clone(), resource.attrs),
};
ResourceForkEntry {
res_type: resource.res_type.to_be_bytes(),
id: resource.res_id,
name: resource.name.clone(),
data,
attrs: (attrs & 0x00ff) as u8,
}
})
.collect::<Vec<_>>();
serialize_resource_fork_with_attrs(&entries, file.map_attrs)
}
fn ppc_publish_resource_fork_bytes(
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
vfs_resources: &[PpcVfsResourceRecord],
dirty_only: bool,
) {
let indices = vfs_resource_files
.iter()
.enumerate()
.filter_map(|(index, file)| {
(!file.path.is_empty() && (!dirty_only || file.dirty)).then_some(index)
})
.collect::<Vec<_>>();
for index in indices {
let Some(data) = ppc_serialized_resource_fork(&vfs_resource_files[index], vfs_resources)
else {
continue;
};
let path = vfs_resource_files[index].path.clone();
vfs_resource_files[index].resource_len = u32::try_from(data.len()).unwrap_or(u32::MAX);
vfs_resource_files.update_fork(&path, &data);
}
}
fn ppc_q3_submission_transform_matches(
record: &PpcQ3SubmissionTransformRecord,
submission: &PpcQ3SubmissionRecord,
) -> bool {
record.view == submission.view
&& record.kind == submission.kind
&& record.primary == submission.primary
&& record.secondary == submission.secondary
}
fn ppc_q3_submission_material_matches(
record: &PpcQ3SubmissionMaterialRecord,
submission: &PpcQ3SubmissionRecord,
) -> bool {
record.view == submission.view
&& record.kind == submission.kind
&& record.primary == submission.primary
&& record.secondary == submission.secondary
}
fn ppc_q3_submission_light_matches(
record: &PpcQ3SubmissionLightRecord,
submission: &PpcQ3SubmissionRecord,
) -> bool {
record.view == submission.view
&& record.kind == submission.kind
&& record.primary == submission.primary
&& record.secondary == submission.secondary
}
fn ppc_q3_trimesh_header_u32(data: &[u8], offset: u32) -> Option<u32> {
let offset = usize::try_from(offset).ok()?;
let bytes = data.get(offset..offset.checked_add(4)?)?;
Some(u32::from_be_bytes(bytes.try_into().ok()?))
}
fn ppc_q3_trace_trimesh_header(action: &str, cpu: &PpcCpu, trimesh: u32, data: &[u8]) {
if !qd3d_trimesh_trace_enabled() {
return;
}
let field = |offset| ppc_q3_trimesh_header_u32(data, offset).unwrap_or(0);
eprintln!(
"[QD3D-TRIMESH] {} lr=${:08X} mesh=${:08X} r4=${:08X} tri={}/${:08X} tri_attr={}/${:08X} edges={}/${:08X} edge_attr={}/${:08X} points={}/${:08X} vertex_attr={}/${:08X}",
action,
cpu.lr,
trimesh,
cpu.gpr[4],
field(PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET),
field(PPC_Q3_TRIMESH_TRIANGLES_OFFSET),
field(PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET),
field(PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET),
field(PPC_Q3_TRIMESH_NUM_EDGES_OFFSET),
field(PPC_Q3_TRIMESH_EDGES_OFFSET),
field(PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET),
field(PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET),
field(PPC_Q3_TRIMESH_NUM_POINTS_OFFSET),
field(PPC_Q3_TRIMESH_POINTS_OFFSET),
field(PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET),
field(PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET),
);
}
fn ppc_q3_point_finite((x, y, z): (f32, f32, f32)) -> bool {
x.is_finite() && y.is_finite() && z.is_finite()
}
fn ppc_q3_color_finite((red, green, blue): (f32, f32, f32)) -> bool {
red.is_finite() && green.is_finite() && blue.is_finite()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcQ3SoftwareTexture {
image_base: u32,
valid_size: u32,
image_offset: u32,
width: u32,
height: u32,
row_bytes: u32,
pixel_type: u32,
byte_order: u32,
pixel_bytes: u32,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PpcQ3SoftwareTextureSample {
color: (f32, f32, f32),
opacity: f32,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PpcQ3SoftwareMaterialSample {
diffuse: (f32, f32, f32),
ambient_coefficient: f32,
specular_color: (f32, f32, f32),
specular_control: f32,
highlight_state: bool,
transparency: (f32, f32, f32),
illumination_type: u32,
texture: Option<PpcQ3SoftwareTexture>,
uv_transform: Option<[[f32; 3]; 3]>,
shader_boundary: Option<PpcQ3ShaderBoundaryRecord>,
fog_style: Option<PpcQ3FogStyleData>,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PpcQ3SoftwareMaterialOutput {
color: (f32, f32, f32),
opacity: f32,
}
fn ppc_q3_software_material_sample(
q3_objects: &[PpcQ3ObjectRecord],
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
material: &PpcQ3SubmissionMaterialRecord,
) -> PpcQ3SoftwareMaterialSample {
PpcQ3SoftwareMaterialSample {
diffuse: ppc_q3_software_material_diffuse_color(material),
ambient_coefficient: ppc_q3_software_material_ambient_coefficient(material),
specular_color: ppc_q3_software_material_specular_color(material),
specular_control: ppc_q3_software_material_specular_control(material),
highlight_state: ppc_q3_software_material_highlight_state(material),
transparency: ppc_q3_software_material_transparency_color(material),
illumination_type: ppc_q3_software_illumination_type(material.illumination_type),
texture: ppc_q3_software_material_texture(q3_objects, q3_memory_storages, material),
uv_transform: material.shader_uv_transform.map(|record| record.matrix),
shader_boundary: material.shader_boundary,
fog_style: material.fog_style,
}
}
fn ppc_q3_software_uses_ambient_coefficients(
material: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
) -> bool {
material.illumination_type != PPC_Q3_ILLUMINATION_TYPE_NULL
&& lights
.lights
.iter()
.any(|light| light.data.is_on != 0 && matches!(light.kind, PpcQ3LightKind::Ambient))
}
fn ppc_q3_software_uses_normals(
material: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
) -> bool {
material.illumination_type != PPC_Q3_ILLUMINATION_TYPE_NULL
&& lights
.lights
.iter()
.any(|light| light.data.is_on != 0 && !matches!(light.kind, PpcQ3LightKind::Ambient))
}
fn ppc_q3_software_uses_specular_attributes(
material: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
) -> bool {
material.illumination_type == PPC_Q3_ILLUMINATION_TYPE_PHONG
&& ppc_q3_software_uses_normals(material, lights)
}
fn ppc_q3_software_fill_style(material: &PpcQ3SubmissionMaterialRecord) -> u32 {
material
.styles
.iter()
.find(|record| record.kind == PpcQ3StyleKind::Fill)
.map(|record| record.value)
.unwrap_or(PPC_Q3_FILL_STYLE_FILLED)
}
fn ppc_q3_software_backfacing_style(material: &PpcQ3SubmissionMaterialRecord) -> u32 {
material
.styles
.iter()
.find(|record| record.kind == PpcQ3StyleKind::Backfacing)
.map(|record| record.value)
.unwrap_or(PPC_Q3_BACKFACING_STYLE_BOTH)
}
fn ppc_q3_software_orientation_style(material: &PpcQ3SubmissionMaterialRecord) -> u32 {
material
.styles
.iter()
.find(|record| record.kind == PpcQ3StyleKind::Orientation)
.map(|record| record.value)
.unwrap_or(PPC_Q3_ORIENTATION_STYLE_COUNTER_CLOCKWISE)
}
fn ppc_q3_software_interpolation_style(material: &PpcQ3SubmissionMaterialRecord) -> u32 {
material
.styles
.iter()
.find(|record| record.kind == PpcQ3StyleKind::Interpolation)
.map(|record| record.value)
.unwrap_or(PPC_Q3_INTERPOLATION_STYLE_PIXEL)
}
fn ppc_q3_software_material_diffuse_color(
material: &PpcQ3SubmissionMaterialRecord,
) -> (f32, f32, f32) {
material
.attributes
.iter()
.find(|record| record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR)
.and_then(|record| {
Some((
ppc_q3_read_f32_from_slice(&record.data, 0)?,
ppc_q3_read_f32_from_slice(&record.data, 4)?,
ppc_q3_read_f32_from_slice(&record.data, 8)?,
))
})
// QuickDraw 3D 1.5.4, View Objects, p. 907: default view attributes.
.unwrap_or((0.5, 0.5, 0.5))
}
fn ppc_q3_software_material_ambient_coefficient(material: &PpcQ3SubmissionMaterialRecord) -> f32 {
material
.attributes
.iter()
.find(|record| record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT)
.and_then(|record| ppc_q3_read_f32_from_slice(&record.data, 0))
.filter(|value| value.is_finite())
.map(|value| value.clamp(0.0, 1.0))
.unwrap_or(1.0)
}
fn ppc_q3_software_material_specular_color(
material: &PpcQ3SubmissionMaterialRecord,
) -> (f32, f32, f32) {
material
.attributes
.iter()
.find(|record| record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR)
.and_then(|record| {
Some((
ppc_q3_read_f32_from_slice(&record.data, 0)?,
ppc_q3_read_f32_from_slice(&record.data, 4)?,
ppc_q3_read_f32_from_slice(&record.data, 8)?,
))
})
// QuickDraw 3D 1.5.4, View Objects, p. 907: default view attributes.
.unwrap_or((0.5, 0.5, 0.5))
}
fn ppc_q3_software_material_specular_control(material: &PpcQ3SubmissionMaterialRecord) -> f32 {
material
.attributes
.iter()
.find(|record| record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL)
.and_then(|record| ppc_q3_read_f32_from_slice(&record.data, 0))
.filter(|value| value.is_finite() && *value >= 0.0)
// QuickDraw 3D 1.5.4, View Objects, p. 907: default view attributes.
.unwrap_or(4.0)
}
fn ppc_q3_software_material_highlight_state(material: &PpcQ3SubmissionMaterialRecord) -> bool {
material
.attributes
.iter()
.find(|record| record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE)
.and_then(|record| ppc_q3_read_u32_from_slice(&record.data, 0))
.map(|value| value != 0)
.unwrap_or(true)
}
fn ppc_q3_software_material_transparency_color(
material: &PpcQ3SubmissionMaterialRecord,
) -> (f32, f32, f32) {
material
.attributes
.iter()
.find(|record| record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR)
.and_then(|record| {
Some((
ppc_q3_software_transparency_component(ppc_q3_read_f32_from_slice(
&record.data,
0,
)?),
ppc_q3_software_transparency_component(ppc_q3_read_f32_from_slice(
&record.data,
4,
)?),
ppc_q3_software_transparency_component(ppc_q3_read_f32_from_slice(
&record.data,
8,
)?),
))
})
.unwrap_or((1.0, 1.0, 1.0))
}
fn ppc_q3_software_transparency_component(value: f32) -> f32 {
if value.is_finite() {
value.clamp(0.0, 1.0)
} else {
0.0
}
}
fn ppc_q3_software_transparency_color_alpha(color: (f32, f32, f32)) -> Option<f32> {
if !color.0.is_finite() || !color.1.is_finite() || !color.2.is_finite() {
return None;
}
Some(
(ppc_q3_software_transparency_component(color.0)
+ ppc_q3_software_transparency_component(color.1)
+ ppc_q3_software_transparency_component(color.2))
/ 3.0,
)
}
fn ppc_q3_software_material_uses_alpha_fog(fog_style: Option<PpcQ3FogStyleData>) -> bool {
matches!(
fog_style,
Some(PpcQ3FogStyleData {
state: 1,
mode: PPC_Q3_FOG_MODE_ALPHA,
..
})
)
}
#[cfg(test)]
fn ppc_q3_software_material_color(
memory: &mut PpcSectionMem,
sample: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
uv: Option<(f32, f32)>,
diffuse: Option<(f32, f32, f32)>,
normal: Option<(f32, f32, f32)>,
specular_color: Option<(f32, f32, f32)>,
specular_control: Option<f32>,
fog_depth: f32,
vertex_alpha: Option<f32>,
) -> (f32, f32, f32) {
ppc_q3_software_material_shaded_output(
memory,
sample,
lights,
uv,
diffuse,
None,
normal,
specular_color,
specular_control,
None,
None,
Some((0.0, 0.0, 1.0)),
fog_depth,
vertex_alpha,
)
.color
}
fn ppc_q3_software_material_shaded_output(
memory: &mut PpcSectionMem,
sample: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
uv: Option<(f32, f32)>,
diffuse: Option<(f32, f32, f32)>,
ambient_coefficient: Option<f32>,
normal: Option<(f32, f32, f32)>,
specular_color: Option<(f32, f32, f32)>,
specular_control: Option<f32>,
highlight_state: Option<bool>,
world: Option<(f32, f32, f32)>,
view_direction: Option<(f32, f32, f32)>,
fog_depth: f32,
vertex_alpha: Option<f32>,
) -> PpcQ3SoftwareMaterialOutput {
let diffuse = diffuse.unwrap_or(sample.diffuse);
let texture_sample = sample.texture.and_then(|texture| {
uv.and_then(|uv| ppc_q3_software_transform_uv(uv, sample.uv_transform))
.and_then(|uv| {
ppc_q3_software_texture_sample(memory, texture, sample.shader_boundary, uv.0, uv.1)
})
.or_else(|| ppc_q3_software_texture_pixel_at(memory, texture, 0, 0))
});
let texture_opacity = texture_sample.map(|texture| texture.opacity).unwrap_or(1.0);
let color = texture_sample
.map(|texture| {
(
diffuse.0 * texture.color.0,
diffuse.1 * texture.color.1,
diffuse.2 * texture.color.2,
)
})
.unwrap_or(diffuse);
let specular_color = if highlight_state.unwrap_or(sample.highlight_state) {
specular_color.unwrap_or(sample.specular_color)
} else {
(0.0, 0.0, 0.0)
};
let color = ppc_q3_software_apply_lights(
color,
ambient_coefficient.unwrap_or(sample.ambient_coefficient),
specular_color,
specular_control.unwrap_or(sample.specular_control),
sample.illumination_type,
lights,
normal,
world,
view_direction,
);
PpcQ3SoftwareMaterialOutput {
color: ppc_q3_software_apply_fog(color, sample.fog_style, fog_depth, vertex_alpha),
opacity: texture_opacity,
}
}
fn ppc_q3_software_apply_texture_and_fog(
memory: &mut PpcSectionMem,
sample: &PpcQ3SoftwareMaterialSample,
uv: Option<(f32, f32)>,
fog_depth: f32,
vertex_alpha: Option<f32>,
output: PpcQ3SoftwareMaterialOutput,
) -> PpcQ3SoftwareMaterialOutput {
let texture_sample = sample.texture.and_then(|texture| {
uv.and_then(|uv| ppc_q3_software_transform_uv(uv, sample.uv_transform))
.and_then(|uv| {
ppc_q3_software_texture_sample(memory, texture, sample.shader_boundary, uv.0, uv.1)
})
.or_else(|| ppc_q3_software_texture_pixel_at(memory, texture, 0, 0))
});
let color = texture_sample
.map(|texture| {
(
output.color.0 * texture.color.0,
output.color.1 * texture.color.1,
output.color.2 * texture.color.2,
)
})
.unwrap_or(output.color);
PpcQ3SoftwareMaterialOutput {
color: ppc_q3_software_apply_fog(color, sample.fog_style, fog_depth, vertex_alpha),
opacity: output.opacity * texture_sample.map(|texture| texture.opacity).unwrap_or(1.0),
}
}
fn ppc_q3_software_transform_uv(
(u, v): (f32, f32),
uv_transform: Option<[[f32; 3]; 3]>,
) -> Option<(f32, f32)> {
if !u.is_finite() || !v.is_finite() {
return None;
}
let Some(matrix) = uv_transform else {
return Some((u, v));
};
let tu = u.mul_add(matrix[0][0], v.mul_add(matrix[1][0], matrix[2][0]));
let tv = u.mul_add(matrix[0][1], v.mul_add(matrix[1][1], matrix[2][1]));
let tw = u.mul_add(matrix[0][2], v.mul_add(matrix[1][2], matrix[2][2]));
if !tu.is_finite() || !tv.is_finite() || !tw.is_finite() || tw == 0.0 {
return None;
}
if tw != 1.0 {
Some((tu / tw, tv / tw))
} else {
Some((tu, tv))
}
}
fn ppc_q3_software_geometric_normal(
points: [(f32, f32, f32); 3],
orientation: u32,
) -> Option<(f32, f32, f32)> {
let normal = ppc_q3_vector3d_cross_values(
ppc_q3_vector3d_sub(points[1], points[0]),
ppc_q3_vector3d_sub(points[2], points[0]),
);
let normal = if orientation == PPC_Q3_ORIENTATION_STYLE_CLOCKWISE {
(-normal.0, -normal.1, -normal.2)
} else {
normal
};
ppc_q3_vector3d_normalized_value(normal)
}
fn ppc_q3_software_transform_normal(
normal: (f32, f32, f32),
local_to_world: [[f32; 4]; 4],
) -> Option<(f32, f32, f32)> {
let normal_matrix = ppc_q3_matrix4x4_invert_values(local_to_world)
.map(ppc_q3_matrix4x4_transpose_values)
.unwrap_or(local_to_world);
ppc_q3_vector3d_normalized_value(ppc_q3_vector3d_transform_values(normal, normal_matrix))
}
fn ppc_q3_software_material_texture(
q3_objects: &[PpcQ3ObjectRecord],
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
material: &PpcQ3SubmissionMaterialRecord,
) -> Option<PpcQ3SoftwareTexture> {
let mipmap = material.mipmap_texture.as_ref()?;
let storage = ppc_q3_read_u32_from_slice(&mipmap.mipmap, PPC_Q3_MIPMAP_IMAGE_OFFSET)?;
let pixel_type = ppc_q3_read_u32_from_slice(&mipmap.mipmap, PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET)?;
let byte_order = ppc_q3_read_u32_from_slice(&mipmap.mipmap, PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET)?;
let width = ppc_q3_read_u32_from_slice(&mipmap.mipmap, PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET)?;
let height = ppc_q3_read_u32_from_slice(&mipmap.mipmap, PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET)?;
let row_bytes =
ppc_q3_read_u32_from_slice(&mipmap.mipmap, PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET)?;
let image_offset =
ppc_q3_read_u32_from_slice(&mipmap.mipmap, PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET)?;
if storage == 0 || width == 0 || height == 0 || row_bytes == 0 {
return None;
}
let pixel_bytes = ppc_q3_software_texture_pixel_bytes(pixel_type)?;
let min_row_bytes = width.checked_mul(pixel_bytes)?;
if row_bytes < min_row_bytes {
return None;
}
let (image_base, valid_size) =
ppc_q3_software_storage_buffer(q3_objects, q3_memory_storages, storage)?;
let last_row_offset = height.checked_sub(1)?.checked_mul(row_bytes)?;
let last_pixel_offset = width.checked_sub(1)?.checked_mul(pixel_bytes)?;
let image_end = image_offset
.checked_add(last_row_offset)?
.checked_add(last_pixel_offset)?
.checked_add(pixel_bytes)?;
if image_end > valid_size {
return None;
}
Some(PpcQ3SoftwareTexture {
image_base,
valid_size,
image_offset,
width,
height,
row_bytes,
pixel_type,
byte_order,
pixel_bytes,
})
}
fn ppc_q3_software_texture_sample(
memory: &mut PpcSectionMem,
texture: PpcQ3SoftwareTexture,
shader_boundary: Option<PpcQ3ShaderBoundaryRecord>,
u: f32,
v: f32,
) -> Option<PpcQ3SoftwareTextureSample> {
let u_boundary = shader_boundary
.map(|record| record.u_boundary)
.unwrap_or(PPC_Q3_SHADER_UV_BOUNDARY_WRAP);
let v_boundary = shader_boundary
.map(|record| record.v_boundary)
.unwrap_or(PPC_Q3_SHADER_UV_BOUNDARY_WRAP);
let u = ppc_q3_software_texture_coordinate(u, u_boundary)?;
let v = ppc_q3_software_texture_coordinate(v, v_boundary)?;
let x = ((u * texture.width as f32).floor() as u32).min(texture.width.saturating_sub(1));
let y = ((v * texture.height as f32).floor() as u32).min(texture.height.saturating_sub(1));
ppc_q3_software_texture_pixel_at(memory, texture, x, y)
}
fn ppc_q3_software_texture_coordinate(value: f32, boundary: u32) -> Option<f32> {
if !value.is_finite() {
return None;
}
match boundary {
PPC_Q3_SHADER_UV_BOUNDARY_CLAMP => Some(value.clamp(0.0, 1.0)),
PPC_Q3_SHADER_UV_BOUNDARY_WRAP => Some(value - value.floor()),
_ => None,
}
}
fn ppc_q3_software_texture_pixel_at(
memory: &mut PpcSectionMem,
texture: PpcQ3SoftwareTexture,
x: u32,
y: u32,
) -> Option<PpcQ3SoftwareTextureSample> {
if x >= texture.width || y >= texture.height {
return None;
}
let row_offset = y.checked_mul(texture.row_bytes)?;
let pixel_offset = x.checked_mul(texture.pixel_bytes)?;
let storage_offset = texture
.image_offset
.checked_add(row_offset)?
.checked_add(pixel_offset)?;
let pixel_end = storage_offset.checked_add(texture.pixel_bytes)?;
if pixel_end > texture.valid_size {
return None;
}
let pixel_ptr = texture.image_base.checked_add(storage_offset)?;
let mut pixel = [0u8; 4];
let pixel_bytes = usize::try_from(texture.pixel_bytes).ok()?;
memory.read_bytes_into(pixel_ptr, pixel.get_mut(..pixel_bytes)?)?;
ppc_q3_software_texture_pixel_color(texture.pixel_type, texture.byte_order, &pixel)
}
fn ppc_q3_gpu_texture_from_software(
memory: &mut PpcSectionMem,
texture: PpcQ3SoftwareTexture,
shader_boundary: Option<PpcQ3ShaderBoundaryRecord>,
) -> Option<PpcQ3GpuTexture> {
let pixel_count = usize::try_from(texture.width.checked_mul(texture.height)?).ok()?;
let mut rgba = Vec::with_capacity(pixel_count.checked_mul(4)?);
for y in 0..texture.height {
for x in 0..texture.width {
let sample = ppc_q3_software_texture_pixel_at(memory, texture, x, y)?;
rgba.extend([
(sample.color.0.clamp(0.0, 1.0) * 255.0).round() as u8,
(sample.color.1.clamp(0.0, 1.0) * 255.0).round() as u8,
(sample.color.2.clamp(0.0, 1.0) * 255.0).round() as u8,
(sample.opacity.clamp(0.0, 1.0) * 255.0).round() as u8,
]);
}
}
let u_boundary = shader_boundary
.map(|record| record.u_boundary)
.unwrap_or(PPC_Q3_SHADER_UV_BOUNDARY_WRAP);
let v_boundary = shader_boundary
.map(|record| record.v_boundary)
.unwrap_or(PPC_Q3_SHADER_UV_BOUNDARY_WRAP);
if !matches!(
u_boundary,
PPC_Q3_SHADER_UV_BOUNDARY_WRAP | PPC_Q3_SHADER_UV_BOUNDARY_CLAMP
) || !matches!(
v_boundary,
PPC_Q3_SHADER_UV_BOUNDARY_WRAP | PPC_Q3_SHADER_UV_BOUNDARY_CLAMP
) {
return None;
}
if (u_boundary == PPC_Q3_SHADER_UV_BOUNDARY_WRAP && !texture.width.is_power_of_two())
|| (v_boundary == PPC_Q3_SHADER_UV_BOUNDARY_WRAP && !texture.height.is_power_of_two())
{
// WebGL 1 only permits REPEAT on power-of-two texture dimensions.
return None;
}
Some(PpcQ3GpuTexture {
width: texture.width,
height: texture.height,
rgba,
wrap_u: u_boundary == PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
wrap_v: v_boundary == PPC_Q3_SHADER_UV_BOUNDARY_WRAP,
})
}
fn ppc_q3_read_u32_from_slice(data: &[u8], offset: u32) -> Option<u32> {
let offset = usize::try_from(offset).ok()?;
let bytes = data.get(offset..offset.checked_add(4)?)?;
Some(u32::from_be_bytes(bytes.try_into().ok()?))
}
fn ppc_q3_software_storage_buffer(
q3_objects: &[PpcQ3ObjectRecord],
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
storage: u32,
) -> Option<(u32, u32)> {
q3_memory_storages
.iter()
.find(|record| record.storage == storage)
.map(|record| (record.buffer_ptr, record.valid_size))
.or_else(|| {
q3_objects
.iter()
.find(|record| record.object == storage)
.map(|record| (record.data_ptr, record.data_size))
})
.filter(|(buffer_ptr, valid_size)| *buffer_ptr != 0 && *valid_size != 0)
}
fn ppc_q3_software_texture_pixel_bytes(pixel_type: u32) -> Option<u32> {
match pixel_type {
PPC_Q3_PIXEL_TYPE_RGB32 | PPC_Q3_PIXEL_TYPE_ARGB32 => Some(4),
PPC_Q3_PIXEL_TYPE_RGB16 | PPC_Q3_PIXEL_TYPE_ARGB16 | PPC_Q3_PIXEL_TYPE_RGB16_565 => Some(2),
PPC_Q3_PIXEL_TYPE_RGB24 => Some(3),
_ => None,
}
}
fn ppc_q3_software_texture_pixel_color(
pixel_type: u32,
byte_order: u32,
pixel: &[u8; 4],
) -> Option<PpcQ3SoftwareTextureSample> {
match pixel_type {
PPC_Q3_PIXEL_TYPE_RGB24 => {
let (red, green, blue) = if byte_order == PPC_Q3_ENDIAN_LITTLE {
(pixel[2], pixel[1], pixel[0])
} else {
(pixel[0], pixel[1], pixel[2])
};
Some(PpcQ3SoftwareTextureSample {
color: ppc_q3_color_rgb_from_u8(red, green, blue),
opacity: 1.0,
})
}
PPC_Q3_PIXEL_TYPE_RGB32 => {
let (red, green, blue) = if byte_order == PPC_Q3_ENDIAN_LITTLE {
(pixel[2], pixel[1], pixel[0])
} else {
(pixel[1], pixel[2], pixel[3])
};
Some(PpcQ3SoftwareTextureSample {
color: ppc_q3_color_rgb_from_u8(red, green, blue),
opacity: 1.0,
})
}
PPC_Q3_PIXEL_TYPE_ARGB32 => {
let (alpha, red, green, blue) = if byte_order == PPC_Q3_ENDIAN_LITTLE {
(pixel[3], pixel[2], pixel[1], pixel[0])
} else {
(pixel[0], pixel[1], pixel[2], pixel[3])
};
Some(PpcQ3SoftwareTextureSample {
color: ppc_q3_color_rgb_from_u8(red, green, blue),
opacity: f32::from(alpha) / 255.0,
})
}
PPC_Q3_PIXEL_TYPE_RGB16 => {
let value = ppc_q3_software_texture_u16(byte_order, pixel)?;
Some(PpcQ3SoftwareTextureSample {
color: ppc_q3_rgb555_to_color(value),
opacity: 1.0,
})
}
PPC_Q3_PIXEL_TYPE_ARGB16 => {
let value = ppc_q3_software_texture_u16(byte_order, pixel)?;
Some(PpcQ3SoftwareTextureSample {
color: ppc_q3_rgb555_to_color(value & 0x7fff),
opacity: if (value & 0x8000) != 0 { 1.0 } else { 0.0 },
})
}
PPC_Q3_PIXEL_TYPE_RGB16_565 => {
let value = ppc_q3_software_texture_u16(byte_order, pixel)?;
Some(PpcQ3SoftwareTextureSample {
color: (
f32::from((value >> 11) & 0x1f) / 31.0,
f32::from((value >> 5) & 0x3f) / 63.0,
f32::from(value & 0x1f) / 31.0,
),
opacity: 1.0,
})
}
_ => None,
}
}
fn ppc_q3_color_rgb_from_u8(red: u8, green: u8, blue: u8) -> (f32, f32, f32) {
(
f32::from(red) / 255.0,
f32::from(green) / 255.0,
f32::from(blue) / 255.0,
)
}
fn ppc_q3_software_texture_u16(byte_order: u32, pixel: &[u8; 4]) -> Option<u16> {
match byte_order {
PPC_Q3_ENDIAN_BIG => Some(u16::from_be_bytes([pixel[0], pixel[1]])),
PPC_Q3_ENDIAN_LITTLE => Some(u16::from_le_bytes([pixel[0], pixel[1]])),
_ => None,
}
}
fn ppc_q3_software_illumination_type(illumination_type: u32) -> u32 {
if ppc_q3_object_type_is_illumination_shader(illumination_type) {
illumination_type
} else {
PPC_Q3_ILLUMINATION_TYPE_PHONG
}
}
fn ppc_q3_software_apply_lights(
diffuse: (f32, f32, f32),
ambient_coefficient: f32,
specular_color: (f32, f32, f32),
specular_control: f32,
illumination_type: u32,
lights: &PpcQ3SubmissionLightRecord,
normal: Option<(f32, f32, f32)>,
world: Option<(f32, f32, f32)>,
view_direction: Option<(f32, f32, f32)>,
) -> (f32, f32, f32) {
if illumination_type == PPC_Q3_ILLUMINATION_TYPE_NULL {
return diffuse;
}
if lights.lights.is_empty() {
return diffuse;
}
let use_specular = illumination_type == PPC_Q3_ILLUMINATION_TYPE_PHONG;
let mut factor = (0.0, 0.0, 0.0);
let mut specular = (0.0, 0.0, 0.0);
for light in &lights.lights {
if light.data.is_on == 0 {
continue;
}
let contribution = match light.kind {
PpcQ3LightKind::Ambient => {
ppc_q3_software_light_contribution(light, ambient_coefficient)
}
PpcQ3LightKind::Directional { direction, .. } => {
let intensity = normal
.and_then(|normal| {
ppc_q3_vector3d_normalized_value(direction)
.map(|direction| (normal, direction))
})
.map(|(normal, direction)| {
let diffuse_intensity = (-ppc_q3_vector3d_dot(normal, direction)).max(0.0);
if use_specular {
if let Some(specular_contribution) =
ppc_q3_software_specular_contribution(
light,
normal,
direction,
view_direction,
diffuse_intensity,
specular_color,
specular_control,
)
{
specular.0 += specular_contribution.0;
specular.1 += specular_contribution.1;
specular.2 += specular_contribution.2;
}
}
diffuse_intensity
})
.unwrap_or(1.0);
ppc_q3_software_light_contribution(light, intensity)
}
PpcQ3LightKind::Point {
attenuation,
location,
..
} => {
let Some((light_direction, attenuation_factor)) = world.and_then(|world| {
ppc_q3_software_point_light_direction_and_attenuation(
world,
location,
attenuation,
)
}) else {
continue;
};
let diffuse_intensity =
ppc_q3_software_surface_light_intensity(normal, light_direction);
if use_specular {
ppc_q3_software_accumulate_specular_contribution(
&mut specular,
light,
normal,
light_direction,
view_direction,
diffuse_intensity,
specular_color,
specular_control,
attenuation_factor,
);
}
ppc_q3_software_light_contribution(light, diffuse_intensity * attenuation_factor)
}
PpcQ3LightKind::Spot {
attenuation,
location,
direction,
hot_angle,
outer_angle,
fall_off,
..
} => {
let Some((light_direction, attenuation_factor)) = world.and_then(|world| {
ppc_q3_software_point_light_direction_and_attenuation(
world,
location,
attenuation,
)
}) else {
continue;
};
let Some(spot_factor) = ppc_q3_software_spot_factor(
light_direction,
direction,
hot_angle,
outer_angle,
fall_off,
) else {
continue;
};
if spot_factor <= 0.0 {
continue;
}
let diffuse_intensity =
ppc_q3_software_surface_light_intensity(normal, light_direction);
let light_factor = attenuation_factor * spot_factor;
if use_specular {
ppc_q3_software_accumulate_specular_contribution(
&mut specular,
light,
normal,
light_direction,
view_direction,
diffuse_intensity,
specular_color,
specular_control,
light_factor,
);
}
ppc_q3_software_light_contribution(light, diffuse_intensity * light_factor)
}
};
factor.0 += contribution.0;
factor.1 += contribution.1;
factor.2 += contribution.2;
}
(
diffuse.0.mul_add(factor.0, specular.0),
diffuse.1.mul_add(factor.1, specular.1),
diffuse.2.mul_add(factor.2, specular.2),
)
}
fn ppc_q3_software_surface_light_intensity(
normal: Option<(f32, f32, f32)>,
light_direction: (f32, f32, f32),
) -> f32 {
normal
.map(|normal| (-ppc_q3_vector3d_dot(normal, light_direction)).max(0.0))
.unwrap_or(1.0)
}
fn ppc_q3_software_point_light_direction_and_attenuation(
world: (f32, f32, f32),
location: (f32, f32, f32),
attenuation: u32,
) -> Option<((f32, f32, f32), f32)> {
let offset = ppc_q3_vector3d_sub(world, location);
let distance_squared = ppc_q3_vector3d_dot(offset, offset);
if !distance_squared.is_finite() || distance_squared <= 0.0 {
return None;
}
let distance = distance_squared.sqrt();
let light_direction = (
offset.0 / distance,
offset.1 / distance,
offset.2 / distance,
);
let attenuation_factor = ppc_q3_software_attenuation_factor(distance, attenuation)?;
Some((light_direction, attenuation_factor))
}
fn ppc_q3_software_attenuation_factor(distance: f32, attenuation: u32) -> Option<f32> {
if !distance.is_finite() || distance <= 0.0 {
return None;
}
let factor = match attenuation {
PPC_Q3_ATTENUATION_TYPE_NONE => 1.0,
PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE => 1.0 / distance,
PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE_SQUARED => 1.0 / (distance * distance),
_ => return None,
};
if factor.is_finite() && factor >= 0.0 {
Some(factor)
} else {
None
}
}
fn ppc_q3_software_spot_factor(
light_direction: (f32, f32, f32),
direction: (f32, f32, f32),
hot_angle: f32,
outer_angle: f32,
fall_off: u32,
) -> Option<f32> {
if !hot_angle.is_finite()
|| !outer_angle.is_finite()
|| hot_angle < 0.0
|| outer_angle < hot_angle
{
return None;
}
let spot_direction = ppc_q3_vector3d_normalized_value(direction)?;
let angle = ppc_q3_vector3d_dot(light_direction, spot_direction)
.clamp(-1.0, 1.0)
.acos();
if !angle.is_finite() {
return None;
}
if angle > outer_angle {
return Some(0.0);
}
if angle <= hot_angle {
return Some(1.0);
}
let span = outer_angle - hot_angle;
if span <= 0.0 {
return Some(0.0);
}
let t = ((outer_angle - angle) / span).clamp(0.0, 1.0);
let factor = match fall_off {
PPC_Q3_FALL_OFF_TYPE_NONE => 1.0,
PPC_Q3_FALL_OFF_TYPE_LINEAR => t,
PPC_Q3_FALL_OFF_TYPE_EXPONENTIAL => t * t,
PPC_Q3_FALL_OFF_TYPE_COSINE => 0.5 - 0.5 * (std::f32::consts::PI * t).cos(),
_ => return None,
};
if factor.is_finite() {
Some(factor)
} else {
None
}
}
fn ppc_q3_software_accumulate_specular_contribution(
specular: &mut (f32, f32, f32),
light: &PpcQ3LightRecord,
normal: Option<(f32, f32, f32)>,
light_direction: (f32, f32, f32),
view_direction: Option<(f32, f32, f32)>,
diffuse_intensity: f32,
specular_color: (f32, f32, f32),
specular_control: f32,
scale: f32,
) {
if !scale.is_finite() || scale <= 0.0 {
return;
}
let Some(normal) = normal else {
return;
};
let Some(specular_contribution) = ppc_q3_software_specular_contribution(
light,
normal,
light_direction,
view_direction,
diffuse_intensity,
specular_color,
specular_control,
) else {
return;
};
specular.0 += specular_contribution.0 * scale;
specular.1 += specular_contribution.1 * scale;
specular.2 += specular_contribution.2 * scale;
}
fn ppc_q3_software_specular_contribution(
light: &PpcQ3LightRecord,
normal: (f32, f32, f32),
light_direction: (f32, f32, f32),
view_direction: Option<(f32, f32, f32)>,
diffuse_intensity: f32,
specular_color: (f32, f32, f32),
specular_control: f32,
) -> Option<(f32, f32, f32)> {
// QuickDraw 3D 1.5.4, 3D Metafile Reference, p. 1396 permits exponent zero.
if diffuse_intensity <= 0.0 || specular_control < 0.0 {
return None;
}
let view_direction = view_direction.and_then(ppc_q3_vector3d_normalized_value)?;
let surface_to_light = (-light_direction.0, -light_direction.1, -light_direction.2);
let reflection = ppc_q3_vector3d_normalized_value((
(2.0 * diffuse_intensity).mul_add(normal.0, -surface_to_light.0),
(2.0 * diffuse_intensity).mul_add(normal.1, -surface_to_light.1),
(2.0 * diffuse_intensity).mul_add(normal.2, -surface_to_light.2),
))?;
let specular_intensity = ppc_q3_vector3d_dot(reflection, view_direction)
.max(0.0)
.powf(specular_control);
if !specular_intensity.is_finite() || specular_intensity <= 0.0 {
return None;
}
Some((
light.data.color.0 * light.data.brightness * specular_color.0 * specular_intensity,
light.data.color.1 * light.data.brightness * specular_color.1 * specular_intensity,
light.data.color.2 * light.data.brightness * specular_color.2 * specular_intensity,
))
}
fn ppc_q3_software_light_contribution(light: &PpcQ3LightRecord, intensity: f32) -> (f32, f32, f32) {
(
light.data.color.0 * light.data.brightness * intensity,
light.data.color.1 * light.data.brightness * intensity,
light.data.color.2 * light.data.brightness * intensity,
)
}
fn ppc_q3_software_apply_fog(
color: (f32, f32, f32),
fog_style: Option<PpcQ3FogStyleData>,
fog_depth: f32,
vertex_alpha: Option<f32>,
) -> (f32, f32, f32) {
let Some(fog_style) = fog_style else {
return color;
};
if fog_style.state == 0 || !fog_depth.is_finite() {
return color;
}
let Some(factor) = ppc_q3_software_fog_color_factor(fog_style, fog_depth, vertex_alpha) else {
return color;
};
let factor = factor.clamp(0.0, 1.0);
(
color.0.mul_add(factor, fog_style.color.0 * (1.0 - factor)),
color.1.mul_add(factor, fog_style.color.1 * (1.0 - factor)),
color.2.mul_add(factor, fog_style.color.2 * (1.0 - factor)),
)
}
fn ppc_q3_software_fog_color_factor(
fog_style: PpcQ3FogStyleData,
fog_depth: f32,
vertex_alpha: Option<f32>,
) -> Option<f32> {
let factor = match fog_style.mode {
PPC_Q3_FOG_MODE_LINEAR => {
let range = fog_style.fog_end - fog_style.fog_start;
if range == 0.0 {
if fog_depth < fog_style.fog_end {
1.0
} else {
0.0
}
} else {
(fog_style.fog_end - fog_depth) / range
}
}
PPC_Q3_FOG_MODE_EXPONENTIAL => (-fog_style.density * fog_depth).exp(),
PPC_Q3_FOG_MODE_EXPONENTIAL_SQUARED => {
let value = fog_style.density * fog_depth;
(-(value * value)).exp()
}
PPC_Q3_FOG_MODE_ALPHA => vertex_alpha?,
_ => return None,
};
if factor.is_finite() {
Some(factor)
} else {
None
}
}
fn ppc_q3_read_f32_from_slice(data: &[u8], offset: usize) -> Option<f32> {
let bytes = data.get(offset..offset.checked_add(4)?)?;
Some(f32::from_bits(u32::from_be_bytes(bytes.try_into().ok()?)))
}
fn ppc_q3_rgb555((red, green, blue): (f32, f32, f32)) -> u16 {
fn component(value: f32) -> u16 {
if !value.is_finite() {
return 0;
}
(value.clamp(0.0, 1.0) * 31.0).round() as u16
}
(component(red) << 10) | (component(green) << 5) | component(blue)
}
fn ppc_q3_rgb555_to_color(pixel: u16) -> (f32, f32, f32) {
(
f32::from((pixel >> 10) & 0x1f) / 31.0,
f32::from((pixel >> 5) & 0x1f) / 31.0,
f32::from(pixel & 0x1f) / 31.0,
)
}
fn ppc_q3_blend_transparency_color(
source: (f32, f32, f32),
destination: (f32, f32, f32),
transparency: (f32, f32, f32),
) -> (f32, f32, f32) {
(
source
.0
.mul_add(transparency.0, destination.0 * (1.0 - transparency.0)),
source
.1
.mul_add(transparency.1, destination.1 * (1.0 - transparency.1)),
source
.2
.mul_add(transparency.2, destination.2 * (1.0 - transparency.2)),
)
}
fn ppc_q3_software_effective_transparency(
transparency: (f32, f32, f32),
opacity: f32,
) -> (f32, f32, f32) {
if !opacity.is_finite() {
return (0.0, 0.0, 0.0);
}
let opacity = opacity.clamp(0.0, 1.0);
(
transparency.0 * opacity,
transparency.1 * opacity,
transparency.2 * opacity,
)
}
fn ppc_q3_software_blend_opacity(
material: &PpcQ3SoftwareMaterialSample,
texture_opacity: f32,
vertex_alpha: Option<f32>,
) -> f32 {
if ppc_q3_software_material_uses_alpha_fog(material.fog_style) {
return texture_opacity;
}
match vertex_alpha {
Some(vertex_alpha) => texture_opacity * vertex_alpha,
None => texture_opacity,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcQ3SoftwareTriangle {
index: usize,
points: [usize; 3],
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcQ3SoftwareEdge {
index: usize,
points: [usize; 2],
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PpcQ3SoftwareEdgeMaterial {
diffuse: Option<(f32, f32, f32)>,
ambient_coefficient: Option<f32>,
specular_color: Option<(f32, f32, f32)>,
specular_control: Option<f32>,
highlight_state: Option<bool>,
normal: Option<(f32, f32, f32)>,
vertex_alpha: Option<f32>,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PpcQ3SoftwareProjectedVertex {
x: f32,
y: f32,
z: f32,
clip: Option<(f32, f32, f32, f32)>,
world: (f32, f32, f32),
view_direction: Option<(f32, f32, f32)>,
fog_depth: f32,
uv: Option<(f32, f32)>,
diffuse: Option<(f32, f32, f32)>,
ambient_coefficient: Option<f32>,
normal: Option<(f32, f32, f32)>,
specular_color: Option<(f32, f32, f32)>,
specular_control: Option<f32>,
highlight_state: Option<bool>,
vertex_alpha: Option<f32>,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct PpcQ3SoftwareProjectedPoint {
x: i32,
y: i32,
z: f32,
reciprocal_w: f32,
world: (f32, f32, f32),
view_direction: Option<(f32, f32, f32)>,
fog_depth: f32,
uv: Option<(f32, f32)>,
diffuse: Option<(f32, f32, f32)>,
ambient_coefficient: Option<f32>,
normal: Option<(f32, f32, f32)>,
specular_color: Option<(f32, f32, f32)>,
specular_control: Option<f32>,
highlight_state: Option<bool>,
vertex_alpha: Option<f32>,
}
enum PpcQ3SoftwareDeferredPrimitive {
Triangle {
vertices: [PpcQ3SoftwareProjectedPoint; 3],
material: PpcQ3SoftwareMaterialSample,
lights: PpcQ3SubmissionLightRecord,
interpolation_style: u32,
sort_depth: f32,
},
Point {
point: PpcQ3SoftwareProjectedPoint,
material: PpcQ3SoftwareMaterialSample,
lights: PpcQ3SubmissionLightRecord,
sort_depth: f32,
},
Edge {
start: PpcQ3SoftwareProjectedPoint,
end: PpcQ3SoftwareProjectedPoint,
material: PpcQ3SoftwareMaterialSample,
lights: PpcQ3SubmissionLightRecord,
sort_depth: f32,
},
}
impl PpcQ3SoftwareDeferredPrimitive {
fn sort_depth(&self) -> f32 {
match self {
PpcQ3SoftwareDeferredPrimitive::Triangle { sort_depth, .. }
| PpcQ3SoftwareDeferredPrimitive::Point { sort_depth, .. }
| PpcQ3SoftwareDeferredPrimitive::Edge { sort_depth, .. } => *sort_depth,
}
}
}
#[derive(Debug, Clone, PartialEq)]
struct PpcQ3SoftwareDepthBuffer {
width: u32,
height: u32,
depths: Vec<f32>,
}
impl PpcQ3SoftwareDepthBuffer {
fn new(front_buffer: PpcFrontBuffer) -> Self {
let len = front_buffer
.width
.checked_mul(front_buffer.height)
.and_then(|pixels| usize::try_from(pixels).ok())
.unwrap_or(0);
Self {
width: front_buffer.width,
height: front_buffer.height,
depths: vec![f32::INFINITY; len],
}
}
fn test(&self, x: u32, y: u32, z: f32) -> bool {
if x >= self.width || y >= self.height || !z.is_finite() {
return false;
}
let Some(index) = y
.checked_mul(self.width)
.and_then(|row| row.checked_add(x))
.and_then(|index| usize::try_from(index).ok())
else {
return false;
};
self.depths.get(index).is_some_and(|depth| z <= *depth)
}
fn test_and_update(&mut self, x: u32, y: u32, z: f32) -> bool {
if x >= self.width || y >= self.height || !z.is_finite() {
return false;
}
let Some(index) = y
.checked_mul(self.width)
.and_then(|row| row.checked_add(x))
.and_then(|index| usize::try_from(index).ok())
else {
return false;
};
let Some(depth) = self.depths.get_mut(index) else {
return false;
};
if z > *depth {
return false;
}
*depth = z;
true
}
}
fn ppc_q3_software_project_point(
command: &PpcQ3SceneTriMeshCommand,
front_buffer: PpcFrontBuffer,
viewport: PpcQ3ViewportRect,
point: (f32, f32, f32),
) -> Option<PpcQ3SoftwareProjectedVertex> {
let world = ppc_q3_point3d_transform_values(point, command.local_to_world);
let view_direction = ppc_q3_software_view_direction(command.camera, world);
let (projected, fog_depth, clip) = if let Some(camera) = command.camera {
let world_to_view = ppc_q3_camera_world_to_view_matrix(camera.placement)?;
let view_to_frustum = ppc_q3_camera_view_to_frustum_matrix(&camera)?;
let view = ppc_q3_point3d_transform_values(world, world_to_view);
let mut clip = ppc_q3_point3d_transform_4d_values(view, view_to_frustum);
// QuickDraw 3D exposes frustum depth in [-1, 0], with the hither
// plane at 0. Keep that guest-visible matrix authentic, then remap
// depth to the software rasterizer's OpenGL-style [-1, 1] interval.
clip.2 = (-2.0_f32).mul_add(clip.2, -clip.3);
(
ppc_q3_software_clip_to_projected(clip)?,
-view.2,
Some(clip),
)
} else {
(world, world.2, None)
};
if !ppc_q3_point_finite(projected) || !fog_depth.is_finite() {
return None;
}
let (screen_x, screen_y) =
ppc_q3_software_projected_to_screen(projected, command.camera, front_buffer, viewport);
Some(PpcQ3SoftwareProjectedVertex {
x: screen_x,
y: screen_y,
z: projected.2,
clip,
world,
view_direction,
fog_depth,
uv: None,
diffuse: None,
ambient_coefficient: None,
normal: None,
specular_color: None,
specular_control: None,
highlight_state: None,
vertex_alpha: None,
})
}
fn ppc_q3_software_view_direction(
camera: Option<PpcQ3CameraRecord>,
world: (f32, f32, f32),
) -> Option<(f32, f32, f32)> {
camera
.and_then(|camera| {
ppc_q3_vector3d_normalized_value(ppc_q3_vector3d_sub(
camera.placement.camera_location,
world,
))
})
.or(Some((0.0, 0.0, 1.0)))
}
fn ppc_q3_software_projected_to_screen(
projected: (f32, f32, f32),
camera: Option<PpcQ3CameraRecord>,
front_buffer: PpcFrontBuffer,
viewport: PpcQ3ViewportRect,
) -> (f32, f32) {
let (normalized_x, normalized_y) = if let Some(camera) = camera {
let viewport_x = (projected.0 + 1.0) * 0.5;
let viewport_y = (projected.1 + 1.0) * 0.5;
(
camera.viewport_origin.0 + viewport_x * camera.viewport_width,
// QD3D camera viewport origins are the upper-left corner of the pane.
camera.viewport_origin.1 - camera.viewport_height + viewport_y * camera.viewport_height,
)
} else {
(projected.0, projected.1)
};
let viewport = if camera.is_some() {
viewport
} else {
PpcQ3ViewportRect::full(front_buffer)
};
let max_x = viewport.right.saturating_sub(1) as f32;
let max_y = viewport.bottom.saturating_sub(1) as f32;
let width = (max_x - viewport.left as f32).max(0.0);
let height = (max_y - viewport.top as f32).max(0.0);
(
viewport.left as f32 + (normalized_x + 1.0) * 0.5 * width,
viewport.top as f32 + (1.0 - ((normalized_y + 1.0) * 0.5)) * height,
)
}
fn ppc_q3_software_clip_to_projected(clip: (f32, f32, f32, f32)) -> Option<(f32, f32, f32)> {
if !clip.0.is_finite() || !clip.1.is_finite() || !clip.2.is_finite() || !clip.3.is_finite() {
return None;
}
if clip.3 == 0.0 {
return None;
}
let projected = (clip.0 / clip.3, clip.1 / clip.3, clip.2 / clip.3);
if ppc_q3_point_finite(projected) {
Some(projected)
} else {
None
}
}
fn ppc_q3_software_projected_vertex_depth_visible(
depth_clip: bool,
vertex: PpcQ3SoftwareProjectedVertex,
) -> bool {
if !depth_clip {
return true;
}
if let Some(clip) = vertex.clip {
return ppc_q3_software_clip_inside_frustum(clip);
}
vertex.z >= PPC_Q3_SOFTWARE_DEPTH_NEAR && vertex.z <= PPC_Q3_SOFTWARE_DEPTH_FAR
}
fn ppc_q3_software_projected_vertex_to_point(
vertex: PpcQ3SoftwareProjectedVertex,
) -> PpcQ3SoftwareProjectedPoint {
PpcQ3SoftwareProjectedPoint {
x: vertex.x.round() as i32,
y: vertex.y.round() as i32,
z: vertex.z,
reciprocal_w: vertex
.clip
.map(|clip| 1.0 / clip.3)
.filter(|value| value.is_finite())
.unwrap_or(1.0),
world: vertex.world,
view_direction: vertex.view_direction,
fog_depth: vertex.fog_depth,
uv: vertex.uv,
diffuse: vertex.diffuse,
ambient_coefficient: vertex.ambient_coefficient,
normal: vertex.normal,
specular_color: vertex.specular_color,
specular_control: vertex.specular_control,
highlight_state: vertex.highlight_state,
vertex_alpha: vertex.vertex_alpha,
}
}
fn ppc_q3_software_clip_projected_triangle(
camera: Option<PpcQ3CameraRecord>,
front_buffer: PpcFrontBuffer,
viewport: PpcQ3ViewportRect,
vertices: [PpcQ3SoftwareProjectedVertex; 3],
) -> Vec<PpcQ3SoftwareProjectedVertex> {
let Some(camera) = camera else {
return vertices.to_vec();
};
if vertices.iter().any(|vertex| vertex.clip.is_none()) {
let near_clipped =
ppc_q3_software_clip_projected_polygon_z(&vertices, PPC_Q3_SOFTWARE_DEPTH_NEAR, true);
if near_clipped.len() < 3 {
return Vec::new();
}
return ppc_q3_software_clip_projected_polygon_z(
&near_clipped,
PPC_Q3_SOFTWARE_DEPTH_FAR,
false,
);
}
let mut clipped = vertices.to_vec();
for plane in [
PpcQ3SoftwareClipPlane::Left,
PpcQ3SoftwareClipPlane::Right,
PpcQ3SoftwareClipPlane::Bottom,
PpcQ3SoftwareClipPlane::Top,
PpcQ3SoftwareClipPlane::Near,
PpcQ3SoftwareClipPlane::Far,
] {
clipped = ppc_q3_software_clip_projected_polygon_clip(
&clipped,
plane,
camera,
front_buffer,
viewport,
);
if clipped.len() < 3 {
return Vec::new();
}
}
clipped
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PpcQ3SoftwareClipPlane {
Left,
Right,
Bottom,
Top,
Near,
Far,
}
fn ppc_q3_software_clip_inside_frustum(clip: (f32, f32, f32, f32)) -> bool {
[
PpcQ3SoftwareClipPlane::Left,
PpcQ3SoftwareClipPlane::Right,
PpcQ3SoftwareClipPlane::Bottom,
PpcQ3SoftwareClipPlane::Top,
PpcQ3SoftwareClipPlane::Near,
PpcQ3SoftwareClipPlane::Far,
]
.into_iter()
.all(|plane| {
ppc_q3_software_clip_plane_value(clip, plane)
.is_some_and(|value| value >= -PPC_Q3_SOFTWARE_CLIP_EPSILON)
})
}
fn ppc_q3_software_clip_plane_value(
(x, y, z, w): (f32, f32, f32, f32),
plane: PpcQ3SoftwareClipPlane,
) -> Option<f32> {
if !x.is_finite() || !y.is_finite() || !z.is_finite() || !w.is_finite() {
return None;
}
Some(match plane {
PpcQ3SoftwareClipPlane::Left => x + w,
PpcQ3SoftwareClipPlane::Right => w - x,
PpcQ3SoftwareClipPlane::Bottom => y + w,
PpcQ3SoftwareClipPlane::Top => w - y,
PpcQ3SoftwareClipPlane::Near => z + w,
PpcQ3SoftwareClipPlane::Far => w - z,
})
}
fn ppc_q3_software_clip_projected_polygon_clip(
vertices: &[PpcQ3SoftwareProjectedVertex],
plane: PpcQ3SoftwareClipPlane,
camera: PpcQ3CameraRecord,
front_buffer: PpcFrontBuffer,
viewport: PpcQ3ViewportRect,
) -> Vec<PpcQ3SoftwareProjectedVertex> {
let mut clipped = Vec::new();
let Some(mut previous) = vertices.last().copied() else {
return clipped;
};
let mut previous_value = previous
.clip
.and_then(|clip| ppc_q3_software_clip_plane_value(clip, plane))
.unwrap_or(f32::NEG_INFINITY);
let mut previous_inside = previous_value >= -PPC_Q3_SOFTWARE_CLIP_EPSILON;
for ¤t in vertices {
let current_value = current
.clip
.and_then(|clip| ppc_q3_software_clip_plane_value(clip, plane))
.unwrap_or(f32::NEG_INFINITY);
let current_inside = current_value >= -PPC_Q3_SOFTWARE_CLIP_EPSILON;
if current_inside != previous_inside {
if let Some(intersection) = ppc_q3_software_projected_vertex_intersect_clip(
previous,
current,
previous_value,
current_value,
camera,
front_buffer,
viewport,
) {
clipped.push(intersection);
}
}
if current_inside {
clipped.push(current);
}
previous = current;
previous_value = current_value;
previous_inside = current_inside;
}
clipped
}
fn ppc_q3_software_projected_vertex_intersect_clip(
start: PpcQ3SoftwareProjectedVertex,
end: PpcQ3SoftwareProjectedVertex,
start_value: f32,
end_value: f32,
camera: PpcQ3CameraRecord,
front_buffer: PpcFrontBuffer,
viewport: PpcQ3ViewportRect,
) -> Option<PpcQ3SoftwareProjectedVertex> {
let denominator = start_value - end_value;
if denominator == 0.0 || !denominator.is_finite() {
return None;
}
let t = (start_value / denominator).clamp(0.0, 1.0);
let start_clip = start.clip?;
let end_clip = end.clip?;
let clip = (
start_clip.0.mul_add(1.0 - t, end_clip.0 * t),
start_clip.1.mul_add(1.0 - t, end_clip.1 * t),
start_clip.2.mul_add(1.0 - t, end_clip.2 * t),
start_clip.3.mul_add(1.0 - t, end_clip.3 * t),
);
let projected = ppc_q3_software_clip_to_projected(clip)?;
let (x, y) =
ppc_q3_software_projected_to_screen(projected, Some(camera), front_buffer, viewport);
if !x.is_finite() || !y.is_finite() {
return None;
}
let mut vertex = ppc_q3_software_projected_vertex_interpolate(start, end, t);
vertex.x = x;
vertex.y = y;
vertex.z = projected.2;
vertex.clip = Some(clip);
Some(vertex)
}
fn ppc_q3_software_clip_projected_polygon_z(
vertices: &[PpcQ3SoftwareProjectedVertex],
plane_z: f32,
keep_greater_or_equal: bool,
) -> Vec<PpcQ3SoftwareProjectedVertex> {
let mut clipped = Vec::new();
let Some(mut previous) = vertices.last().copied() else {
return clipped;
};
let mut previous_inside =
ppc_q3_software_projected_vertex_inside_z(previous, plane_z, keep_greater_or_equal);
for ¤t in vertices {
let current_inside =
ppc_q3_software_projected_vertex_inside_z(current, plane_z, keep_greater_or_equal);
if current_inside != previous_inside {
if let Some(intersection) =
ppc_q3_software_projected_vertex_intersect_z(previous, current, plane_z)
{
clipped.push(intersection);
}
}
if current_inside {
clipped.push(current);
}
previous = current;
previous_inside = current_inside;
}
clipped
}
fn ppc_q3_software_projected_vertex_inside_z(
vertex: PpcQ3SoftwareProjectedVertex,
plane_z: f32,
keep_greater_or_equal: bool,
) -> bool {
if keep_greater_or_equal {
vertex.z >= plane_z
} else {
vertex.z <= plane_z
}
}
fn ppc_q3_software_projected_vertex_intersect_z(
start: PpcQ3SoftwareProjectedVertex,
end: PpcQ3SoftwareProjectedVertex,
plane_z: f32,
) -> Option<PpcQ3SoftwareProjectedVertex> {
let dz = end.z - start.z;
if dz == 0.0 {
return None;
}
let t = ((plane_z - start.z) / dz).clamp(0.0, 1.0);
let mut vertex = ppc_q3_software_projected_vertex_interpolate(start, end, t);
vertex.z = plane_z;
if vertex.x.is_finite() && vertex.y.is_finite() {
Some(vertex)
} else {
None
}
}
fn ppc_q3_software_projected_vertex_interpolate(
start: PpcQ3SoftwareProjectedVertex,
end: PpcQ3SoftwareProjectedVertex,
t: f32,
) -> PpcQ3SoftwareProjectedVertex {
PpcQ3SoftwareProjectedVertex {
x: start.x.mul_add(1.0 - t, end.x * t),
y: start.y.mul_add(1.0 - t, end.y * t),
z: start.z.mul_add(1.0 - t, end.z * t),
clip: match (start.clip, end.clip) {
(Some(start_clip), Some(end_clip)) => Some((
start_clip.0.mul_add(1.0 - t, end_clip.0 * t),
start_clip.1.mul_add(1.0 - t, end_clip.1 * t),
start_clip.2.mul_add(1.0 - t, end_clip.2 * t),
start_clip.3.mul_add(1.0 - t, end_clip.3 * t),
)),
_ => None,
},
world: (
start.world.0.mul_add(1.0 - t, end.world.0 * t),
start.world.1.mul_add(1.0 - t, end.world.1 * t),
start.world.2.mul_add(1.0 - t, end.world.2 * t),
),
view_direction: match (start.view_direction, end.view_direction) {
(Some(start_view), Some(end_view)) => ppc_q3_vector3d_normalized_value((
start_view.0.mul_add(1.0 - t, end_view.0 * t),
start_view.1.mul_add(1.0 - t, end_view.1 * t),
start_view.2.mul_add(1.0 - t, end_view.2 * t),
)),
_ => None,
},
fog_depth: start.fog_depth.mul_add(1.0 - t, end.fog_depth * t),
uv: match (start.uv, end.uv) {
(Some(start_uv), Some(end_uv)) => Some((
start_uv.0.mul_add(1.0 - t, end_uv.0 * t),
start_uv.1.mul_add(1.0 - t, end_uv.1 * t),
)),
_ => None,
},
diffuse: match (start.diffuse, end.diffuse) {
(Some(start_diffuse), Some(end_diffuse)) => Some((
start_diffuse.0.mul_add(1.0 - t, end_diffuse.0 * t),
start_diffuse.1.mul_add(1.0 - t, end_diffuse.1 * t),
start_diffuse.2.mul_add(1.0 - t, end_diffuse.2 * t),
)),
_ => None,
},
ambient_coefficient: match (start.ambient_coefficient, end.ambient_coefficient) {
(Some(start_coefficient), Some(end_coefficient)) => {
Some(start_coefficient.mul_add(1.0 - t, end_coefficient * t))
}
_ => None,
},
normal: match (start.normal, end.normal) {
(Some(start_normal), Some(end_normal)) => ppc_q3_vector3d_normalized_value((
start_normal.0.mul_add(1.0 - t, end_normal.0 * t),
start_normal.1.mul_add(1.0 - t, end_normal.1 * t),
start_normal.2.mul_add(1.0 - t, end_normal.2 * t),
)),
_ => None,
},
specular_color: match (start.specular_color, end.specular_color) {
(Some(start_specular), Some(end_specular)) => Some((
start_specular.0.mul_add(1.0 - t, end_specular.0 * t),
start_specular.1.mul_add(1.0 - t, end_specular.1 * t),
start_specular.2.mul_add(1.0 - t, end_specular.2 * t),
)),
_ => None,
},
specular_control: match (start.specular_control, end.specular_control) {
(Some(start_control), Some(end_control)) => {
Some(start_control.mul_add(1.0 - t, end_control * t))
}
_ => None,
},
highlight_state: match (start.highlight_state, end.highlight_state) {
(Some(start_state), Some(end_state)) => Some(start_state && end_state),
_ => None,
},
vertex_alpha: match (start.vertex_alpha, end.vertex_alpha) {
(Some(start_alpha), Some(end_alpha)) => {
Some(start_alpha.mul_add(1.0 - t, end_alpha * t))
}
_ => None,
},
}
}
pub(super) fn ppc_front_buffer_for_gworld(gworlds: &[PpcGWorldRecord], gworld: u32) -> Option<PpcFrontBuffer> {
gworlds
.iter()
.find(|record| record.port == gworld)
.map(|record| PpcFrontBuffer {
base_addr: record.base_addr,
row_bytes: record.row_bytes,
width: record.width,
height: record.height,
depth: record.depth,
})
}
pub(super) fn ppc_live_front_buffer_for_gworld(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
gworld: u32,
) -> Option<PpcFrontBuffer> {
ppc_live_quickdraw_surface(memory, gworlds, gworld).map(|surface| surface.front_buffer)
}
pub(super) fn ppc_live_quickdraw_surface(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
gworld: u32,
) -> Option<PpcQuickDrawSurface> {
let record = gworlds.iter().find(|record| record.port == gworld);
// Color QuickDraw permits callers to replace a CGrafPort's portPixMap
// after OpenCPort. Resolve that live Handle on every drawing operation;
// the host-side GWorld record describes the port at creation time only.
// A monochrome GrafPort embeds a BitMap at portBits instead.
let live_bits = gworld.checked_add(6).and_then(|row_bytes| {
let is_color = memory.read_u16_be(row_bytes)? & 0x8000 != 0;
let port_bits = gworld.checked_add(2)?;
if is_color {
let pixmap_handle = memory.read_u32_be(port_bits)?;
let pixmap = memory.read_u32_be(pixmap_handle)?;
let bits = ppc_read_pixmap_bits(memory, pixmap)?;
let ctable_handle = pixmap
.checked_add(42)
.and_then(|pm_table| memory.read_u32_be(pm_table))
.filter(|handle| *handle != 0);
Some((bits, ctable_handle))
} else {
let mut bits = ppc_read_pixmap_bits(memory, port_bits)?;
let row_capacity = bits.row_bytes.checked_mul(8)?.checked_div(bits.depth)?;
if bits.width > row_capacity {
// Basic GrafPorts commonly start as a copy of screenBits and
// are then converted to an offscreen port by replacing only
// baseAddr/rowBytes and portRect. In that idiom the copied
// BitMap.bounds can remain screen-sized even though portRect
// and rowBytes describe the actual backing store. QuickDraw
// clips drawing to portRect; recover that live extent when
// the stale bounds cannot possibly fit in one bitmap row.
// Imaging With QuickDraw (1994), pp. 2-38--2-40, 2-46.
let (top, left, bottom, right) = ppc_read_rect(memory, gworld + 16)?;
let (width, height) = ppc_rect_dimensions(top, left, bottom, right);
if width == 0 || height == 0 || width > row_capacity {
return None;
}
bits.top = top;
bits.left = left;
bits.bottom = bottom;
bits.right = right;
bits.width = width;
bits.height = height;
}
Some((bits, None))
}
});
live_bits
.map(|(bits, ctable_handle)| PpcQuickDrawSurface {
front_buffer: PpcFrontBuffer {
base_addr: bits.base_addr,
row_bytes: bits.row_bytes,
width: bits.width,
height: bits.height,
depth: bits.depth,
},
top: bits.top,
left: bits.left,
ctable_handle,
})
.or_else(|| {
let record = record?;
let ctable_handle = (record.pixmap != 0)
.then_some(record.pixmap)
.and_then(|pixmap| pixmap.checked_add(42))
.and_then(|pm_table| memory.read_u32_be(pm_table))
.filter(|handle| *handle != 0);
Some(PpcQuickDrawSurface {
front_buffer: PpcFrontBuffer {
base_addr: record.base_addr,
row_bytes: record.row_bytes,
width: record.width,
height: record.height,
depth: record.depth,
},
top: 0,
left: 0,
ctable_handle,
})
})
}
fn ppc_live_gworld_ctable_handle(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
gworld: u32,
) -> Option<u32> {
let record = gworlds.iter().find(|record| record.port == gworld)?;
let live_pixmap = gworld
.checked_add(6)
.and_then(|row_bytes| memory.read_u16_be(row_bytes))
.filter(|row_bytes| row_bytes & 0x8000 != 0)
.and_then(|_| gworld.checked_add(2))
.and_then(|port_bits| memory.read_u32_be(port_bits))
.and_then(|pixmap_handle| memory.read_u32_be(pixmap_handle));
live_pixmap
.or_else(|| (record.pixmap != 0).then_some(record.pixmap))
.and_then(|pixmap| pixmap.checked_add(42))
.and_then(|pm_table| memory.read_u32_be(pm_table))
.filter(|ctable_handle| *ctable_handle != 0)
}
fn ppc_live_gworld_clut(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
gworld: u32,
_screen_clut: &[[u16; 3]; 256],
color_manager_clut: &[[u16; 3]; 256],
) -> [[u16; 3]; 256] {
let Some(ctable_handle) = ppc_live_gworld_ctable_handle(memory, gworlds, gworld) else {
return *color_manager_clut;
};
// Imaging With QuickDraw (1994), "Color Tables": RGB-to-pixel mapping is
// performed through the destination PixMap's logical ColorTable. A display
// driver cscSetEntries request may temporarily fade the physical CLUT
// without replacing that table, so never substitute the host's hardware
// palette here—even for a PixMap whose baseAddr is the main screen.
ppc_read_ctable_clut(memory, ctable_handle, color_manager_clut).unwrap_or(*color_manager_clut)
}
fn ppc_q3_draw_context_render_target(
q3_objects: &[PpcQ3ObjectRecord],
q3_draw_contexts: &[PpcQ3DrawContextRecord],
gworlds: &[PpcGWorldRecord],
draw_context: u32,
) -> Option<PpcQ3RenderTarget> {
let object = q3_objects
.iter()
.find(|record| record.object == draw_context)?;
let record = q3_draw_contexts
.iter()
.find(|record| record.draw_context == draw_context)?;
if object.object_type != record.draw_context_type {
return None;
}
let clear_color =
(ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_DRAW_CONTEXT_CLEAR_METHOD_OFFSET)
== Some(PPC_Q3_CLEAR_METHOD_WITH_COLOR))
.then(|| {
Some(ppc_q3_rgb555((
ppc_q3_read_f32_from_slice(
&record.data,
PPC_Q3_DRAW_CONTEXT_CLEAR_COLOR_RED_OFFSET as usize,
)?,
ppc_q3_read_f32_from_slice(
&record.data,
PPC_Q3_DRAW_CONTEXT_CLEAR_COLOR_GREEN_OFFSET as usize,
)?,
ppc_q3_read_f32_from_slice(
&record.data,
PPC_Q3_DRAW_CONTEXT_CLEAR_COLOR_BLUE_OFFSET as usize,
)?,
)))
})
.flatten();
match record.draw_context_type {
PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP => {
let base_addr =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_DRAW_CONTEXT_DATA_SIZE)?;
let width =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_PIXMAP_DRAW_CONTEXT_WIDTH_OFFSET)?;
let height =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_PIXMAP_DRAW_CONTEXT_HEIGHT_OFFSET)?;
let row_bytes =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 12)?;
let pixel_size =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 16)?;
let pixel_type =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_DRAW_CONTEXT_DATA_SIZE + 20)?;
if base_addr == 0
|| width == 0
|| height == 0
|| pixel_size != 16
|| !matches!(
pixel_type,
PPC_Q3_PIXEL_TYPE_RGB16 | PPC_Q3_PIXEL_TYPE_ARGB16
)
|| row_bytes < width.checked_mul(2)?
{
return None;
}
Some(PpcQ3RenderTarget {
front_buffer: PpcFrontBuffer {
base_addr,
row_bytes,
width,
height,
depth: 16,
},
viewport: ppc_q3_draw_context_viewport(
record,
PpcFrontBuffer {
base_addr,
row_bytes,
width,
height,
depth: 16,
},
),
clear_color,
source: PpcQ3RenderTargetSource::PixmapDrawContext,
draw_context: Some(draw_context),
gworld: None,
})
}
PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH => {
let port =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET)?;
ppc_front_buffer_for_gworld(gworlds, port).map(|front_buffer| PpcQ3RenderTarget {
front_buffer,
viewport: ppc_q3_draw_context_viewport(record, front_buffer),
clear_color,
source: PpcQ3RenderTargetSource::MacDrawContext,
draw_context: Some(draw_context),
gworld: Some(port),
})
}
_ => None,
}
}
fn ppc_q3_live_draw_context_render_target(
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_draw_contexts: &[PpcQ3DrawContextRecord],
gworlds: &[PpcGWorldRecord],
draw_context: u32,
) -> Option<PpcQ3RenderTarget> {
let mut target =
ppc_q3_draw_context_render_target(q3_objects, q3_draw_contexts, gworlds, draw_context)?;
if target.source != PpcQ3RenderTargetSource::MacDrawContext {
return Some(target);
}
let port = target.gworld?;
let gworld = gworlds.iter().find(|record| record.port == port)?;
if gworld.pixmap_handle == 0 && gworld.pixmap == 0 {
return Some(target);
}
let surface = ppc_live_quickdraw_surface(memory, gworlds, port)?;
let record = q3_draw_contexts
.iter()
.find(|record| record.draw_context == draw_context)?;
target.front_buffer = surface.front_buffer;
target.viewport = ppc_q3_draw_context_viewport_with_origin(
record,
surface.front_buffer,
-i32::from(surface.left),
-i32::from(surface.top),
);
Some(target)
}
fn ppc_q3_draw_context_viewport(
record: &PpcQ3DrawContextRecord,
front_buffer: PpcFrontBuffer,
) -> Option<PpcQ3ViewportRect> {
ppc_q3_draw_context_viewport_with_origin(record, front_buffer, 0, 0)
}
fn ppc_q3_draw_context_viewport_with_origin(
record: &PpcQ3DrawContextRecord,
front_buffer: PpcFrontBuffer,
origin_x: i32,
origin_y: i32,
) -> Option<PpcQ3ViewportRect> {
let pane_state =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_DRAW_CONTEXT_PANE_STATE_OFFSET)
.unwrap_or(0);
if pane_state == 0 {
return None;
}
let pane_start = usize::try_from(PPC_Q3_DRAW_CONTEXT_PANE_OFFSET).ok()?;
let min_x = ppc_q3_read_f32_from_slice(&record.data, pane_start)?;
let min_y = ppc_q3_read_f32_from_slice(&record.data, pane_start.checked_add(4)?)?;
let max_x = ppc_q3_read_f32_from_slice(&record.data, pane_start.checked_add(8)?)?;
let max_y = ppc_q3_read_f32_from_slice(&record.data, pane_start.checked_add(12)?)?;
PpcQ3ViewportRect::from_q3_area(
front_buffer,
min_x + origin_x as f32,
min_y + origin_y as f32,
max_x + origin_x as f32,
max_y + origin_y as f32,
)
}
fn ppc_q3_front_buffer_pixel_addr(front_buffer: PpcFrontBuffer, (x, y): (i32, i32)) -> Option<u32> {
let offset = ppc_q3_front_buffer_pixel_relative_offset(front_buffer, (x, y))?;
front_buffer
.base_addr
.checked_add(u32::try_from(offset).ok()?)
}
fn ppc_q3_front_buffer_pixel_relative_offset(
front_buffer: PpcFrontBuffer,
(x, y): (i32, i32),
) -> Option<usize> {
if x < 0 || y < 0 {
return None;
}
let (x, y) = (x as u32, y as u32);
if x >= front_buffer.width || y >= front_buffer.height {
return None;
}
let pixel_offset = x.checked_mul(2)?;
let pixel_end = pixel_offset.checked_add(2)?;
if pixel_end > front_buffer.row_bytes {
return None;
}
let row_offset = y.checked_mul(front_buffer.row_bytes)?;
let offset = row_offset.checked_add(pixel_offset)?;
usize::try_from(offset).ok()
}
fn ppc_q3_front_buffer_span_len(front_buffer: PpcFrontBuffer) -> Option<usize> {
if front_buffer.depth != 16 || front_buffer.height == 0 {
return None;
}
let rows_before_last = front_buffer.height.checked_sub(1)?;
let last_row_offset = rows_before_last.checked_mul(front_buffer.row_bytes)?;
let last_row_bytes = front_buffer.width.checked_mul(2)?;
let len = last_row_offset.checked_add(last_row_bytes)?;
usize::try_from(len).ok()
}
fn ppc_q3_read_software_pixel(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
point: (i32, i32),
) -> Option<u16> {
memory.read_u16_be(ppc_q3_front_buffer_pixel_addr(front_buffer, point)?)
}
fn ppc_q3_write_software_pixel(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
point: (i32, i32),
color: u16,
) -> bool {
let Some(addr) = ppc_q3_front_buffer_pixel_addr(front_buffer, point) else {
return false;
};
memory.write_u16_be(addr, color).is_some()
}
fn ppc_front_buffer_8bpp_pixel_addr(
front_buffer: PpcFrontBuffer,
(x, y): (i32, i32),
) -> Option<u32> {
if x < 0 || y < 0 || front_buffer.depth != 8 {
return None;
}
let (x, y) = (x as u32, y as u32);
if x >= front_buffer.width || y >= front_buffer.height || x >= front_buffer.row_bytes {
return None;
}
front_buffer
.base_addr
.checked_add(y.checked_mul(front_buffer.row_bytes)?)?
.checked_add(x)
}
#[cfg(test)]
fn ppc_rgb_color_to_8bpp_index(color: PpcRgbColor) -> u8 {
ppc_rgb_color_to_8bpp_index_in_clut(color, &TrapDispatcher::standard_mac_8bpp_clut())
}
#[cfg(test)]
fn ppc_rgb_color_to_8bpp_index_in_clut(color: PpcRgbColor, clut: &[[u16; 3]; 256]) -> u8 {
ppc_rgb555_to_clut_index(ppc_rgb_color_to_rgb555(color), clut)
}
pub(super) fn ppc_indexed_depth_entry_count(depth: u32) -> Option<usize> {
matches!(depth, 1 | 2 | 4 | 8).then(|| 1usize << depth)
}
pub(super) fn ppc_rgb_color_to_index_in_clut(
color: PpcRgbColor,
clut: &[[u16; 3]; 256],
entry_count: usize,
) -> u8 {
ppc_rgb_color_to_valid_index_in_clut(color, clut, &[true; 256], entry_count).unwrap_or(0)
}
fn ppc_rgb_color_to_valid_index_in_clut(
color: PpcRgbColor,
clut: &[[u16; 3]; 256],
valid: &[bool; 256],
entry_count: usize,
) -> Option<u8> {
let target = ppc_rgb_color_to_rgb555(color);
let target_r = i64::from((target >> 10) & 0x1f);
let target_g = i64::from((target >> 5) & 0x1f);
let target_b = i64::from(target & 0x1f);
clut.iter()
.take(entry_count.min(clut.len()))
.enumerate()
.filter(|(index, _)| valid[*index])
.min_by_key(|(_, [red, green, blue])| {
let red = i64::from(*red >> 11);
let green = i64::from(*green >> 11);
let blue = i64::from(*blue >> 11);
(red - target_r).pow(2) + (green - target_g).pow(2) + (blue - target_b).pow(2)
})
.map(|(index, _)| index as u8)
}
pub(super) fn ppc_quickdraw_surface_color_pixel(
memory: &mut PpcSectionMem,
surface: PpcQuickDrawSurface,
color: PpcRgbColor,
) -> Option<u16> {
match surface.front_buffer.depth {
depth @ (1 | 2 | 4 | 8) => {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 4-81--4-82:
// Color2Index maps an RGBColor through the destination GDevice's
// inverse table. For an offscreen PixMap, its own ColorTable is the
// destination palette, so RGB QuickDraw primitives must not assume
// the canonical system palette.
// The same volume, pp. 4-14--4-16 and 4-46--4-47, defines indexed
// pixel values at 1, 2, 4, and 8 bits. Match only the entries that
// the destination pixel can represent; matching all 256 and then
// truncating would select a different color and corrupt its index.
let fallback = TrapDispatcher::standard_mac_indexed_clut(depth as u16)
.map(|(clut, _)| clut)
.unwrap_or_else(TrapDispatcher::standard_mac_8bpp_clut);
let clut = surface
.ctable_handle
.and_then(|handle| ppc_read_ctable_clut(memory, handle, &fallback))
.unwrap_or(fallback);
Some(u16::from(ppc_rgb_color_to_index_in_clut(
color,
&clut,
ppc_indexed_depth_entry_count(depth)?,
)))
}
16 => Some(ppc_rgb_color_to_rgb555(color)),
_ => None,
}
}
fn ppc_quickdraw_background_pattern(
memory: &mut PpcSectionMem,
current_gworld: u32,
fallback: [u8; 8],
) -> [u8; 8] {
// A color port's bkPixPat field is at the same offset as documented by
// Color QuickDraw. Its pat1Data member remains the required monochrome
// fallback for one-bit patterns and for destinations without a usable
// pixel map (Inside Macintosh: Imaging With QuickDraw, pp. 4-80--4-82).
let Some(pattern_handle) = memory
.read_u32_be(current_gworld.wrapping_add(32))
.filter(|handle| *handle != 0)
else {
return fallback;
};
let Some(pattern_ptr) = memory
.read_u32_be(pattern_handle)
.filter(|ptr| *ptr != 0)
else {
return fallback;
};
let mut pattern = [0u8; 8];
memory
.read_bytes_into(pattern_ptr.wrapping_add(20), &mut pattern)
.is_some()
.then_some(pattern)
.unwrap_or(fallback)
}
fn ppc_quickdraw_surface_background_pixel(
memory: &mut PpcSectionMem,
surface: PpcQuickDrawSurface,
local_point: (i32, i32),
fore_color: PpcRgbColor,
back_color: PpcRgbColor,
explicit_back_index: Option<u8>,
pattern: [u8; 8],
) -> Option<u16> {
let (x, y) = local_point;
let global_x = i32::from(surface.left).checked_add(x)?;
let global_y = i32::from(surface.top).checked_add(y)?;
let row = pattern[global_y.rem_euclid(8) as usize];
let is_foreground = row & (0x80 >> (global_x.rem_euclid(8) as u8)) != 0;
if is_foreground {
ppc_quickdraw_surface_fore_pixel(memory, surface, fore_color, None)
} else {
ppc_quickdraw_surface_fore_pixel(memory, surface, back_color, explicit_back_index)
}
}
fn ppc_quickdraw_surface_fore_pixel(
memory: &mut PpcSectionMem,
surface: PpcQuickDrawSurface,
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> Option<u16> {
if let Some(entry_count) = ppc_indexed_depth_entry_count(surface.front_buffer.depth) {
if let Some(index) = explicit_index {
return Some(u16::from(index) & (entry_count as u16 - 1));
}
}
ppc_quickdraw_surface_color_pixel(memory, surface, color)
}
pub(super) fn ppc_quickdraw_write_pixel(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
point: (i32, i32),
color: PpcRgbColor,
) -> bool {
match front_buffer.depth {
depth @ (1 | 2 | 4 | 8) => {
let fallback = TrapDispatcher::standard_mac_indexed_clut(depth as u16)
.map(|(clut, _)| clut)
.unwrap_or_else(TrapDispatcher::standard_mac_8bpp_clut);
let clut = if front_buffer.base_addr == PPC_MAIN_SCREEN_BASE {
ppc_read_ctable_clut(memory, PPC_MAIN_CTABLE_HANDLE, &fallback).unwrap_or(fallback)
} else {
fallback
};
let pixel = ppc_rgb_color_to_index_in_clut(
color,
&clut,
ppc_indexed_depth_entry_count(depth).unwrap_or(1),
);
ppc_quickdraw_write_raw_pixel(memory, front_buffer, point, u16::from(pixel))
}
16 => {
ppc_q3_write_software_pixel(memory, front_buffer, point, ppc_rgb_color_to_rgb555(color))
}
_ => false,
}
}
pub(super) fn ppc_quickdraw_read_pixel(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
point: (i32, i32),
) -> Option<u16> {
match front_buffer.depth {
depth @ (1 | 2 | 4) => {
let (x, y) = point;
let x = u32::try_from(x).ok()?;
let y = u32::try_from(y).ok()?;
if x >= front_buffer.width || y >= front_buffer.height {
return None;
}
let pixels_per_byte = 8 / depth;
let byte_offset = x / pixels_per_byte;
if byte_offset >= front_buffer.row_bytes {
return None;
}
let byte = memory.read_u8(
front_buffer
.base_addr
.checked_add(y.checked_mul(front_buffer.row_bytes)?)?
.checked_add(byte_offset)?,
)?;
let shift = 8 - depth - (x % pixels_per_byte) * depth;
let mask = (1u8 << depth) - 1;
Some(u16::from((byte >> shift) & mask))
}
8 => memory
.read_u8(ppc_front_buffer_8bpp_pixel_addr(front_buffer, point)?)
.map(u16::from),
16 => ppc_q3_read_software_pixel(memory, front_buffer, point),
_ => None,
}
}
pub(super) fn ppc_quickdraw_write_raw_pixel(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
point: (i32, i32),
value: u16,
) -> bool {
match front_buffer.depth {
depth @ (1 | 2 | 4) => {
let (x, y) = point;
let (Ok(x), Ok(y)) = (u32::try_from(x), u32::try_from(y)) else {
return false;
};
if x >= front_buffer.width || y >= front_buffer.height {
return false;
}
let Some(row_offset) = y.checked_mul(front_buffer.row_bytes) else {
return false;
};
let pixels_per_byte = 8 / depth;
let byte_offset = x / pixels_per_byte;
if byte_offset >= front_buffer.row_bytes {
return false;
}
let Some(addr) = front_buffer
.base_addr
.checked_add(row_offset)
.and_then(|row| row.checked_add(byte_offset))
else {
return false;
};
let Some(byte) = memory.read_u8(addr) else {
return false;
};
let shift = 8 - depth - (x % pixels_per_byte) * depth;
let value_mask = (1u8 << depth) - 1;
let pixel_mask = value_mask << shift;
let packed = ((value as u8) & value_mask) << shift;
memory
.write_u8(addr, (byte & !pixel_mask) | packed)
.is_some()
}
8 => {
let Some(addr) = ppc_front_buffer_8bpp_pixel_addr(front_buffer, point) else {
return false;
};
memory.write_u8(addr, value as u8).is_some()
}
16 => ppc_q3_write_software_pixel(memory, front_buffer, point, value),
_ => false,
}
}
fn ppc_q3_software_material_output_pixel_color(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
point: (i32, i32),
source: (f32, f32, f32),
transparency: (f32, f32, f32),
) -> u16 {
if transparency == (1.0, 1.0, 1.0) {
return ppc_q3_rgb555(source);
}
let destination = surface
.read_pixel(memory, point)
.map(ppc_q3_rgb555_to_color)
.unwrap_or(source);
ppc_q3_rgb555(ppc_q3_blend_transparency_color(
source,
destination,
transparency,
))
}
fn ppc_q3_write_software_depth_material_pixel(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
depth_buffer: &mut PpcQ3SoftwareDepthBuffer,
point: PpcQ3SoftwareProjectedPoint,
material: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
) -> bool {
if point.x < 0 || point.y < 0 {
return false;
}
let (x, y) = (point.x as u32, point.y as u32);
if !depth_buffer.test_and_update(x, y, point.z) {
return false;
}
let output = ppc_q3_software_material_shaded_output(
memory,
material,
lights,
point.uv,
point.diffuse,
point.ambient_coefficient,
point.normal,
point.specular_color,
point.specular_control,
point.highlight_state,
Some(point.world),
point.view_direction,
point.fog_depth,
point.vertex_alpha,
);
ppc_q3_write_software_material_output_pixel(memory, surface, point, material, output)
}
fn ppc_q3_draw_deferred_software_point(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
depth_buffer: &mut PpcQ3SoftwareDepthBuffer,
point: PpcQ3SoftwareProjectedPoint,
material: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
) -> bool {
let output = ppc_q3_software_material_shaded_output(
memory,
material,
lights,
point.uv,
point.diffuse,
point.ambient_coefficient,
point.normal,
point.specular_color,
point.specular_control,
point.highlight_state,
Some(point.world),
point.view_direction,
point.fog_depth,
point.vertex_alpha,
);
ppc_q3_write_software_depth_material_output_pixel(
memory,
surface,
depth_buffer,
point,
material,
output,
false,
)
}
fn ppc_q3_write_software_depth_material_output_pixel(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
depth_buffer: &mut PpcQ3SoftwareDepthBuffer,
point: PpcQ3SoftwareProjectedPoint,
material: &PpcQ3SoftwareMaterialSample,
output: PpcQ3SoftwareMaterialOutput,
write_depth: bool,
) -> bool {
if point.x < 0 || point.y < 0 {
return false;
}
let (x, y) = (point.x as u32, point.y as u32);
let depth_visible = if write_depth {
depth_buffer.test_and_update(x, y, point.z)
} else {
depth_buffer.test(x, y, point.z)
};
if !depth_visible {
return false;
}
ppc_q3_write_software_material_output_pixel(memory, surface, point, material, output)
}
fn ppc_q3_write_software_material_output_pixel(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
point: PpcQ3SoftwareProjectedPoint,
material: &PpcQ3SoftwareMaterialSample,
output: PpcQ3SoftwareMaterialOutput,
) -> bool {
let opacity = ppc_q3_software_blend_opacity(material, output.opacity, point.vertex_alpha);
let transparency = ppc_q3_software_effective_transparency(material.transparency, opacity);
let color = ppc_q3_software_material_output_pixel_color(
memory,
surface,
(point.x, point.y),
output.color,
transparency,
);
surface.write_pixel(memory, (point.x, point.y), color)
}
fn ppc_q3_draw_software_triangle(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
depth_buffer: &mut PpcQ3SoftwareDepthBuffer,
vertices: [PpcQ3SoftwareProjectedPoint; 3],
material: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
interpolation_style: u32,
viewport: PpcQ3ViewportRect,
write_depth: bool,
) -> usize {
let Some((viewport_left, viewport_top, viewport_right, viewport_bottom)) =
viewport.inclusive_bounds()
else {
return 0;
};
let [a, b, c] = vertices;
let area = ppc_q3_software_edge_value(a, b, c);
if area == 0 {
let point =
ppc_q3_software_interpolate_projected_point(&vertices, [1.0 / 3.0; 3], a.x, a.y);
let output = ppc_q3_software_material_shaded_output(
memory,
material,
lights,
point.uv,
point.diffuse,
point.ambient_coefficient,
point.normal,
point.specular_color,
point.specular_control,
point.highlight_state,
Some(point.world),
point.view_direction,
point.fog_depth,
point.vertex_alpha,
);
let opacity = ppc_q3_software_blend_opacity(material, output.opacity, point.vertex_alpha);
let transparency = ppc_q3_software_effective_transparency(material.transparency, opacity);
return ppc_q3_draw_software_line(memory, surface, a, b, output.color, transparency)
.saturating_add(ppc_q3_draw_software_line(
memory,
surface,
b,
c,
output.color,
transparency,
))
.saturating_add(ppc_q3_draw_software_line(
memory,
surface,
c,
a,
output.color,
transparency,
));
}
let min_x = a.x.min(b.x).min(c.x).max(viewport_left);
let min_y = a.y.min(b.y).min(c.y).max(viewport_top);
let max_x = a.x.max(b.x).max(c.x).min(viewport_right);
let max_y = a.y.max(b.y).max(c.y).min(viewport_bottom);
if min_x > max_x || min_y > max_y {
return 0;
}
// QD3D interpolation styles select where illumination is evaluated.
// Texturing and fog remain per-pixel even for flat and vertex lighting.
let mut lighting_material = *material;
lighting_material.texture = None;
lighting_material.fog_style = None;
let flat_sample = if interpolation_style == PPC_Q3_INTERPOLATION_STYLE_NONE {
let point =
ppc_q3_software_interpolate_projected_point(&vertices, [1.0 / 3.0; 3], a.x, a.y);
let output = ppc_q3_software_material_shaded_output(
memory,
&lighting_material,
lights,
point.uv,
point.diffuse,
point.ambient_coefficient,
point.normal,
point.specular_color,
point.specular_control,
point.highlight_state,
Some(point.world),
point.view_direction,
point.fog_depth,
point.vertex_alpha,
);
Some((point, output))
} else {
None
};
let vertex_outputs = if interpolation_style == PPC_Q3_INTERPOLATION_STYLE_VERTEX {
Some(vertices.map(|point| {
ppc_q3_software_material_shaded_output(
memory,
&lighting_material,
lights,
point.uv,
point.diffuse,
point.ambient_coefficient,
point.normal,
point.specular_color,
point.specular_control,
point.highlight_state,
Some(point.world),
point.view_direction,
point.fog_depth,
point.vertex_alpha,
)
}))
} else {
None
};
let mut pixels = 0usize;
let area_f = area as f32;
let (mut row_edge_weights, edge_x_steps, edge_y_steps) =
ppc_q3_software_triangle_edge_walker(vertices, min_x, min_y);
for y in min_y..=max_y {
let mut edge_weights = row_edge_weights;
for x in min_x..=max_x {
let [w0, w1, w2] = edge_weights;
edge_weights[0] += edge_x_steps[0];
edge_weights[1] += edge_x_steps[1];
edge_weights[2] += edge_x_steps[2];
if !ppc_q3_software_weights_inside(area, w0, w1, w2) {
continue;
}
let weight0 = w0 as f32 / area_f;
let weight1 = w1 as f32 / area_f;
let weight2 = w2 as f32 / area_f;
let perspective_weights =
ppc_q3_software_perspective_weights(&vertices, [weight0, weight1, weight2]);
let point = ppc_q3_software_interpolate_projected_point_with_weights(
&vertices,
[weight0, weight1, weight2],
perspective_weights,
x,
y,
);
let (write_point, output, needs_texture_and_fog) = match interpolation_style {
PPC_Q3_INTERPOLATION_STYLE_NONE => {
let (flat_point, output) =
flat_sample.expect("flat interpolation output should be precomputed");
(
PpcQ3SoftwareProjectedPoint {
diffuse: flat_point.diffuse,
normal: flat_point.normal,
specular_color: flat_point.specular_color,
specular_control: flat_point.specular_control,
highlight_state: flat_point.highlight_state,
vertex_alpha: flat_point.vertex_alpha,
..point
},
output,
true,
)
}
PPC_Q3_INTERPOLATION_STYLE_VERTEX => (
point,
ppc_q3_software_interpolate_material_output(
vertex_outputs.expect("vertex interpolation outputs should be precomputed"),
perspective_weights[0],
perspective_weights[1],
perspective_weights[2],
),
true,
),
_ => (
point,
ppc_q3_software_material_shaded_output(
memory,
material,
lights,
point.uv,
point.diffuse,
point.ambient_coefficient,
point.normal,
point.specular_color,
point.specular_control,
point.highlight_state,
Some(point.world),
point.view_direction,
point.fog_depth,
point.vertex_alpha,
),
false,
),
};
let output = if needs_texture_and_fog {
ppc_q3_software_apply_texture_and_fog(
memory,
material,
write_point.uv,
write_point.fog_depth,
write_point.vertex_alpha,
output,
)
} else {
output
};
if ppc_q3_write_software_depth_material_output_pixel(
memory,
surface,
depth_buffer,
write_point,
material,
output,
write_depth,
) {
pixels = pixels.saturating_add(1);
}
}
row_edge_weights[0] += edge_y_steps[0];
row_edge_weights[1] += edge_y_steps[1];
row_edge_weights[2] += edge_y_steps[2];
}
pixels
}
fn ppc_q3_software_primitive_deferred_for_transparency(
material: &PpcQ3SoftwareMaterialSample,
vertices: &[PpcQ3SoftwareProjectedPoint],
) -> bool {
if material.transparency.0 < 0.999
|| material.transparency.1 < 0.999
|| material.transparency.2 < 0.999
{
return true;
}
if ppc_q3_software_texture_may_blend(material.texture) {
return true;
}
if !ppc_q3_software_material_uses_alpha_fog(material.fog_style) {
return vertices
.iter()
.any(|vertex| vertex.vertex_alpha.is_some_and(|alpha| alpha < 0.999));
}
false
}
fn ppc_q3_software_texture_may_blend(texture: Option<PpcQ3SoftwareTexture>) -> bool {
matches!(
texture.map(|texture| texture.pixel_type),
Some(PPC_Q3_PIXEL_TYPE_ARGB32 | PPC_Q3_PIXEL_TYPE_ARGB16)
)
}
fn ppc_q3_software_triangle_sort_depth(vertices: [PpcQ3SoftwareProjectedPoint; 3]) -> f32 {
(vertices[0].z + vertices[1].z + vertices[2].z) / 3.0
}
fn ppc_q3_software_line_sort_depth(
start: PpcQ3SoftwareProjectedPoint,
end: PpcQ3SoftwareProjectedPoint,
) -> f32 {
(start.z + end.z) * 0.5
}
fn ppc_q3_software_interpolate_projected_point(
vertices: &[PpcQ3SoftwareProjectedPoint; 3],
weights: [f32; 3],
x: i32,
y: i32,
) -> PpcQ3SoftwareProjectedPoint {
let perspective_weights = ppc_q3_software_perspective_weights(vertices, weights);
ppc_q3_software_interpolate_projected_point_with_weights(
vertices,
weights,
perspective_weights,
x,
y,
)
}
fn ppc_q3_software_interpolate_projected_point_with_weights(
vertices: &[PpcQ3SoftwareProjectedPoint; 3],
weights: [f32; 3],
perspective_weights: [f32; 3],
x: i32,
y: i32,
) -> PpcQ3SoftwareProjectedPoint {
let [a, b, c] = vertices;
let [affine_weight0, affine_weight1, affine_weight2] = weights;
let [weight0, weight1, weight2] = perspective_weights;
PpcQ3SoftwareProjectedPoint {
x,
y,
z: affine_weight0.mul_add(a.z, affine_weight1.mul_add(b.z, affine_weight2 * c.z)),
reciprocal_w: affine_weight0.mul_add(
a.reciprocal_w,
affine_weight1.mul_add(b.reciprocal_w, affine_weight2 * c.reciprocal_w),
),
world: (
weight0.mul_add(a.world.0, weight1.mul_add(b.world.0, weight2 * c.world.0)),
weight0.mul_add(a.world.1, weight1.mul_add(b.world.1, weight2 * c.world.1)),
weight0.mul_add(a.world.2, weight1.mul_add(b.world.2, weight2 * c.world.2)),
),
view_direction: match (a.view_direction, b.view_direction, c.view_direction) {
(Some(view_a), Some(view_b), Some(view_c)) => ppc_q3_vector3d_normalized_value((
weight0.mul_add(view_a.0, weight1.mul_add(view_b.0, weight2 * view_c.0)),
weight0.mul_add(view_a.1, weight1.mul_add(view_b.1, weight2 * view_c.1)),
weight0.mul_add(view_a.2, weight1.mul_add(view_b.2, weight2 * view_c.2)),
)),
_ => None,
},
fog_depth: weight0.mul_add(
a.fog_depth,
weight1.mul_add(b.fog_depth, weight2 * c.fog_depth),
),
uv: match (a.uv, b.uv, c.uv) {
(Some(uv_a), Some(uv_b), Some(uv_c)) => Some((
weight0.mul_add(uv_a.0, weight1.mul_add(uv_b.0, weight2 * uv_c.0)),
weight0.mul_add(uv_a.1, weight1.mul_add(uv_b.1, weight2 * uv_c.1)),
)),
_ => None,
},
diffuse: match (a.diffuse, b.diffuse, c.diffuse) {
(Some(diffuse_a), Some(diffuse_b), Some(diffuse_c)) => Some((
weight0.mul_add(
diffuse_a.0,
weight1.mul_add(diffuse_b.0, weight2 * diffuse_c.0),
),
weight0.mul_add(
diffuse_a.1,
weight1.mul_add(diffuse_b.1, weight2 * diffuse_c.1),
),
weight0.mul_add(
diffuse_a.2,
weight1.mul_add(diffuse_b.2, weight2 * diffuse_c.2),
),
)),
_ => None,
},
ambient_coefficient: match (
a.ambient_coefficient,
b.ambient_coefficient,
c.ambient_coefficient,
) {
(Some(coefficient_a), Some(coefficient_b), Some(coefficient_c)) => {
Some(weight0.mul_add(
coefficient_a,
weight1.mul_add(coefficient_b, weight2 * coefficient_c),
))
}
_ => None,
},
normal: match (a.normal, b.normal, c.normal) {
(Some(normal_a), Some(normal_b), Some(normal_c)) => ppc_q3_vector3d_normalized_value((
weight0.mul_add(
normal_a.0,
weight1.mul_add(normal_b.0, weight2 * normal_c.0),
),
weight0.mul_add(
normal_a.1,
weight1.mul_add(normal_b.1, weight2 * normal_c.1),
),
weight0.mul_add(
normal_a.2,
weight1.mul_add(normal_b.2, weight2 * normal_c.2),
),
)),
_ => None,
},
specular_color: match (a.specular_color, b.specular_color, c.specular_color) {
(Some(specular_a), Some(specular_b), Some(specular_c)) => Some((
weight0.mul_add(
specular_a.0,
weight1.mul_add(specular_b.0, weight2 * specular_c.0),
),
weight0.mul_add(
specular_a.1,
weight1.mul_add(specular_b.1, weight2 * specular_c.1),
),
weight0.mul_add(
specular_a.2,
weight1.mul_add(specular_b.2, weight2 * specular_c.2),
),
)),
_ => None,
},
specular_control: match (a.specular_control, b.specular_control, c.specular_control) {
(Some(control_a), Some(control_b), Some(control_c)) => {
Some(weight0.mul_add(control_a, weight1.mul_add(control_b, weight2 * control_c)))
}
_ => None,
},
highlight_state: match (a.highlight_state, b.highlight_state, c.highlight_state) {
(Some(state_a), Some(state_b), Some(state_c)) => Some(state_a && state_b && state_c),
_ => None,
},
vertex_alpha: match (a.vertex_alpha, b.vertex_alpha, c.vertex_alpha) {
(Some(alpha_a), Some(alpha_b), Some(alpha_c)) => {
Some(weight0.mul_add(alpha_a, weight1.mul_add(alpha_b, weight2 * alpha_c)))
}
_ => None,
},
}
}
fn ppc_q3_software_perspective_weights(
vertices: &[PpcQ3SoftwareProjectedPoint; 3],
weights: [f32; 3],
) -> [f32; 3] {
let weighted = [
weights[0] * vertices[0].reciprocal_w,
weights[1] * vertices[1].reciprocal_w,
weights[2] * vertices[2].reciprocal_w,
];
let sum = weighted[0] + weighted[1] + weighted[2];
if !sum.is_finite() || sum.abs() <= f32::EPSILON {
return weights;
}
[weighted[0] / sum, weighted[1] / sum, weighted[2] / sum]
}
fn ppc_q3_software_interpolate_material_output(
outputs: [PpcQ3SoftwareMaterialOutput; 3],
weight0: f32,
weight1: f32,
weight2: f32,
) -> PpcQ3SoftwareMaterialOutput {
let [a, b, c] = outputs;
PpcQ3SoftwareMaterialOutput {
color: (
weight0.mul_add(a.color.0, weight1.mul_add(b.color.0, weight2 * c.color.0)),
weight0.mul_add(a.color.1, weight1.mul_add(b.color.1, weight2 * c.color.1)),
weight0.mul_add(a.color.2, weight1.mul_add(b.color.2, weight2 * c.color.2)),
),
opacity: weight0.mul_add(a.opacity, weight1.mul_add(b.opacity, weight2 * c.opacity)),
}
}
fn ppc_q3_software_edge_value(
a: PpcQ3SoftwareProjectedPoint,
b: PpcQ3SoftwareProjectedPoint,
c: PpcQ3SoftwareProjectedPoint,
) -> i64 {
i64::from(c.x - a.x) * i64::from(b.y - a.y) - i64::from(c.y - a.y) * i64::from(b.x - a.x)
}
fn ppc_q3_software_triangle_edge_walker(
[a, b, c]: [PpcQ3SoftwareProjectedPoint; 3],
x: i32,
y: i32,
) -> ([i64; 3], [i64; 3], [i64; 3]) {
let point = 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,
};
(
[
ppc_q3_software_edge_value(b, c, point),
ppc_q3_software_edge_value(c, a, point),
ppc_q3_software_edge_value(a, b, point),
],
[
i64::from(c.y - b.y),
i64::from(a.y - c.y),
i64::from(b.y - a.y),
],
[
-i64::from(c.x - b.x),
-i64::from(a.x - c.x),
-i64::from(b.x - a.x),
],
)
}
fn ppc_q3_software_is_backfacing(
orientation_style: u32,
vertices: &[PpcQ3SoftwareProjectedPoint],
) -> bool {
if vertices.len() < 3 {
return false;
}
// Screen-space y points downward, reversing QD3D's projected winding.
let edge = ppc_q3_software_edge_value(vertices[0], vertices[1], vertices[2]);
if orientation_style == PPC_Q3_ORIENTATION_STYLE_CLOCKWISE {
edge < 0
} else {
edge > 0
}
}
fn ppc_q3_software_culls_backfacing(
backfacing_style: u32,
orientation_style: u32,
vertices: &[PpcQ3SoftwareProjectedPoint],
) -> bool {
match backfacing_style {
PPC_Q3_BACKFACING_STYLE_REMOVE => {
ppc_q3_software_is_backfacing(orientation_style, vertices)
}
PPC_Q3_BACKFACING_STYLE_BOTH | PPC_Q3_BACKFACING_STYLE_FLIP => false,
_ => false,
}
}
fn ppc_q3_software_flip_backfacing_normals(
backfacing_style: u32,
orientation_style: u32,
vertices: &mut [PpcQ3SoftwareProjectedPoint],
) {
if backfacing_style != PPC_Q3_BACKFACING_STYLE_FLIP
|| !ppc_q3_software_is_backfacing(orientation_style, vertices)
{
return;
}
for vertex in vertices {
if let Some((x, y, z)) = vertex.normal {
vertex.normal = Some((-x, -y, -z));
}
}
}
fn ppc_q3_software_weights_inside(area: i64, w0: i64, w1: i64, w2: i64) -> bool {
if area > 0 {
w0 >= 0 && w1 >= 0 && w2 >= 0
} else {
w0 <= 0 && w1 <= 0 && w2 <= 0
}
}
fn ppc_q3_draw_software_line(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
start: PpcQ3SoftwareProjectedPoint,
end: PpcQ3SoftwareProjectedPoint,
source: (f32, f32, f32),
transparency: (f32, f32, f32),
) -> usize {
let (mut x0, mut y0) = (start.x, start.y);
let (x1, y1) = (end.x, end.y);
let dx = (x1 - x0).abs();
let sx = if x0 < x1 { 1 } else { -1 };
let dy = -((y1 - y0).abs());
let sy = if y0 < y1 { 1 } else { -1 };
let mut err = dx + dy;
let mut pixels = 0usize;
loop {
let color = ppc_q3_software_material_output_pixel_color(
memory,
surface,
(x0, y0),
source,
transparency,
);
if surface.write_pixel(memory, (x0, y0), color) {
pixels = pixels.saturating_add(1);
}
if x0 == x1 && y0 == y1 {
break;
}
let e2 = err.saturating_mul(2);
if e2 >= dy {
err += dy;
x0 += sx;
}
if e2 <= dx {
err += dx;
y0 += sy;
}
}
pixels
}
fn ppc_q3_draw_software_line_depth_test(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
depth_buffer: &PpcQ3SoftwareDepthBuffer,
start: PpcQ3SoftwareProjectedPoint,
end: PpcQ3SoftwareProjectedPoint,
source: (f32, f32, f32),
transparency: (f32, f32, f32),
) -> usize {
let (mut x0, mut y0) = (start.x, start.y);
let (x1, y1) = (end.x, end.y);
let dx = (x1 - x0).abs();
let sx = if x0 < x1 { 1 } else { -1 };
let dy_abs = (y1 - y0).abs();
let dy = -dy_abs;
let sy = if y0 < y1 { 1 } else { -1 };
let steps = dx.max(dy_abs).max(1) as f32;
let mut err = dx + dy;
let mut step = 0usize;
let mut pixels = 0usize;
loop {
let t = (step as f32 / steps).clamp(0.0, 1.0);
let z = start.z.mul_add(1.0 - t, end.z * t);
if x0 >= 0 && y0 >= 0 && depth_buffer.test(x0 as u32, y0 as u32, z) {
let color = ppc_q3_software_material_output_pixel_color(
memory,
surface,
(x0, y0),
source,
transparency,
);
if surface.write_pixel(memory, (x0, y0), color) {
pixels = pixels.saturating_add(1);
}
}
if x0 == x1 && y0 == y1 {
break;
}
let e2 = err.saturating_mul(2);
if e2 >= dy {
err += dy;
x0 += sx;
}
if e2 <= dx {
err += dx;
y0 += sy;
}
step = step.saturating_add(1);
}
pixels
}
fn ppc_q3_draw_or_defer_software_edge_loop(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
vertices: &[PpcQ3SoftwareProjectedPoint],
material: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
edge_materials: &[Option<PpcQ3SoftwareEdgeMaterial>],
deferred_primitives: &mut Vec<PpcQ3SoftwareDeferredPrimitive>,
) -> usize {
if vertices.len() < 2 {
return 0;
}
let mut pixels = 0usize;
for index in 0..vertices.len() {
let (start, end) = ppc_q3_software_edge_material_points(
vertices[index],
vertices[(index + 1) % vertices.len()],
edge_materials.get(index).and_then(|record| *record),
);
if ppc_q3_software_primitive_deferred_for_transparency(material, &[start, end]) {
deferred_primitives.push(PpcQ3SoftwareDeferredPrimitive::Edge {
start,
end,
material: *material,
lights: lights.clone(),
sort_depth: ppc_q3_software_line_sort_depth(start, end),
});
} else {
pixels = pixels.saturating_add(ppc_q3_draw_software_material_line(
memory, surface, start, end, material, lights,
));
}
}
pixels
}
fn ppc_q3_software_edge_material_points(
mut start: PpcQ3SoftwareProjectedPoint,
mut end: PpcQ3SoftwareProjectedPoint,
edge_material: Option<PpcQ3SoftwareEdgeMaterial>,
) -> (PpcQ3SoftwareProjectedPoint, PpcQ3SoftwareProjectedPoint) {
if let Some(edge_material) = edge_material {
if let Some(diffuse) = edge_material.diffuse {
start.diffuse = Some(diffuse);
end.diffuse = Some(diffuse);
}
if let Some(ambient_coefficient) = edge_material.ambient_coefficient {
start.ambient_coefficient = Some(ambient_coefficient);
end.ambient_coefficient = Some(ambient_coefficient);
}
if let Some(vertex_alpha) = edge_material.vertex_alpha {
start.vertex_alpha = Some(vertex_alpha);
end.vertex_alpha = Some(vertex_alpha);
}
if let Some(specular_color) = edge_material.specular_color {
start.specular_color = Some(specular_color);
end.specular_color = Some(specular_color);
}
if let Some(specular_control) = edge_material.specular_control {
start.specular_control = Some(specular_control);
end.specular_control = Some(specular_control);
}
if let Some(highlight_state) = edge_material.highlight_state {
start.highlight_state = Some(highlight_state);
end.highlight_state = Some(highlight_state);
}
if let Some(normal) = edge_material.normal {
start.normal = Some(normal);
end.normal = Some(normal);
}
}
(start, end)
}
fn ppc_q3_software_triangle_edge_materials(
edge_indices: &HashMap<u64, usize>,
edge_diffuse_colors: Option<&[(f32, f32, f32)]>,
edge_ambient_coefficients: Option<&[f32]>,
edge_specular_colors: Option<&[(f32, f32, f32)]>,
edge_specular_controls: Option<&[f32]>,
edge_highlight_states: Option<&[bool]>,
edge_normals: Option<&[(f32, f32, f32)]>,
edge_alphas: Option<&[f32]>,
points: [usize; 3],
) -> [Option<PpcQ3SoftwareEdgeMaterial>; 3] {
[
ppc_q3_software_edge_material(
edge_indices,
edge_diffuse_colors,
edge_ambient_coefficients,
edge_specular_colors,
edge_specular_controls,
edge_highlight_states,
edge_normals,
edge_alphas,
[points[0], points[1]],
),
ppc_q3_software_edge_material(
edge_indices,
edge_diffuse_colors,
edge_ambient_coefficients,
edge_specular_colors,
edge_specular_controls,
edge_highlight_states,
edge_normals,
edge_alphas,
[points[1], points[2]],
),
ppc_q3_software_edge_material(
edge_indices,
edge_diffuse_colors,
edge_ambient_coefficients,
edge_specular_colors,
edge_specular_controls,
edge_highlight_states,
edge_normals,
edge_alphas,
[points[2], points[0]],
),
]
}
fn ppc_q3_software_edge_index_map(edges: &[PpcQ3SoftwareEdge]) -> HashMap<u64, usize> {
let mut edge_indices = HashMap::with_capacity(edges.len());
for edge in edges {
edge_indices.insert(
ppc_q3_software_edge_key(edge.points[0], edge.points[1]),
edge.index,
);
}
edge_indices
}
fn ppc_q3_software_edge_key(a: usize, b: usize) -> u64 {
let (a, b) = if a <= b { (a, b) } else { (b, a) };
((a as u64) << 32) | b as u64
}
fn ppc_q3_software_edge_material(
edge_indices: &HashMap<u64, usize>,
edge_diffuse_colors: Option<&[(f32, f32, f32)]>,
edge_ambient_coefficients: Option<&[f32]>,
edge_specular_colors: Option<&[(f32, f32, f32)]>,
edge_specular_controls: Option<&[f32]>,
edge_highlight_states: Option<&[bool]>,
edge_normals: Option<&[(f32, f32, f32)]>,
edge_alphas: Option<&[f32]>,
points: [usize; 2],
) -> Option<PpcQ3SoftwareEdgeMaterial> {
let edge_index = *edge_indices.get(&ppc_q3_software_edge_key(points[0], points[1]))?;
let diffuse = edge_diffuse_colors.and_then(|colors| colors.get(edge_index).copied());
let ambient_coefficient =
edge_ambient_coefficients.and_then(|coefficients| coefficients.get(edge_index).copied());
let specular_color = edge_specular_colors.and_then(|colors| colors.get(edge_index).copied());
let specular_control =
edge_specular_controls.and_then(|controls| controls.get(edge_index).copied());
let highlight_state = edge_highlight_states.and_then(|states| states.get(edge_index).copied());
let normal = edge_normals.and_then(|normals| normals.get(edge_index).copied());
let vertex_alpha = edge_alphas.and_then(|alphas| alphas.get(edge_index).copied());
if diffuse.is_none()
&& ambient_coefficient.is_none()
&& specular_color.is_none()
&& specular_control.is_none()
&& highlight_state.is_none()
&& normal.is_none()
&& vertex_alpha.is_none()
{
None
} else {
Some(PpcQ3SoftwareEdgeMaterial {
diffuse,
ambient_coefficient,
specular_color,
specular_control,
highlight_state,
normal,
vertex_alpha,
})
}
}
fn ppc_q3_draw_software_material_line(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
start: PpcQ3SoftwareProjectedPoint,
end: PpcQ3SoftwareProjectedPoint,
material: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
) -> usize {
let midpoint = ppc_q3_software_projected_line_midpoint(start, end);
let output = ppc_q3_software_material_shaded_output(
memory,
material,
lights,
midpoint.uv,
midpoint.diffuse,
midpoint.ambient_coefficient,
midpoint.normal,
midpoint.specular_color,
midpoint.specular_control,
midpoint.highlight_state,
Some(midpoint.world),
midpoint.view_direction,
midpoint.fog_depth,
midpoint.vertex_alpha,
);
let opacity = ppc_q3_software_blend_opacity(material, output.opacity, midpoint.vertex_alpha);
let transparency = ppc_q3_software_effective_transparency(material.transparency, opacity);
ppc_q3_draw_software_line(memory, surface, start, end, output.color, transparency)
}
fn ppc_q3_draw_deferred_software_material_line(
memory: &mut PpcSectionMem,
surface: PpcQ3SoftwareFrontBufferSurface,
depth_buffer: &PpcQ3SoftwareDepthBuffer,
start: PpcQ3SoftwareProjectedPoint,
end: PpcQ3SoftwareProjectedPoint,
material: &PpcQ3SoftwareMaterialSample,
lights: &PpcQ3SubmissionLightRecord,
) -> usize {
let midpoint = ppc_q3_software_projected_line_midpoint(start, end);
let output = ppc_q3_software_material_shaded_output(
memory,
material,
lights,
midpoint.uv,
midpoint.diffuse,
midpoint.ambient_coefficient,
midpoint.normal,
midpoint.specular_color,
midpoint.specular_control,
midpoint.highlight_state,
Some(midpoint.world),
midpoint.view_direction,
midpoint.fog_depth,
midpoint.vertex_alpha,
);
let opacity = ppc_q3_software_blend_opacity(material, output.opacity, midpoint.vertex_alpha);
let transparency = ppc_q3_software_effective_transparency(material.transparency, opacity);
ppc_q3_draw_software_line_depth_test(
memory,
surface,
depth_buffer,
start,
end,
output.color,
transparency,
)
}
fn ppc_q3_software_projected_line_midpoint(
start: PpcQ3SoftwareProjectedPoint,
end: PpcQ3SoftwareProjectedPoint,
) -> PpcQ3SoftwareProjectedPoint {
PpcQ3SoftwareProjectedPoint {
x: ((start.x as f32 + end.x as f32) * 0.5).round() as i32,
y: ((start.y as f32 + end.y as f32) * 0.5).round() as i32,
z: start.z.mul_add(0.5, end.z * 0.5),
reciprocal_w: start.reciprocal_w.mul_add(0.5, end.reciprocal_w * 0.5),
world: (
start.world.0.mul_add(0.5, end.world.0 * 0.5),
start.world.1.mul_add(0.5, end.world.1 * 0.5),
start.world.2.mul_add(0.5, end.world.2 * 0.5),
),
view_direction: match (start.view_direction, end.view_direction) {
(Some(start_view), Some(end_view)) => ppc_q3_vector3d_normalized_value((
start_view.0.mul_add(0.5, end_view.0 * 0.5),
start_view.1.mul_add(0.5, end_view.1 * 0.5),
start_view.2.mul_add(0.5, end_view.2 * 0.5),
)),
_ => None,
},
fog_depth: start.fog_depth.mul_add(0.5, end.fog_depth * 0.5),
uv: match (start.uv, end.uv) {
(Some(start_uv), Some(end_uv)) => Some((
start_uv.0.mul_add(0.5, end_uv.0 * 0.5),
start_uv.1.mul_add(0.5, end_uv.1 * 0.5),
)),
_ => None,
},
diffuse: match (start.diffuse, end.diffuse) {
(Some(start_diffuse), Some(end_diffuse)) => Some((
start_diffuse.0.mul_add(0.5, end_diffuse.0 * 0.5),
start_diffuse.1.mul_add(0.5, end_diffuse.1 * 0.5),
start_diffuse.2.mul_add(0.5, end_diffuse.2 * 0.5),
)),
_ => None,
},
ambient_coefficient: match (start.ambient_coefficient, end.ambient_coefficient) {
(Some(start_coefficient), Some(end_coefficient)) => {
Some(start_coefficient.mul_add(0.5, end_coefficient * 0.5))
}
_ => None,
},
normal: match (start.normal, end.normal) {
(Some(start_normal), Some(end_normal)) => ppc_q3_vector3d_normalized_value((
start_normal.0.mul_add(0.5, end_normal.0 * 0.5),
start_normal.1.mul_add(0.5, end_normal.1 * 0.5),
start_normal.2.mul_add(0.5, end_normal.2 * 0.5),
)),
_ => None,
},
specular_color: match (start.specular_color, end.specular_color) {
(Some(start_specular), Some(end_specular)) => Some((
start_specular.0.mul_add(0.5, end_specular.0 * 0.5),
start_specular.1.mul_add(0.5, end_specular.1 * 0.5),
start_specular.2.mul_add(0.5, end_specular.2 * 0.5),
)),
_ => None,
},
specular_control: match (start.specular_control, end.specular_control) {
(Some(start_control), Some(end_control)) => {
Some(start_control.mul_add(0.5, end_control * 0.5))
}
_ => None,
},
highlight_state: match (start.highlight_state, end.highlight_state) {
(Some(start_state), Some(end_state)) => Some(start_state && end_state),
_ => None,
},
vertex_alpha: match (start.vertex_alpha, end.vertex_alpha) {
(Some(start_alpha), Some(end_alpha)) => Some(start_alpha.mul_add(0.5, end_alpha * 0.5)),
_ => None,
},
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PpcRelocationImportSymbol {
pub symbol_index: u32,
pub library_name: String,
pub symbol_name: String,
pub class: u8,
pub weak: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PpcLoadError {
PefParse,
SectionInstantiation,
NoCodeSection,
NoDataSection,
MainSectionMissing {
section_index: i32,
},
MainTVectorOutOfRange {
section_index: i32,
offset: u32,
},
RelocationStream {
section_index: u16,
},
RelocationApply {
section_index: u16,
reloc_instr_offset: u32,
section_position: u32,
import_index: Option<u32>,
import_symbol: Option<PpcRelocationImportSymbol>,
error: PefRelocApplyError,
},
ImportBindingOutOfRange {
symbol_index: u32,
import_count: u32,
},
ImportCapacityExceeded {
import_count: u32,
capacity: u32,
},
StackSizeOutOfRange {
requested: u32,
},
ScreenDepthOutOfRange {
requested: u32,
},
AddressOverflow,
}
pub fn load_pef_application(data: &[u8]) -> Result<PpcLoadedApp, PpcLoadError> {
load_pef_application_with_config(data, PpcLoadConfig::default())
}
pub fn load_pef_application_with_config(
data: &[u8],
config: PpcLoadConfig,
) -> Result<PpcLoadedApp, PpcLoadError> {
load_pef_application_with_config_and_optional_system_reservation(data, config, None)
}
pub(crate) fn load_pef_application_with_config_and_system_reservation(
data: &[u8],
config: PpcLoadConfig,
system_reservation: (u32, u32),
) -> Result<PpcLoadedApp, PpcLoadError> {
load_pef_application_with_config_and_optional_system_reservation(
data,
config,
Some(system_reservation),
)
}
fn load_pef_application_with_config_and_optional_system_reservation(
data: &[u8],
config: PpcLoadConfig,
system_reservation: Option<(u32, u32)>,
) -> Result<PpcLoadedApp, PpcLoadError> {
if !matches!(config.screen_depth, 1 | 2 | 4 | 8 | 16) {
return Err(PpcLoadError::ScreenDepthOutOfRange {
requested: config.screen_depth,
});
}
let header = parse_pef_header(data).ok_or(PpcLoadError::PefParse)?;
let raw_sections = parse_pef_sections(data).ok_or(PpcLoadError::PefParse)?;
let loader = parse_pef_loader_header(data).ok_or(PpcLoadError::PefParse)?;
let resolved_imports = resolve_pef_imports(data).unwrap_or_default();
let imported_symbols = parse_pef_imported_symbols(data).unwrap_or_default();
let import_plan = PpcImportBindingPlan::prepare(
resolved_imports,
imported_symbols.len(),
0,
ppc_import_layout(),
&SystemlessPpcImportBindingPolicy,
)
.map_err(ppc_initial_import_error)?;
let import_addrs = import_plan.relocation_addresses().to_vec();
let imports = import_plan.into_initial_bindings();
let mut mapped_sections = map_instantiated_sections(data)?;
let section_bases = section_bases(&mapped_sections);
let code_base = first_base_for_kind(&mapped_sections, SECTION_KIND_CODE)
.ok_or(PpcLoadError::NoCodeSection)?;
let data_base = first_data_base(&mapped_sections).ok_or(PpcLoadError::NoDataSection)?;
let reloc_headers = parse_pef_reloc_headers(data).unwrap_or_default();
for reloc in &reloc_headers {
let stream = pef_reloc_chunk_stream(data, reloc).ok_or(PpcLoadError::RelocationStream {
section_index: reloc.section_index,
})?;
let mapped = mapped_sections
.iter_mut()
.find(|section| section.index == usize::from(reloc.section_index))
.ok_or(PpcLoadError::RelocationStream {
section_index: reloc.section_index,
})?;
let ctx = PefRelocContext {
code_base,
data_base,
section_bases: §ion_bases,
import_addrs: &import_addrs,
};
apply_pef_relocations_detailed(&mut mapped.bytes, stream, &ctx).map_err(|failure| {
let import_symbol = failure
.import_index
.and_then(|index| relocation_import_symbol(&imports, index));
PpcLoadError::RelocationApply {
section_index: reloc.section_index,
reloc_instr_offset: reloc
.first_reloc_offset
.checked_add(failure.reloc_offset)
.unwrap_or(u32::MAX),
section_position: failure.section_position,
import_index: failure.import_index,
import_symbol,
error: failure.error,
}
})?;
}
let main_section = mapped_sections
.iter()
.find(|section| section.index == usize::try_from(loader.main_section).unwrap_or(usize::MAX))
.ok_or(PpcLoadError::MainSectionMissing {
section_index: loader.main_section,
})?;
let main_offset =
usize::try_from(loader.main_offset).map_err(|_| PpcLoadError::MainTVectorOutOfRange {
section_index: loader.main_section,
offset: loader.main_offset,
})?;
let tvector_end = main_offset
.checked_add(8)
.ok_or(PpcLoadError::MainTVectorOutOfRange {
section_index: loader.main_section,
offset: loader.main_offset,
})?;
if tvector_end > main_section.bytes.len() {
return Err(PpcLoadError::MainTVectorOutOfRange {
section_index: loader.main_section,
offset: loader.main_offset,
});
}
let entry_pc =
read_u32(&main_section.bytes, main_offset).ok_or(PpcLoadError::MainTVectorOutOfRange {
section_index: loader.main_section,
offset: loader.main_offset,
})?;
let rtoc = read_u32(&main_section.bytes, main_offset + 4).ok_or(
PpcLoadError::MainTVectorOutOfRange {
section_index: loader.main_section,
offset: loader.main_offset,
},
)?;
let special_tvector = |section_index: i32, offset: u32| -> Option<(u32, u32, u32)> {
if section_index < 0 {
return None;
}
let section_index = usize::try_from(section_index).ok()?;
let section = mapped_sections
.iter()
.find(|section| section.index == section_index)?;
let offset = usize::try_from(offset).ok()?;
let entry = read_u32(§ion.bytes, offset)?;
let rtoc = read_u32(§ion.bytes, offset.checked_add(4)?)?;
let descriptor = section.base.checked_add(offset as u32)?;
Some((descriptor, entry, rtoc))
};
let init_tvector = special_tvector(loader.init_section, loader.init_offset);
let term_tvector = special_tvector(loader.term_section, loader.term_offset);
if loader.init_section >= 0 && init_tvector.is_none() {
return Err(PpcLoadError::PefParse);
}
if loader.term_section >= 0 && term_tvector.is_none() {
return Err(PpcLoadError::PefParse);
}
let main_tvector = main_section.base + loader.main_offset;
let stack_size = normalize_stack_size(config.stack_size)?;
let stack_base =
PPC_STACK_TOP
.checked_sub(stack_size)
.ok_or(PpcLoadError::StackSizeOutOfRange {
requested: config.stack_size,
})?;
if stack_base <= PPC_HEAP_BASE {
return Err(PpcLoadError::StackSizeOutOfRange {
requested: config.stack_size,
});
}
maybe_write(&PefDumpContext {
data_len: data.len(),
header,
loader,
raw_sections: &raw_sections,
mapped_sections: &mapped_sections,
imports: &imports,
reloc_headers: &reloc_headers,
entry_pc,
rtoc,
stack_base,
stack_size,
stack_top: PPC_STACK_TOP,
});
let mut memory = PpcSectionMem::new();
if let Some((base, len)) = system_reservation {
memory
.add_readonly_allocation_exclusion(base, len)
.ok_or(PpcLoadError::AddressOverflow)?;
}
memory.add_region(PPC_HALT_PC, vec![0u8; PPC_LOW_MEMORY_SIZE]);
let _ = memory.write_u16_be(
crate::memory::globals::addr::SYS_EVT_MASK,
crate::memory::globals::DEFAULT_SYS_EVT_MASK,
);
let _ = memory.write_u16_be(
crate::memory::globals::addr::MENU_FLASH,
crate::memory::globals::DEFAULT_MENU_FLASH_COUNT,
);
let _ = memory.write_u16_be(PPC_MBAR_HEIGHT_ADDR, 20);
let _ = memory.write_u16_be(PPC_THE_MENU_ADDR, 0);
// PaintOne normally starts with PaintWhite enabled. Carbon's generated
// low-memory accessors preserve this flag around window creation.
let _ = memory.write_u16_be(0x09dc, 1);
// Inside Macintosh Volume V (1986), pp. V-592--V-593, documents the
// MMU32Bit low-memory byte at $0CB2. Native PowerPC processes always use
// 32-bit addressing.
let _ = memory.write_u8(PPC_MMU_32BIT_ADDR, 1);
let _ = memory.write_u32_be(
crate::memory::globals::addr::DOUBLE_TIME,
PPC_DEFAULT_DOUBLE_TIME_TICKS,
);
let _ = memory.write_u8(crate::memory::globals::addr::SD_VOLUME, 1);
memory.add_region(
PPC_CLASSIC_APP_MEMORY_BASE,
vec![0u8; PPC_CLASSIC_APP_MEMORY_SIZE],
);
for section in mapped_sections {
if section.section_kind == SECTION_KIND_CODE
|| section.section_kind == SECTION_KIND_CONSTANT
{
memory.add_readonly_region(section.base, section.bytes);
} else {
memory.add_region(section.base, section.bytes);
}
}
// Keep a bounded pool of synthetic import slots mapped from launch so
// GetMemFragment can bind imports while the CPU is already running.
memory
.publish_system_code(
GuestIsa::PowerPc,
PPC_IMPORT_TVECTOR_BASE,
import_tvector_bytes(PPC_IMPORT_SLOT_COUNT as usize),
)
.ok_or(PpcLoadError::AddressOverflow)?;
memory
.publish_system_code(
GuestIsa::PowerPc,
PPC_IMPORT_TRAP_BASE,
import_trap_bytes(PPC_IMPORT_SLOT_COUNT as usize),
)
.ok_or(PpcLoadError::AddressOverflow)?;
memory.add_region(PPC_IMPORT_DATA_BASE, vec![0; PPC_IMPORT_DATA_SIZE]);
ppc_seed_import_data(&mut memory);
memory
.publish_system_code(
GuestIsa::PowerPc,
PPC_CFM_MAIN_STUB_BASE,
import_trap_bytes(PPC_CFM_MAIN_STUB_COUNT as usize),
)
.ok_or(PpcLoadError::AddressOverflow)?;
memory.add_region(PPC_MAIN_GWORLD, vec![0u8; 256]);
memory.add_region(PPC_MAIN_GDEVICE, vec![0u8; 256]);
memory.add_region(PPC_MAIN_GDEVICE_RECORD, vec![0u8; 256]);
memory.add_region(PPC_MAIN_PIXMAP_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_MAIN_PIXMAP, vec![0u8; PPC_PIXMAP_SIZE as usize]);
memory.add_region(PPC_GRAY_RGN_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_GRAY_RGN, vec![0u8; 10]);
memory.add_region(PPC_MAIN_DCE_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_MAIN_DCE, vec![0u8; 52]);
memory.add_region(PPC_MAIN_CTABLE_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_MAIN_CTABLE, vec![0u8; PPC_MAIN_CTABLE_SIZE as usize]);
memory.add_region(PPC_MAIN_VIS_RGN_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_MAIN_VIS_RGN, vec![0u8; 10]);
memory.add_region(PPC_MAIN_CLIP_RGN_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_MAIN_CLIP_RGN, vec![0u8; 10]);
// Universal Interfaces 3.4 Video.h defines GammaTbl as a six-word
// header followed by formula bytes and channel data. The main display's
// device-owned table is the standard one-channel, 8-bit linear ramp.
let mut gamma_table = vec![0u8; PPC_MAIN_GAMMA_TABLE_SIZE as usize];
gamma_table[6..8].copy_from_slice(&1u16.to_be_bytes()); // gChanCnt
gamma_table[8..10].copy_from_slice(&256u16.to_be_bytes()); // gDataCnt
gamma_table[10..12].copy_from_slice(&8u16.to_be_bytes()); // gDataWidth
for (value, output) in gamma_table[12..].iter_mut().enumerate() {
*output = value as u8;
}
memory.add_readonly_region(PPC_MAIN_GAMMA_TABLE, gamma_table);
memory.add_region(PPC_PORT_LIST_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_PORT_LIST, vec![0u8; 2]);
memory.add_region(PPC_UNIT_TABLE, vec![0u8; 64 * 4]);
memory.add_region(PPC_SOUND_DCE_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_SOUND_DCE, vec![0u8; 52]);
// PortList is a QuickDraw-owned handle whose first word is the number of
// registered ports. Keep a valid empty list even though native clients
// normally reach it through the Window Manager instead of low memory.
let _ = memory.write_u32_be(PPC_PORT_LIST_ADDR, PPC_PORT_LIST_HANDLE);
let _ = memory.write_u32_be(PPC_PORT_LIST_HANDLE, PPC_PORT_LIST);
let _ = memory.write_u16_be(PPC_PORT_LIST, 0);
let _ = memory.write_u32_be(PPC_SOUND_DCE_HANDLE, PPC_SOUND_DCE);
let _ = memory.write_u16_be(PPC_SOUND_DCE + 24, (-4i16) as u16);
let _ = memory.write_u32_be(PPC_UNIT_TABLE + 3 * 4, PPC_SOUND_DCE_HANDLE);
memory.add_region(PPC_APPLICATION_ZONE, vec![0u8; PPC_ZONE_STORAGE_SIZE]);
memory.add_region(PPC_SYSTEM_ZONE, vec![0u8; PPC_ZONE_STORAGE_SIZE]);
ppc_seed_zone_header(
&mut memory,
PPC_APPLICATION_ZONE,
PPC_HEAP_BASE,
stack_base,
64,
);
ppc_seed_zone_header(&mut memory, PPC_SYSTEM_ZONE, PPC_HEAP_BASE, stack_base, 32);
let _ = memory.write_u32_be(PPC_THE_ZONE_ADDR, PPC_APPLICATION_ZONE);
let _ = memory.write_u32_be(PPC_APPL_ZONE_ADDR, PPC_APPLICATION_ZONE);
let _ = memory.write_u32_be(PPC_SYS_ZONE_ADDR, PPC_SYSTEM_ZONE);
memory.add_region(
PPC_MAIN_SCREEN_BASE,
vec![0u8; ppc_main_screen_buffer_size() as usize],
);
memory.add_region(PPC_DSP_BACK_GWORLD, vec![0u8; 256]);
memory.add_region(PPC_DSP_BACK_PIXMAP_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_DSP_BACK_PIXMAP, vec![0u8; PPC_PIXMAP_SIZE as usize]);
memory.add_region(PPC_DSP_BACK_VIS_RGN_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_DSP_BACK_VIS_RGN, vec![0u8; 10]);
memory.add_region(PPC_DSP_BACK_CLIP_RGN_HANDLE, vec![0u8; 4]);
memory.add_region(PPC_DSP_BACK_CLIP_RGN, vec![0u8; 10]);
memory.add_region(
PPC_DSP_BACK_SCREEN_BASE,
vec![0u8; ppc_main_screen_buffer_size() as usize],
);
memory.add_region(PPC_DSP_CONTEXT, vec![0u8; PPC_QA_OBJECTS_SIZE]);
ppc_seed_qa_rave_objects(&mut memory);
if init_tvector.is_some() {
memory
.publish_system_code(
GuestIsa::PowerPc,
PPC_APPLICATION_INIT_RETURN_PC,
ppc_application_init_return_trampoline(entry_pc, rtoc),
)
.ok_or(PpcLoadError::AddressOverflow)?;
}
let mut gworlds = vec![
ppc_seed_main_gworld(&mut memory),
ppc_seed_dsp_back_gworld(&mut memory),
];
// Loader-owned screen worlds remain lazy compatibility projections so two
// pristine adapters can attach to the same process without presenting
// duplicate populated registries. The first pixel-state operation adopts
// their non-purgeable mirror; NewGWorld records are registered eagerly.
let gworld_pixel_states = SharedProcessQuickDrawPixelStates::default();
if let Some((base, len)) = system_reservation {
let reservation_start = u64::from(base);
let reservation_end = reservation_start + u64::from(len);
let overlaps_stack =
reservation_start < u64::from(PPC_STACK_TOP) && u64::from(stack_base) < reservation_end;
if overlaps_stack || memory.mapping_overlaps(base, len) {
return Err(PpcLoadError::AddressOverflow);
}
}
memory.add_region(
PPC_HEAP_BASE,
vec![0u8; usize::try_from(stack_base - PPC_HEAP_BASE).unwrap()],
);
let mut heap_cursor = PPC_HEAP_BASE;
let mut cfm_connections = Vec::new();
let mut next_cfm_connection_id = PPC_FIRST_CFM_CONNECTION_ID;
let startup = if let Some((init_addr, init_entry, init_rtoc)) = init_tvector {
// Inside Macintosh: PowerPC System Software (1994), pp. 3-15--3-18
// requires CFM to call a fragment initializer before its main routine.
// Keep a guest-visible copy of the PEF as an in-memory fragment locator
// so the initializer receives the documented InitBlock contract.
let fragment_size = u32::try_from(data.len()).map_err(|_| PpcLoadError::AddressOverflow)?;
let fragment_addr = ppc_heap_alloc(
&mut memory,
&mut heap_cursor,
stack_base,
fragment_size,
false,
);
if fragment_addr == 0 || memory.write_bytes(fragment_addr, data).is_none() {
return Err(PpcLoadError::AddressOverflow);
}
let init_block = ppc_create_mem_fragment_init_block(
None,
&mut memory,
&mut heap_cursor,
stack_base,
PPC_FIRST_CFM_CONNECTION_ID,
fragment_addr,
fragment_size,
"application",
)
.map_err(|_| PpcLoadError::AddressOverflow)?;
cfm_connections.push(PpcCfmConnection {
id: PPC_FIRST_CFM_CONNECTION_ID,
library_name: "application".to_string(),
main_addr: main_tvector,
init_addr,
term_addr: term_tvector.map_or(0, |(addr, _, _)| addr),
exports: Vec::new(),
});
next_cfm_connection_id += 1;
Some((init_entry, init_rtoc, init_block))
} else {
None
};
let stack_pointer = PPC_STACK_TOP - PPC_INITIAL_STACK_FRAME_SIZE;
let mut stack = vec![0u8; stack_size as usize];
let sp_offset = usize::try_from(stack_pointer - stack_base).unwrap();
stack[sp_offset..sp_offset + 4].copy_from_slice(&0u32.to_be_bytes());
memory.add_region(stack_base, stack);
let mut cpu = PpcCpu::new();
cpu.alignment_policy = PpcAlignmentPolicy::EmulateData;
cpu.pc = startup.map_or(entry_pc, |(entry, _, _)| entry);
cpu.gpr[1] = stack_pointer;
cpu.gpr[2] = startup.map_or(rtoc, |(_, init_rtoc, _)| init_rtoc);
cpu.gpr[3] = startup.map_or(0, |(_, _, init_block)| init_block);
cpu.lr = startup.map_or(PPC_HALT_PC, |_| PPC_APPLICATION_INIT_RETURN_PC);
let mut toolbox_startup = PpcToolboxStartupState::default();
let mut handles = Vec::new();
let mut screen_clut = TrapDispatcher::standard_mac_8bpp_clut();
let mut color_manager_clut = screen_clut;
let process_memory_manager = PpcProcessMemoryManager::with_heap(heap_cursor, stack_base);
if config.screen_depth != PPC_MAIN_PIXEL_DEPTH {
let saved_r3 = cpu.gpr[3];
let saved_r4 = cpu.gpr[4];
cpu.gpr[3] = PPC_MAIN_GDEVICE;
cpu.gpr[4] = config.screen_depth;
let mut last_mem_error = PPC_NO_ERR;
let shared_memory_manager = process_memory_manager.0.clone();
let mut memory_manager = shared_memory_manager.borrow_mut();
let mut allocator = PpcProcessAllocatorView {
memory_manager: memory_manager.native_mut(),
};
let result = ppc_set_depth(
&cpu,
Some(&mut allocator),
&mut memory,
&mut heap_cursor,
stack_base,
&mut last_mem_error,
&mut handles,
&mut gworlds,
&mut toolbox_startup,
&mut screen_clut,
&mut color_manager_clut,
);
cpu.gpr[3] = saved_r3;
cpu.gpr[4] = saved_r4;
if result != PPC_NO_ERR {
return Err(PpcLoadError::ScreenDepthOutOfRange {
requested: config.screen_depth,
});
}
}
let sound = PpcSoundState::default();
sound
.manager
.set_default_output_volume(PPC_DEFAULT_OUTPUT_VOLUME);
Ok(PpcLoadedApp {
cpu,
memory,
entry_pc,
rtoc,
stack_base,
stack_size,
stack_pointer,
tick_state: SharedProcessTickState::default(),
clock_cycles_per_tick: 1,
clock_cycle_phase: 0,
native_exception_handler: 0,
native_exception_stack: Vec::new(),
stdc_qsort_stack: Vec::new(),
dialog_callback_stack: Vec::new(),
apple_events: PpcAppleEventState::default(),
cfm: Some(PpcCfmState {
connections: cfm_connections,
library_fragments: Vec::new(),
next_connection_id: next_cfm_connection_id,
}),
controls: SharedProcessControlManager::default(),
aliases: Vec::new(),
gworlds,
gworld_pixel_states,
q3_objects: Vec::new(),
q3_object_refs: Vec::new(),
next_q3_object: PPC_Q3_OBJECT_BASE,
q3_error_state: PpcQ3ErrorState::default(),
q3_lifecycle: PpcQ3LifecycleState::default(),
q3_memory_storages: Vec::new(),
q3_files: Vec::new(),
q3_group_memberships: Vec::new(),
q3_file_groups: Vec::new(),
q3_views: Vec::new(),
q3_submissions: Vec::new(),
q3_view_transforms: Vec::new(),
q3_submission_transforms: Vec::new(),
q3_view_materials: Vec::new(),
q3_submission_materials: Vec::new(),
q3_submission_lights: Vec::new(),
q3_view_state_stack: Vec::new(),
q3_completed_frames: Vec::new(),
q3_retained_frames: Vec::new(),
q3_state_only_completed_frame_batches: Vec::new(),
q3_fog_styles: Vec::new(),
q3_attributes: Vec::new(),
q3_shader_uv_transforms: Vec::new(),
q3_shader_boundaries: Vec::new(),
q3_mipmap_textures: Vec::new(),
q3_texture_shaders: Vec::new(),
q3_renderer_preferences: Vec::new(),
q3_draw_contexts: Vec::new(),
q3_trimeshes: Vec::new(),
q3_styles: Vec::new(),
q3_cameras: Vec::new(),
q3_lights: Vec::new(),
input_sprocket: PpcInputSprocketState::default(),
input_sprocket_virtual_elements: Vec::new(),
toolbox_startup,
quicktime: PpcQuickTimeState::default(),
sound,
timer_tasks: Default::default(),
vbl_tasks: Default::default(),
callback_scheduling: Default::default(),
process_file_system: ppc_initial_process_file_system(),
current_gworld: SharedProcessValue::from_value(PPC_MAIN_GWORLD),
current_gdevice: SharedProcessValue::from_value(PPC_MAIN_GDEVICE),
quickdraw_op_colors: SharedProcessQuickDrawOpColors::default(),
quickdraw_hilite_colors: SharedProcessQuickDrawHiliteColors::default(),
screen_clut: SharedProcessValue::from_value(screen_clut),
color_manager_clut: SharedProcessValue::from_value(color_manager_clut),
display_gamma: SharedProcessDisplayGamma::default(),
process_quickdraw_port_state_attached: false,
quickdraw_fore_color: PPC_RGB_BLACK,
quickdraw_fore_indices: HashMap::new(),
quickdraw_back_color: PPC_RGB_WHITE,
quickdraw_pen_h: 0,
quickdraw_pen_v: 0,
quickdraw_text_mode: PPC_QD_TEXT_MODE_SRC_OR,
quickdraw_text_size: PPC_QD_TEXT_SIZE_SYSTEM,
cursor_state: SharedProcessCursorState::default(),
param_text: SharedProcessDialogText::default(),
scrap: PpcScrapState::default(),
list_manager: PpcListManagerState::default(),
halt_pc: PPC_HALT_PC,
import_trap_base: PPC_IMPORT_TRAP_BASE,
import_count: imported_symbols.len() as u32,
imports,
section_bases,
input: PpcInputSnapshot::default(),
process_input: SharedProcessInputState::default(),
event_queue: SharedProcessEventQueue::default(),
window_list: Default::default(),
process_memory_manager,
draw_sprocket: PpcDrawSprocketState::default(),
})
}
fn map_instantiated_sections(data: &[u8]) -> Result<Vec<MappedSection>, PpcLoadError> {
let instantiated = instantiate_pef_sections(data).ok_or(PpcLoadError::SectionInstantiation)?;
let mut mapped = Vec::with_capacity(instantiated.len());
let mut code_cursor = PPC_CODE_BASE;
let mut data_cursor = PPC_DATA_BASE;
for section in instantiated {
let align = alignment_bytes(section.header.alignment)?;
let size = section.bytes.len() as u32;
let base = if section.header.section_kind == SECTION_KIND_CODE {
code_cursor = align_up(code_cursor, align)?;
let base = code_cursor;
code_cursor = code_cursor
.checked_add(size)
.ok_or(PpcLoadError::AddressOverflow)?;
base
} else {
data_cursor = align_up(data_cursor, align)?;
let base = data_cursor;
data_cursor = data_cursor
.checked_add(size)
.ok_or(PpcLoadError::AddressOverflow)?;
base
};
mapped.push(MappedSection {
index: section.index,
section_kind: section.header.section_kind,
base,
bytes: section.bytes,
});
}
Ok(mapped)
}
fn relocation_import_symbol(
imports: &[PpcImportBinding],
symbol_index: u32,
) -> Option<PpcRelocationImportSymbol> {
let import = imports
.iter()
.find(|import| import.symbol_index == symbol_index)?;
Some(PpcRelocationImportSymbol {
symbol_index: import.symbol_index,
library_name: import.library_name.clone(),
symbol_name: import.symbol_name.clone(),
class: import.class,
weak: import.weak,
})
}
fn dispatcher_target_for_import(
library_name: &str,
symbol_name: &str,
) -> PpcImportDispatcherTarget {
match (library_name, symbol_name) {
("InterfaceLib" | "ProcessMgrSupport", "InstallExceptionHandler") => {
PpcImportDispatcherTarget::InstallExceptionHandler
}
(library_name, "Q3Initialize") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Initialize
}
(library_name, "Q3Exit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Exit
}
(library_name, "Q3MemoryStorage_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MemoryStorageNew
}
(library_name, "Q3MemoryStorage_NewBuffer") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MemoryStorageNewBuffer
}
(library_name, "Q3FSSpecStorage_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FSSpecStorageNew
}
(library_name, "Q3File_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FileNew
}
(library_name, "Q3View_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewNew
}
(library_name, "Q3TriMesh_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3TriMeshNew
}
(library_name, "Q3TriMesh_EmptyData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3TriMeshEmptyData
}
(library_name, "Q3AttributeSet_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3AttributeSetNew
}
(library_name, "Q3ViewAngleAspectCamera_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewAngleAspectCameraNew
}
(library_name, "Q3OrthographicCamera_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3OrthographicCameraNew
}
(library_name, "Q3ViewPlaneCamera_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewPlaneCameraNew
}
(library_name, "Q3AmbientLight_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3AmbientLightNew
}
(library_name, "Q3DirectionalLight_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3DirectionalLightNew
}
(library_name, "Q3PointLight_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PointLightNew
}
(library_name, "Q3SpotLight_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightNew
}
(library_name, "Q3LightGroup_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightGroupNew
}
(library_name, "Q3DisplayGroup_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3DisplayGroupNew
}
(library_name, "Q3BackfacingStyle_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3BackfacingStyleNew
}
(library_name, "Q3InterpolationStyle_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3InterpolationStyleNew
}
(library_name, "Q3FillStyle_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FillStyleNew
}
(library_name, "Q3OrientationStyle_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3OrientationStyleNew
}
(library_name, "Q3MipmapTexture_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MipmapTextureNew
}
(library_name, "Q3TextureShader_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3TextureShaderNew
}
(library_name, "Q3LambertIllumination_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LambertIlluminationNew
}
(library_name, "Q3NULLIllumination_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3NullIlluminationNew
}
(library_name, "Q3PhongIllumination_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PhongIlluminationNew
}
(library_name, "Q3PixmapDrawContext_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PixmapDrawContextNew
}
(library_name, "Q3MacDrawContext_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MacDrawContextNew
}
(library_name, "Q3MatrixTransform_New") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MatrixTransformNew
}
(library_name, symbol_name)
if is_quickdraw_3d_library(library_name)
&& symbol_name.starts_with("Q3")
&& symbol_name.ends_with("_New") =>
{
PpcImportDispatcherTarget::Q3NewObject
}
(library_name, "Q3Renderer_NewFromType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3RendererNewFromType
}
(library_name, "Q3Renderer_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3RendererGetType
}
(library_name, "Q3Renderer_Sync") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3RendererSync
}
(library_name, "Q3Renderer_Flush") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3RendererFlush
}
(library_name, "Q3InteractiveRenderer_SetDoubleBufferBypass")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3InteractiveRendererSetDoubleBufferBypass
}
(library_name, "Q3InteractiveRenderer_SetPreferences")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3InteractiveRendererSetPreferences
}
(library_name, "Q3InteractiveRenderer_SetRAVEContextHints")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3InteractiveRendererSetRaveContextHints
}
(library_name, "Q3InteractiveRenderer_GetRAVEContextHints")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3InteractiveRendererGetRaveContextHints
}
(library_name, "Q3InteractiveRenderer_GetRAVEDrawContexts")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3InteractiveRendererGetRaveDrawContexts
}
(library_name, "Q3InteractiveRenderer_SetRAVETextureFilter")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3InteractiveRendererSetRaveTextureFilter
}
(library_name, "Q3Object_Dispose") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ObjectDispose
}
(library_name, "Q3Object_Duplicate") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ObjectDuplicate
}
(library_name, "Q3Shared_GetReference") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SharedGetReference
}
(library_name, "Q3Shared_IsReferenced") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SharedIsReferenced
}
(library_name, "Q3Shared_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SharedGetType
}
(library_name, "Q3Shape_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShapeGetType
}
(library_name, "Q3Shape_GetLeafType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShapeGetLeafType
}
(library_name, "Q3Error_Get") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ErrorGet
}
(library_name, "Q3Object_IsDrawable") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ObjectIsDrawable
}
(library_name, "Q3Object_IsType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ObjectIsType
}
(library_name, "Q3Object_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ObjectGetType
}
(library_name, "Q3Object_GetLeafType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ObjectGetLeafType
}
(library_name, "Q3Light_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightGetType
}
(library_name, "Q3Geometry_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3GeometryGetType
}
(library_name, "Q3Shader_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShaderGetType
}
(library_name, "Q3Group_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3GroupGetType
}
(library_name, "Q3Matrix3x3_SetTranslate") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix3x3SetTranslate
}
(library_name, "Q3Matrix4x4_SetIdentity") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4SetIdentity
}
(library_name, "Q3Matrix4x4_SetTranslate") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4SetTranslate
}
(library_name, "Q3Matrix4x4_SetScale") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4SetScale
}
(library_name, "Q3Matrix4x4_SetRotate_X") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4SetRotateX
}
(library_name, "Q3Matrix4x4_SetRotate_Y") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4SetRotateY
}
(library_name, "Q3Matrix4x4_SetRotate_Z") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4SetRotateZ
}
(library_name, "Q3Matrix4x4_SetRotate_XYZ") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4SetRotateXyz
}
(library_name, "Q3Matrix4x4_Multiply") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4Multiply
}
(library_name, "Q3Matrix4x4_Transpose") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4Transpose
}
(library_name, "Q3Matrix4x4_Invert") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Matrix4x4Invert
}
(library_name, "Q3Point3D_Transform") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Point3DTransform
}
(library_name, "Q3Point3D_To3DTransformArray") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Point3DTo3DTransformArray
}
(library_name, "Q3Point3D_To4DTransformArray") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Point3DTo4DTransformArray
}
(library_name, "Q3Vector3D_Transform") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Vector3DTransform
}
(library_name, "Q3MatrixTransform_Set") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MatrixTransformSet
}
(library_name, "Q3Transform_GetMatrix") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3TransformGetMatrix
}
(library_name, "Q3TextureShader_GetTexture") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3TextureShaderGetTexture
}
(library_name, "Q3MipmapTexture_GetMipmap") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MipmapTextureGetMipmap
}
(library_name, "Q3Storage_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3StorageGetType
}
(library_name, "Q3DrawContext_GetPane") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3DrawContextGetPane
}
(library_name, "Q3MemoryStorage_Set") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MemoryStorageSet
}
(library_name, "Q3MemoryStorage_GetBuffer") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MemoryStorageGetBuffer
}
(library_name, "Q3MemoryStorage_SetBuffer") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MemoryStorageSetBuffer
}
(library_name, "Q3MemoryStorage_GetType") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MemoryStorageGetType
}
(library_name, "Q3Camera_GetPlacement") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3CameraGetPlacement
}
(library_name, "Q3Camera_SetPlacement") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3CameraSetPlacement
}
(library_name, "Q3Camera_GetRange") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3CameraGetRange
}
(library_name, "Q3Camera_SetRange") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3CameraSetRange
}
(library_name, "Q3Camera_GetViewPort") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3CameraGetViewPort
}
(library_name, "Q3Camera_SetViewPort") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3CameraSetViewPort
}
(library_name, "Q3Camera_GetWorldToView") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3CameraGetWorldToView
}
(library_name, "Q3Camera_GetViewToFrustum") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3CameraGetViewToFrustum
}
(library_name, "Q3Light_GetState") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightGetState
}
(library_name, "Q3Light_SetState") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightSetState
}
(library_name, "Q3Light_GetBrightness") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightGetBrightness
}
(library_name, "Q3Light_SetBrightness") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightSetBrightness
}
(library_name, "Q3Light_GetColor") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightGetColor
}
(library_name, "Q3Light_SetColor") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightSetColor
}
(library_name, "Q3Light_GetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightGetData
}
(library_name, "Q3Light_SetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3LightSetData
}
(library_name, "Q3AmbientLight_GetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3AmbientLightGetData
}
(library_name, "Q3AmbientLight_SetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3AmbientLightSetData
}
(library_name, "Q3DirectionalLight_GetCastShadowsState")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3DirectionalLightGetCastShadowsState
}
(library_name, "Q3DirectionalLight_SetCastShadowsState")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3DirectionalLightSetCastShadowsState
}
(library_name, "Q3DirectionalLight_GetDirection")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3DirectionalLightGetDirection
}
(library_name, "Q3DirectionalLight_SetDirection")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3DirectionalLightSetDirection
}
(library_name, "Q3DirectionalLight_GetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3DirectionalLightGetData
}
(library_name, "Q3DirectionalLight_SetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3DirectionalLightSetData
}
(library_name, "Q3PointLight_GetCastShadowsState")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3PointLightGetCastShadowsState
}
(library_name, "Q3PointLight_SetCastShadowsState")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3PointLightSetCastShadowsState
}
(library_name, "Q3PointLight_GetAttenuation") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PointLightGetAttenuation
}
(library_name, "Q3PointLight_SetAttenuation") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PointLightSetAttenuation
}
(library_name, "Q3PointLight_GetLocation") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PointLightGetLocation
}
(library_name, "Q3PointLight_SetLocation") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PointLightSetLocation
}
(library_name, "Q3PointLight_GetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PointLightGetData
}
(library_name, "Q3PointLight_SetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PointLightSetData
}
(library_name, "Q3SpotLight_GetCastShadowsState")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3SpotLightGetCastShadowsState
}
(library_name, "Q3SpotLight_SetCastShadowsState")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3SpotLightSetCastShadowsState
}
(library_name, "Q3SpotLight_GetAttenuation") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightGetAttenuation
}
(library_name, "Q3SpotLight_SetAttenuation") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightSetAttenuation
}
(library_name, "Q3SpotLight_GetLocation") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightGetLocation
}
(library_name, "Q3SpotLight_SetLocation") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightSetLocation
}
(library_name, "Q3SpotLight_GetDirection") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightGetDirection
}
(library_name, "Q3SpotLight_SetDirection") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightSetDirection
}
(library_name, "Q3SpotLight_GetHotAngle") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightGetHotAngle
}
(library_name, "Q3SpotLight_SetHotAngle") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightSetHotAngle
}
(library_name, "Q3SpotLight_GetOuterAngle") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightGetOuterAngle
}
(library_name, "Q3SpotLight_SetOuterAngle") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightSetOuterAngle
}
(library_name, "Q3SpotLight_GetFallOff") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightGetFallOff
}
(library_name, "Q3SpotLight_SetFallOff") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightSetFallOff
}
(library_name, "Q3SpotLight_GetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightGetData
}
(library_name, "Q3SpotLight_SetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3SpotLightSetData
}
(library_name, "Q3Shader_GetUVTransform") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShaderGetUVTransform
}
(library_name, "Q3Shader_SetUVTransform") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShaderSetUVTransform
}
(library_name, "Q3Shader_GetUBoundary") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShaderGetUBoundary
}
(library_name, "Q3Shader_SetUBoundary") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShaderSetUBoundary
}
(library_name, "Q3Shader_GetVBoundary") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShaderGetVBoundary
}
(library_name, "Q3Shader_SetVBoundary") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShaderSetVBoundary
}
(library_name, "Q3BackfacingStyle_Get") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3BackfacingStyleGet
}
(library_name, "Q3BackfacingStyle_Set") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3BackfacingStyleSet
}
(library_name, "Q3InterpolationStyle_Get") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3InterpolationStyleGet
}
(library_name, "Q3InterpolationStyle_Set") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3InterpolationStyleSet
}
(library_name, "Q3FillStyle_Get") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FillStyleGet
}
(library_name, "Q3FillStyle_Set") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FillStyleSet
}
(library_name, "Q3OrientationStyle_Get") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3OrientationStyleGet
}
(library_name, "Q3OrientationStyle_Set") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3OrientationStyleSet
}
(library_name, "Q3TriMesh_GetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3TriMeshGetData
}
(library_name, "Q3TriMesh_SetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3TriMeshSetData
}
(library_name, "Q3AttributeSet_Add") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3AttributeSetAdd
}
(library_name, "Q3AttributeSet_Get") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3AttributeSetGet
}
(library_name, "Q3AttributeSet_Clear") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3AttributeSetClear
}
(library_name, "Q3AttributeSet_Contains") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3AttributeSetContains
}
(library_name, "Q3AttributeSet_GetNextAttributeType")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3AttributeSetGetNextAttributeType
}
(library_name, "Q3Storage_GetSize") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3StorageGetSize
}
(library_name, "Q3Storage_GetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3StorageGetData
}
(library_name, "Q3Storage_SetData") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3StorageSetData
}
(library_name, "Q3Vector3D_Normalize") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Vector3DNormalize
}
(library_name, "Q3Vector2D_Normalize") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Vector2DNormalize
}
(library_name, "Q3Vector3D_Cross") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Vector3DCross
}
(library_name, "Q3Point2D_Distance") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Point2DDistance
}
(library_name, "Q3Point3D_Distance") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Point3DDistance
}
(library_name, "Q3Point3D_CrossProductTri") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3Point3DCrossProductTri
}
(library_name, "Q3File_SetStorage") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FileSetStorage
}
(library_name, "Q3File_OpenRead") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FileOpenRead
}
(library_name, "Q3File_ReadObject") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FileReadObject
}
(library_name, "Q3File_IsEndOfFile") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FileIsEndOfFile
}
(library_name, "Q3File_Close") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FileClose
}
(library_name, "Q3Group_AddObject") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3GroupAddObject
}
(library_name, "Q3Group_AddObjectBefore") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3GroupAddObjectBefore
}
(library_name, "Q3Group_CountObjects") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3GroupCountObjects
}
(library_name, "Q3Group_GetFirstPosition") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3GroupGetFirstPosition
}
(library_name, "Q3Group_GetNextPosition") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3GroupGetNextPosition
}
(library_name, "Q3Group_GetFirstPositionOfType")
if is_quickdraw_3d_library(library_name) =>
{
PpcImportDispatcherTarget::Q3GroupGetFirstPositionOfType
}
(library_name, "Q3Group_GetPositionObject") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3GroupGetPositionObject
}
(library_name, "Q3Group_RemovePosition") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3GroupRemovePosition
}
(library_name, "Q3View_SetRenderer") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewSetRenderer
}
(library_name, "Q3View_GetRenderer") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewGetRenderer
}
(library_name, "Q3View_SetLightGroup") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewSetLightGroup
}
(library_name, "Q3View_GetLightGroup") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewGetLightGroup
}
(library_name, "Q3View_SetDrawContext") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewSetDrawContext
}
(library_name, "Q3View_GetDrawContext") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewGetDrawContext
}
(library_name, "Q3View_SetCamera") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewSetCamera
}
(library_name, "Q3View_GetCamera") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewGetCamera
}
(library_name, "Q3View_StartRendering") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewStartRendering
}
(library_name, "Q3View_EndRendering") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewEndRendering
}
(library_name, "Q3View_StartBoundingBox") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewStartBoundingBox
}
(library_name, "Q3View_EndBoundingBox") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewEndBoundingBox
}
(library_name, "Q3View_Cancel") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ViewCancel
}
(library_name, "Q3Shader_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ShaderSubmit
}
(library_name, "Q3Style_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3StyleSubmit
}
(library_name, "Q3BackfacingStyle_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3BackfacingStyleSubmit
}
(library_name, "Q3InterpolationStyle_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3InterpolationStyleSubmit
}
(library_name, "Q3FillStyle_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FillStyleSubmit
}
(library_name, "Q3OrientationStyle_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3OrientationStyleSubmit
}
(library_name, "Q3FogStyle_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3FogStyleSubmit
}
(library_name, "Q3TriMesh_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3TriMeshSubmit
}
(library_name, "Q3MatrixTransform_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3MatrixTransformSubmit
}
(library_name, "Q3ResetTransform_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ResetTransformSubmit
}
(library_name, "Q3Push_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PushSubmit
}
(library_name, "Q3Pop_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3PopSubmit
}
(library_name, "Q3Object_Submit") if is_quickdraw_3d_library(library_name) => {
PpcImportDispatcherTarget::Q3ObjectSubmit
}
(library_name, symbol_name)
if is_quickdraw_3d_library(library_name)
&& is_quickdraw_3d_status_success_import(symbol_name) =>
{
PpcImportDispatcherTarget::ReturnOne
}
(library_name, "QADeviceGetFirstEngine")
if is_quickdraw_3d_accelerator_library(library_name) =>
{
PpcImportDispatcherTarget::QADeviceGetFirstEngine
}
(library_name, "QADeviceGetNextEngine")
if is_quickdraw_3d_accelerator_library(library_name) =>
{
PpcImportDispatcherTarget::QADeviceGetNextEngine
}
(library_name, "QAEngineGestalt") if is_quickdraw_3d_accelerator_library(library_name) => {
PpcImportDispatcherTarget::QAEngineGestalt
}
("MathLib", "ceil") => PpcImportDispatcherTarget::MathCeil,
("MathLib", "sqrt") => PpcImportDispatcherTarget::MathSqrt,
("MathLib", "exp") => PpcImportDispatcherTarget::MathExp,
("MathLib", "sin") => PpcImportDispatcherTarget::MathSin,
("MathLib", "cos") => PpcImportDispatcherTarget::MathCos,
("MathLib", "asin") => PpcImportDispatcherTarget::MathAsin,
("MathLib", "tan") => PpcImportDispatcherTarget::MathTan,
("MathLib", "atan") => PpcImportDispatcherTarget::MathAtan,
("MathLib", "atan2") => PpcImportDispatcherTarget::MathAtan2,
("MathLib", "pow") => PpcImportDispatcherTarget::MathPow,
("MathLib", "fmod") => PpcImportDispatcherTarget::MathFmod,
("MathLib", "log") => PpcImportDispatcherTarget::MathLog,
("MathLib", "log10") => PpcImportDispatcherTarget::MathLog10,
("MathLib", "dtox80") => PpcImportDispatcherTarget::MathDtox80,
("Math64Lib", "LongDoubleToSInt64") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::LongDoubleToSInt64)
}
("Math64Lib", "LongDoubleToUInt64") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::LongDoubleToUInt64)
}
("Math64Lib", "S32Set") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S32Set)
}
("Math64Lib", "S64Absolute") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Absolute)
}
("Math64Lib", "S64Add") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Add)
}
("Math64Lib", "S64And") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64And)
}
("Math64Lib", "S64BitwiseAnd") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64BitwiseAnd)
}
("Math64Lib", "S64BitwiseEor") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64BitwiseEor)
}
("Math64Lib", "S64BitwiseNot") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64BitwiseNot)
}
("Math64Lib", "S64BitwiseOr") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64BitwiseOr)
}
("Math64Lib", "S64Compare") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Compare)
}
("Math64Lib", "S64Divide") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Divide)
}
("Math64Lib", "S64Eor") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Eor)
}
("Math64Lib", "S64Max") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Max)
}
("Math64Lib", "S64Min") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Min)
}
("Math64Lib", "S64Multiply") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Multiply)
}
("Math64Lib", "S64Negate") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Negate)
}
("Math64Lib", "S64Not") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Not)
}
("Math64Lib", "S64Or") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Or)
}
("Math64Lib", "S64Set") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Set)
}
("Math64Lib", "S64SetU") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64SetU)
}
("Math64Lib", "S64ShiftLeft") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64ShiftLeft)
}
("Math64Lib", "S64ShiftRight") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64ShiftRight)
}
("Math64Lib", "S64Subtract") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::S64Subtract)
}
("Math64Lib", "SInt64ToLongDouble") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::SInt64ToLongDouble)
}
("Math64Lib", "SInt64ToUInt64") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::SInt64ToUInt64)
}
("Math64Lib", "U32SetU") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U32SetU)
}
("Math64Lib", "U64Add") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Add)
}
("Math64Lib", "U64And") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64And)
}
("Math64Lib", "U64BitwiseAnd") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64BitwiseAnd)
}
("Math64Lib", "U64BitwiseEor") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64BitwiseEor)
}
("Math64Lib", "U64BitwiseNot") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64BitwiseNot)
}
("Math64Lib", "U64BitwiseOr") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64BitwiseOr)
}
("Math64Lib", "U64Compare") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Compare)
}
("Math64Lib", "U64Divide") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Divide)
}
("Math64Lib", "U64Eor") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Eor)
}
("Math64Lib", "U64Max") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Max)
}
("Math64Lib", "U64Multiply") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Multiply)
}
("Math64Lib", "U64Not") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Not)
}
("Math64Lib", "U64Or") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Or)
}
("Math64Lib", "U64Set") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Set)
}
("Math64Lib", "U64SetU") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64SetU)
}
("Math64Lib", "U64ShiftLeft") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64ShiftLeft)
}
("Math64Lib", "U64ShiftRight") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64ShiftRight)
}
("Math64Lib", "U64Subtract") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::U64Subtract)
}
("Math64Lib", "UInt64ToLongDouble") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::UInt64ToLongDouble)
}
("Math64Lib", "UInt64ToSInt64") => {
PpcImportDispatcherTarget::Math64(PpcMath64Operation::UInt64ToSInt64)
}
("MathLib", "pi") => PpcImportDispatcherTarget::NoOpPreserve,
// ISO/IEC 9899:1990 §4.6.1.1: setjmp returns zero when invoked
// directly. The supported callers import __setjmp without longjmp,
// so they do not require restoration of the saved environment.
("StdCLib", "__setjmp") => PpcImportDispatcherTarget::ReturnNoErr,
// ISO C atexit registers process-termination cleanup. Classic games
// remain resident until the emulated process is torn down, at which
// point Systemless releases all guest state together.
("StdCLib", "atexit") => PpcImportDispatcherTarget::ReturnNoErr,
("StdCLib", "clock") => PpcImportDispatcherTarget::TickCount,
("StdCLib", "memset") => PpcImportDispatcherTarget::StdMemset,
("StdCLib", "memcmp") => PpcImportDispatcherTarget::StdMemcmp,
("StdCLib", "memcpy") => PpcImportDispatcherTarget::StdMemcpy,
("StdCLib", "memmove") => PpcImportDispatcherTarget::StdMemmove,
("StdCLib", "malloc") => PpcImportDispatcherTarget::StdMalloc,
("StdCLib", "free") => PpcImportDispatcherTarget::StdFree,
("StdCLib", "calloc") => PpcImportDispatcherTarget::StdCalloc,
("StdCLib", "realloc") => PpcImportDispatcherTarget::StdRealloc,
("StdCLib", "strcpy") => PpcImportDispatcherTarget::StdStrcpy,
("StdCLib", "strcat") => PpcImportDispatcherTarget::StdStrcat,
("StdCLib", "strncpy") => PpcImportDispatcherTarget::StdStrncpy,
("StdCLib", "strncat") => PpcImportDispatcherTarget::StdStrncat,
("StdCLib", "strcmp") => PpcImportDispatcherTarget::StdStrcmp,
("StdCLib", "strncmp") => PpcImportDispatcherTarget::StdStrncmp,
("StdCLib", "strlen") => PpcImportDispatcherTarget::StdStrlen,
// Apple Universal Interfaces 3.4 string.h declares these with the
// standard C pointer, int, and size_t signatures for PowerPC CFM.
("StdCLib", "memchr") => PpcImportDispatcherTarget::StdMemchr,
("StdCLib", "strchr") => PpcImportDispatcherTarget::StdStrchr,
("StdCLib", "strrchr") => PpcImportDispatcherTarget::StdStrrchr,
("StdCLib", "strspn") => PpcImportDispatcherTarget::StdStrspn,
("StdCLib", "strcspn") => PpcImportDispatcherTarget::StdStrcspn,
("StdCLib", "strpbrk") => PpcImportDispatcherTarget::StdStrpbrk,
("StdCLib", "strstr") => PpcImportDispatcherTarget::StdStrstr,
("StdCLib", "atoi") => PpcImportDispatcherTarget::StdAtoi,
("StdCLib", "getenv") => PpcImportDispatcherTarget::StdGetenv,
("StdCLib", "sprintf") => PpcImportDispatcherTarget::StdSprintf,
("StdCLib", "clearerr") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::ClearErr)
}
("StdCLib", "_filbuf") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileBuffer)
}
("StdCLib", "fclose") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileClose)
}
("StdCLib", "feof") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileEof)
}
("StdCLib", "ferror") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileError)
}
("StdCLib", "fflush") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileFlush)
}
("StdCLib", "fopen") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileOpen)
}
("StdCLib", "fprintf") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FilePrintf)
}
("StdCLib", "fread") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileRead)
}
("StdCLib", "fseek") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileSeek)
}
("StdCLib", "ftell") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileTell)
}
("StdCLib", "fwrite") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::FileWrite)
}
("StdCLib", "_iob") => {
PpcImportDispatcherTarget::StdIoCompatibility(PpcStdIoOperation::IoBuffer)
}
("StdCLib", "abs") => PpcImportDispatcherTarget::StdAbs,
("StdCLib", "toupper") => PpcImportDispatcherTarget::StdToupper,
("StdCLib", "tolower") => PpcImportDispatcherTarget::StdTolower,
// Universal Interfaces 3.4 ctype.h declares these StdCLib exports.
("StdCLib", "isalnum") => PpcImportDispatcherTarget::StdIsalnum,
("StdCLib", "isalpha") => PpcImportDispatcherTarget::StdIsalpha,
("StdCLib", "isascii") => PpcImportDispatcherTarget::StdIsascii,
("StdCLib", "iscntrl") => PpcImportDispatcherTarget::StdIscntrl,
("StdCLib", "isdigit") => PpcImportDispatcherTarget::StdIsdigit,
("StdCLib", "isgraph") => PpcImportDispatcherTarget::StdIsgraph,
("StdCLib", "islower") => PpcImportDispatcherTarget::StdIslower,
("StdCLib", "isprint") => PpcImportDispatcherTarget::StdIsprint,
("StdCLib", "ispunct") => PpcImportDispatcherTarget::StdIspunct,
("StdCLib", "isspace") => PpcImportDispatcherTarget::StdIsspace,
("StdCLib", "isupper") => PpcImportDispatcherTarget::StdIsupper,
("StdCLib", "isxdigit") => PpcImportDispatcherTarget::StdIsxdigit,
("StdCLib", "toascii") => PpcImportDispatcherTarget::StdToascii,
("StdCLib", "srand") => PpcImportDispatcherTarget::StdSrand,
("StdCLib", "rand") => PpcImportDispatcherTarget::StdRand,
(
"StdCLib",
"_IntEnv" | "__C_phase" | "__p_CType" | "__target_for_exit" | "_exit_status",
) => PpcImportDispatcherTarget::NoOpPreserve,
("StdCLib", "exit") => PpcImportDispatcherTarget::ExitToShell,
("StdCLib", "_BreakPoint") | ("StdCLib", "__NubAt3") => {
PpcImportDispatcherTarget::NoOpPreserve
}
("InterfaceLib", "AEInstallEventHandler") => {
PpcImportDispatcherTarget::AEInstallEventHandler
}
("DrawSprocketLib", "DSpStartup") => PpcImportDispatcherTarget::DSpStartup,
("DrawSprocketLib", "DSpShutdown") => PpcImportDispatcherTarget::DSpShutdown,
("DrawSprocketLib", "DSpGetFirstContext") => PpcImportDispatcherTarget::DSpGetFirstContext,
("DrawSprocketLib", "DSpGetNextContext") => PpcImportDispatcherTarget::DSpGetNextContext,
("DrawSprocketLib", "DSpProcessEvent") => PpcImportDispatcherTarget::DSpProcessEvent,
("DrawSprocketLib", "DSpCanUserSelectContext") => {
PpcImportDispatcherTarget::DSpCanUserSelectContext
}
("DrawSprocketLib", "DSpGetMouse") => PpcImportDispatcherTarget::DSpGetMouse,
("DrawSprocketLib", "DSpFindContextFromPoint") => {
PpcImportDispatcherTarget::DSpFindContextFromPoint
}
("DrawSprocketLib", "DSpContext_GlobalToLocal") => {
PpcImportDispatcherTarget::DSpContextGlobalToLocal
}
("DrawSprocketLib", "DSpFindBestContext") => PpcImportDispatcherTarget::DSpFindBestContext,
("DrawSprocketLib", "DSpUserSelectContext") => {
PpcImportDispatcherTarget::DSpUserSelectContext
}
("DrawSprocketLib", "DSpSetBlankingColor") => {
PpcImportDispatcherTarget::DSpSetBlankingColor
}
("DrawSprocketLib", "DSpAltBuffer_New") => PpcImportDispatcherTarget::DSpAltBufferNew,
("DrawSprocketLib", "DSpAltBuffer_GetCGrafPtr") => {
PpcImportDispatcherTarget::DSpAltBufferGetCGrafPtr
}
("DrawSprocketLib", "DSpContext_Reserve") => PpcImportDispatcherTarget::DSpContextReserve,
("DrawSprocketLib", "DSpContext_Release") => PpcImportDispatcherTarget::DSpContextRelease,
("DrawSprocketLib", "DSpContext_SetState") => PpcImportDispatcherTarget::DSpContextSetState,
("DrawSprocketLib", "DSpContext_FadeGamma") => {
PpcImportDispatcherTarget::DSpContextFadeGamma
}
("DrawSprocketLib", "DSpContext_FadeGammaIn") => {
PpcImportDispatcherTarget::DSpContextFadeGammaIn
}
("DrawSprocketLib", "DSpContext_FadeGammaOut") => {
PpcImportDispatcherTarget::DSpContextFadeGammaOut
}
("DrawSprocketLib", "DSpContext_GetFrontBuffer") => {
PpcImportDispatcherTarget::DSpContextGetFrontBuffer
}
("DrawSprocketLib", "DSpContext_GetBackBuffer") => {
PpcImportDispatcherTarget::DSpContextGetBackBuffer
}
("DrawSprocketLib", "DSpContext_SwapBuffers") => {
PpcImportDispatcherTarget::DSpContextSwapBuffers
}
("DrawSprocketLib", "DSpContext_SetCLUTEntries") => {
PpcImportDispatcherTarget::DSpContextSetClutEntries
}
("DrawSprocketLib", "DSpContext_GetDisplayID") => {
PpcImportDispatcherTarget::DSpContextGetDisplayID
}
("DrawSprocketLib", "DSpContext_GetAttributes") => {
PpcImportDispatcherTarget::DSpContextGetAttributes
}
("DrawSprocketLib", "DSpContext_SetVBLProc") => {
PpcImportDispatcherTarget::DSpContextSetVblProc
}
("DrawSprocketLib", "DSpContext_IsBusy") => {
PpcImportDispatcherTarget::DSpContextIsBusy
}
("DrawSprocketLib", "DSpAltBuffer_Dispose") => {
PpcImportDispatcherTarget::DSpAltBufferDispose
}
("DrawSprocketLib", "DSpContext_InvalBackBufferRect") => {
PpcImportDispatcherTarget::DSpContextInvalBackBufferRect
}
("DrawSprocketLib", "DSpContext_SetUnderlayAltBuffer") => {
PpcImportDispatcherTarget::DSpContextSetUnderlayAltBuffer
}
("InputSprocketLib", "ISpElement_NewVirtualFromNeeds") => {
PpcImportDispatcherTarget::ISpElementNewVirtualFromNeeds
}
("InputSprocketLib", "ISpElementList_New") => PpcImportDispatcherTarget::ISpElementListNew,
("InputSprocketLib", "ISpElementList_AddElements") => {
PpcImportDispatcherTarget::ISpElementListAddElements
}
("InputSprocketLib", "ISpElementList_GetNextEvent") => {
PpcImportDispatcherTarget::ISpElementListGetNextEvent
}
("InputSprocketLib", "ISpElementList_Flush") => {
PpcImportDispatcherTarget::ISpElementListFlush
}
("InputSprocketLib", "ISpDevices_Extract") => PpcImportDispatcherTarget::ISpDevicesExtract,
("InputSprocketLib", "ISpDevices_ExtractByClass") => {
PpcImportDispatcherTarget::ISpDevicesExtractByClass
}
("InputSprocketLib", "ISpDevice_GetDefinition") => {
PpcImportDispatcherTarget::ISpDeviceGetDefinition
}
("InputSprocketLib", "ISpDevice_GetElementList") => {
PpcImportDispatcherTarget::ISpDeviceGetElementList
}
("InputSprocketLib", "ISpElementList_Extract") => {
PpcImportDispatcherTarget::ISpElementListExtract
}
("InputSprocketLib", "ISpElement_GetInfo") => PpcImportDispatcherTarget::ISpElementGetInfo,
("InputSprocketLib", "ISpElement_GetSimpleState") => {
PpcImportDispatcherTarget::ISpElementGetSimpleState
}
("InputSprocketLib", "ISpGetVersion") => PpcImportDispatcherTarget::ISpGetVersion,
("InputSprocketLib", "ISpStartup") => PpcImportDispatcherTarget::ISpStartup,
("InputSprocketLib", "ISpShutdown") => PpcImportDispatcherTarget::ISpShutdown,
("InputSprocketLib", "ISpInit") => PpcImportDispatcherTarget::ISpInit,
("InputSprocketLib", "ISpStop") => PpcImportDispatcherTarget::ISpStop,
("InputSprocketLib", "ISpSuspend") => PpcImportDispatcherTarget::ISpSuspend,
("InputSprocketLib", "ISpResume") => PpcImportDispatcherTarget::ISpResume,
("InputSprocketLib", "ISpDevices_Activate") => {
PpcImportDispatcherTarget::ISpDevicesActivate
}
("InputSprocketLib", "ISpDevices_Deactivate") => {
PpcImportDispatcherTarget::ISpDevicesDeactivate
}
("InputSprocketLib", "ISpConfigure") => PpcImportDispatcherTarget::ISpConfigure,
("3DfxGlideLib2.x", "grSstQueryBoards") => PpcImportDispatcherTarget::GlideSstQueryBoards,
("InterfaceLib", "NewPtr") | ("InterfaceLib", "NewPtrSys") => {
PpcImportDispatcherTarget::NewPtr { clear: false }
}
("InterfaceLib", "NewPtrClear") | ("InterfaceLib", "NewPtrSysClear") => {
PpcImportDispatcherTarget::NewPtr { clear: true }
}
("InterfaceLib", "DisposePtr") => PpcImportDispatcherTarget::DisposePtr,
("InterfaceLib", "GetPtrSize") => PpcImportDispatcherTarget::GetPtrSize,
("InterfaceLib", "SetPtrSize") => PpcImportDispatcherTarget::SetPtrSize,
("InterfaceLib", "RecoverHandle") => PpcImportDispatcherTarget::RecoverHandle,
("InterfaceLib", "NewHandle") => PpcImportDispatcherTarget::NewHandle { clear: false },
("InterfaceLib", "NewHandleClear") => PpcImportDispatcherTarget::NewHandle { clear: true },
("InterfaceLib", "TempNewHandle") => PpcImportDispatcherTarget::TempNewHandle,
("InterfaceLib", "DisposeHandle") => PpcImportDispatcherTarget::DisposeHandle,
("InterfaceLib", "EmptyHandle") => PpcImportDispatcherTarget::EmptyHandle,
("InterfaceLib", "BlockMove") | ("InterfaceLib", "BlockMoveData") => {
PpcImportDispatcherTarget::BlockMove
}
("InterfaceLib", "PtrToHand") => PpcImportDispatcherTarget::PtrToHand,
("InterfaceLib", "HandToHand") => PpcImportDispatcherTarget::HandToHand,
("InterfaceLib", "HandAndHand") => PpcImportDispatcherTarget::HandAndHand,
("InterfaceLib", "GetHandleSize") => PpcImportDispatcherTarget::GetHandleSize,
("InterfaceLib", "SetHandleSize") => PpcImportDispatcherTarget::SetHandleSize,
("InterfaceLib", "HLock") => PpcImportDispatcherTarget::HLock,
("InterfaceLib", "HLockHi") => PpcImportDispatcherTarget::HLockHi,
("InterfaceLib", "HGetState") => PpcImportDispatcherTarget::HGetState,
("InterfaceLib", "HSetState") => PpcImportDispatcherTarget::HSetState,
("InterfaceLib", "HUnlock") => PpcImportDispatcherTarget::HUnlock,
("InterfaceLib", "MoveHHi") => PpcImportDispatcherTarget::MoveHHi,
("InterfaceLib", "HNoPurge") => PpcImportDispatcherTarget::HNoPurge,
("InterfaceLib", "HPurge") => PpcImportDispatcherTarget::HPurge,
("InterfaceLib", "TickCount") => PpcImportDispatcherTarget::TickCount,
("InterfaceLib", "GetZone") => PpcImportDispatcherTarget::GetZone,
("InterfaceLib", "SetZone") => PpcImportDispatcherTarget::SetZone,
("InterfaceLib", "InitZone") => PpcImportDispatcherTarget::InitZone,
("InterfaceLib", "SystemZone") => PpcImportDispatcherTarget::SystemZone,
("InterfaceLib", "ApplicZone") | ("InterfaceLib", "ApplicationZone") => {
PpcImportDispatcherTarget::ApplicationZone
}
("InterfaceLib", "MaxApplZone") => PpcImportDispatcherTarget::MaxApplZone,
("InterfaceLib", "MoreMasters") => PpcImportDispatcherTarget::MoreMasters,
("InterfaceLib", "GetApplLimit") => PpcImportDispatcherTarget::GetApplLimit,
("InterfaceLib", "SetApplLimit") => PpcImportDispatcherTarget::SetApplLimit,
("InterfaceLib", "CompactMem")
| ("InterfaceLib", "CompactMemSys")
| ("InterfaceLib", "FreeMem")
| ("InterfaceLib", "FreeMemSys") => PpcImportDispatcherTarget::HeapFreeBytes,
("InterfaceLib", "MaxMem") => PpcImportDispatcherTarget::MaxMem,
("InterfaceLib", "MemError") => PpcImportDispatcherTarget::MemError,
("InterfaceLib", "CurResFile") => PpcImportDispatcherTarget::CurResFile,
("InterfaceLib", "UseResFile") => PpcImportDispatcherTarget::UseResFile,
("InterfaceLib", "CloseResFile") => PpcImportDispatcherTarget::CloseResFile,
("InterfaceLib", "OpenResFile") => PpcImportDispatcherTarget::OpenResFile,
("InterfaceLib", "HOpenResFile") => PpcImportDispatcherTarget::HOpenResFile,
("InterfaceLib", "ResError") => PpcImportDispatcherTarget::ResError,
("InterfaceLib", "SetResLoad") => PpcImportDispatcherTarget::SetResLoad,
("InterfaceLib", "LoadResource") => PpcImportDispatcherTarget::LoadResource,
("InterfaceLib", "GetIndString") | ("InterfaceLib", "getindstring") => {
PpcImportDispatcherTarget::GetIndString
}
("InterfaceLib", "GetString") => PpcImportDispatcherTarget::GetString,
("InterfaceLib", "GetResource") => PpcImportDispatcherTarget::GetResource,
("InterfaceLib", "Get1Resource") => PpcImportDispatcherTarget::Get1Resource,
("InterfaceLib", "GetNamedResource") => PpcImportDispatcherTarget::GetNamedResource,
("InterfaceLib", "Get1NamedResource") => PpcImportDispatcherTarget::Get1NamedResource,
("InterfaceLib", "GetIndResource") => PpcImportDispatcherTarget::GetIndResource,
("InterfaceLib", "Get1IndResource") => PpcImportDispatcherTarget::Get1IndResource,
("InterfaceLib", "GetResAttrs") => PpcImportDispatcherTarget::GetResAttrs,
("InterfaceLib", "SetResAttrs") => PpcImportDispatcherTarget::SetResAttrs,
("InterfaceLib", "GetResInfo") => PpcImportDispatcherTarget::GetResInfo,
("InterfaceLib", "GetResourceSizeOnDisk")
| ("InterfaceLib", "GetMaxResourceSize")
| ("InterfaceLib", "MaxSizeRsrc")
| ("InterfaceLib", "SizeResource") => PpcImportDispatcherTarget::GetResourceSizeOnDisk,
("InterfaceLib", "SetResInfo") => PpcImportDispatcherTarget::SetResInfo,
("InterfaceLib", "HomeResFile") => PpcImportDispatcherTarget::HomeResFile,
("InterfaceLib", "CountResources") => PpcImportDispatcherTarget::CountResources,
("InterfaceLib", "Count1Resources") => PpcImportDispatcherTarget::Count1Resources,
("InterfaceLib", "UniqueID") => PpcImportDispatcherTarget::UniqueID,
("InterfaceLib", "Unique1ID") => PpcImportDispatcherTarget::Unique1ID,
("InterfaceLib", "UpdateResFile") => PpcImportDispatcherTarget::UpdateResFile,
("InterfaceLib", "AddResource") => PpcImportDispatcherTarget::AddResource,
("InterfaceLib", "ChangedResource") => PpcImportDispatcherTarget::ChangedResource,
("InterfaceLib", "WriteResource") => PpcImportDispatcherTarget::WriteResource,
("InterfaceLib", "RemoveResource") => PpcImportDispatcherTarget::RemoveResource,
("InterfaceLib", "GetPicture") => PpcImportDispatcherTarget::GetPicture,
("InterfaceLib", "GetIndPattern") => PpcImportDispatcherTarget::GetIndPattern,
("InterfaceLib", "GetPixPat") => PpcImportDispatcherTarget::GetPixPat,
("InterfaceLib", "GetPictInfo") => PpcImportDispatcherTarget::GetPictInfo,
("InterfaceLib", "DrawPicture") => PpcImportDispatcherTarget::DrawPicture,
("InterfaceLib", "KillPicture") => PpcImportDispatcherTarget::KillPicture,
("InterfaceLib", "Gestalt") => PpcImportDispatcherTarget::Gestalt,
// Universal Interfaces exposes Code Fragment Manager entry points
// through several compatibility libraries across classic and Carbon
// runtimes. Treat the library name as an export namespace alias; the
// calling convention and API contract are identical.
(
"InterfaceLib" | "CodeFragmentMgr" | "CarbonCore.vlib" | "CFMPriv_CarbonCore",
"GetSharedLibrary",
) => PpcImportDispatcherTarget::GetSharedLibrary,
(
"InterfaceLib" | "CodeFragmentMgr" | "CarbonCore.vlib" | "CFMPriv_CarbonCore",
"FindSymbol",
) => PpcImportDispatcherTarget::FindSymbol,
(
"InterfaceLib" | "CodeFragmentMgr" | "CarbonCore.vlib" | "CFMPriv_CarbonCore",
"CountSymbols",
) => PpcImportDispatcherTarget::CountSymbols,
(
"InterfaceLib" | "CodeFragmentMgr" | "CarbonCore.vlib" | "CFMPriv_CarbonCore",
"GetIndSymbol",
) => PpcImportDispatcherTarget::GetIndSymbol,
(
"InterfaceLib" | "CodeFragmentMgr" | "CarbonCore.vlib" | "CFMPriv_CarbonCore",
"CloseConnection",
) => PpcImportDispatcherTarget::CloseConnection,
("InterfaceLib", "GetMemFragment") => PpcImportDispatcherTarget::GetMemFragment,
("InterfaceLib", "InitCursor") => PpcImportDispatcherTarget::InitCursor,
("InterfaceLib", "HideCursor") => PpcImportDispatcherTarget::HideCursor,
("InterfaceLib", "ShowCursor") => PpcImportDispatcherTarget::ShowCursor,
("InterfaceLib", "ShieldCursor") => PpcImportDispatcherTarget::ShieldCursor,
("InterfaceLib", "CrsrDevNextDevice") => PpcImportDispatcherTarget::CrsrDevNextDevice,
("InterfaceLib", "CrsrDevMoveTo") => PpcImportDispatcherTarget::CrsrDevMoveTo,
("InterfaceLib", "GetCursor") => PpcImportDispatcherTarget::GetCursor,
("InterfaceLib", "SetCursor") => PpcImportDispatcherTarget::SetCursor,
("InterfaceLib", "GetCCursor") => PpcImportDispatcherTarget::GetCCursor,
("InterfaceLib", "GetCIcon") => PpcImportDispatcherTarget::GetCIcon,
("InterfaceLib", "PlotCIcon") => PpcImportDispatcherTarget::PlotCIcon,
("InterfaceLib", "DisposeCIcon") => PpcImportDispatcherTarget::DisposeCIcon,
("InterfaceLib", "SetCCursor") => PpcImportDispatcherTarget::SetCCursor,
("InterfaceLib", "DisposeCCursor") => PpcImportDispatcherTarget::DisposeCCursor,
("InterfaceLib", "SysBeep") => PpcImportDispatcherTarget::SysBeep,
("InterfaceLib", "GetForeColor") => PpcImportDispatcherTarget::GetForeColor,
("InterfaceLib", "GetBackColor") => PpcImportDispatcherTarget::GetBackColor,
("InterfaceLib", "ForeColor") => PpcImportDispatcherTarget::ForeColor,
("InterfaceLib", "BackColor") => PpcImportDispatcherTarget::BackColor,
("InterfaceLib", "RGBForeColor") => PpcImportDispatcherTarget::RGBForeColor,
("InterfaceLib", "RGBBackColor") => PpcImportDispatcherTarget::RGBBackColor,
("InterfaceLib", "OpColor") => PpcImportDispatcherTarget::OpColor,
("InterfaceLib", "HiliteColor") => PpcImportDispatcherTarget::HiliteColor,
("InterfaceLib", "PmForeColor") => PpcImportDispatcherTarget::PmForeColor,
("InterfaceLib", "PmBackColor") => PpcImportDispatcherTarget::PmBackColor,
("InterfaceLib", "Color2Index") => PpcImportDispatcherTarget::Color2Index,
("InterfaceLib", "Index2Color") => PpcImportDispatcherTarget::Index2Color,
("InterfaceLib", "RGB2HSL") => PpcImportDispatcherTarget::RGB2HSL,
("InterfaceLib", "RGB2HSV") => PpcImportDispatcherTarget::RGB2HSV,
("InterfaceLib", "HSV2RGB") => PpcImportDispatcherTarget::HSV2RGB,
("InterfaceLib", "FixRatio") => PpcImportDispatcherTarget::FixRatio,
("InterfaceLib", "FixMul") => PpcImportDispatcherTarget::FixMul,
("InterfaceLib", "FixDiv") => PpcImportDispatcherTarget::FixDiv,
("InterfaceLib", "Long2Fix") => PpcImportDispatcherTarget::Long2Fix,
("InterfaceLib", "Fix2Long") => PpcImportDispatcherTarget::Fix2Long,
("InterfaceLib", "FixRound") => PpcImportDispatcherTarget::FixRound,
("InterfaceLib", "Fix2Frac") => PpcImportDispatcherTarget::Fix2Frac,
("InterfaceLib", "Frac2Fix") => PpcImportDispatcherTarget::Frac2Fix,
("InterfaceLib", "Frac2X") => PpcImportDispatcherTarget::Frac2X,
("InterfaceLib", "X2Frac") => PpcImportDispatcherTarget::X2Frac,
("InterfaceLib", "FracSin") => PpcImportDispatcherTarget::FracSin,
("InterfaceLib", "FracCos") => PpcImportDispatcherTarget::FracCos,
("InterfaceLib", "FracSqrt") => PpcImportDispatcherTarget::FracSqrt,
("InterfaceLib", "FracMul") => PpcImportDispatcherTarget::FracMul,
("InterfaceLib", "FracDiv") => PpcImportDispatcherTarget::FracDiv,
("InterfaceLib", "FixATan2") => PpcImportDispatcherTarget::FixATan2,
("InterfaceLib", "WideAdd") => PpcImportDispatcherTarget::WideAdd,
("InterfaceLib", "WideSubtract") => PpcImportDispatcherTarget::WideSubtract,
("InterfaceLib", "WideNegate") => PpcImportDispatcherTarget::WideNegate,
("InterfaceLib", "WideShift") => PpcImportDispatcherTarget::WideShift,
("InterfaceLib", "WideMultiply") => PpcImportDispatcherTarget::WideMultiply,
("InterfaceLib", "WideDivide") => PpcImportDispatcherTarget::WideDivide,
("InterfaceLib", "WideWideDivide") => PpcImportDispatcherTarget::WideWideDivide,
("InterfaceLib", "WideSquareRoot") => PpcImportDispatcherTarget::WideSquareRoot,
("InterfaceLib", "WideCompare") => PpcImportDispatcherTarget::WideCompare,
("InterfaceLib", "NewMenu") => PpcImportDispatcherTarget::NewMenu,
("InterfaceLib", "DisposeMenu") => PpcImportDispatcherTarget::DisposeMenu,
("InterfaceLib", "GetMenu") => PpcImportDispatcherTarget::GetMenu,
("InterfaceLib", "GetItemCmd") => PpcImportDispatcherTarget::GetItemCmd,
("InterfaceLib", "SetItemCmd") => PpcImportDispatcherTarget::SetItemCmd,
("InterfaceLib", "GetItemMark") => PpcImportDispatcherTarget::GetItemMark,
("InterfaceLib", "CountMItems") => PpcImportDispatcherTarget::CountMItems,
("InterfaceLib", "GetMenuItemText") => PpcImportDispatcherTarget::GetMenuItemText,
("InterfaceLib", "SetMenuItemText") | ("InterfaceLib", "SetItem") => {
PpcImportDispatcherTarget::SetMenuItemText
}
("InterfaceLib", "DeleteMenuItem") | ("InterfaceLib", "DelMenuItem") => {
PpcImportDispatcherTarget::DeleteMenuItem
}
("InterfaceLib", "CalcMenuSize") => PpcImportDispatcherTarget::CalcMenuSize,
("InterfaceLib", "PopUpMenuSelect") => PpcImportDispatcherTarget::PopUpMenuSelect,
("InterfaceLib", "InsertMenu") => PpcImportDispatcherTarget::InsertMenu,
("InterfaceLib", "DeleteMenu") => PpcImportDispatcherTarget::DeleteMenu,
("InterfaceLib", "AppendMenu") => PpcImportDispatcherTarget::AppendMenu,
("InterfaceLib", "InsertMenuItem") | ("InterfaceLib", "InsMenuItem") => {
PpcImportDispatcherTarget::InsertMenuItem
}
("InterfaceLib", "AppendResMenu") | ("InterfaceLib", "AddResMenu") => {
PpcImportDispatcherTarget::AppendResMenu
}
("InterfaceLib", "InsertResMenu") => PpcImportDispatcherTarget::InsertResMenu,
("InterfaceLib", "EnableItem") => PpcImportDispatcherTarget::EnableMenuItem,
("InterfaceLib", "DisableItem") => PpcImportDispatcherTarget::DisableMenuItem,
("InterfaceLib", "SetItemMark") => PpcImportDispatcherTarget::SetItemMark,
("InterfaceLib", "CheckItem") => PpcImportDispatcherTarget::CheckItem,
("InterfaceLib", "GetMenuBar") => PpcImportDispatcherTarget::GetMenuBar,
("InterfaceLib", "GetNewMBar") => PpcImportDispatcherTarget::GetNewMBar,
("InterfaceLib", "LMGetMenuList") => PpcImportDispatcherTarget::LMGetMenuList,
("InterfaceLib", "LMGetMenuFlash") => PpcImportDispatcherTarget::LMGetMenuFlash,
("InterfaceLib", "LMGetPaintWhite") => PpcImportDispatcherTarget::LMGetPaintWhite,
("InterfaceLib", "LMGetSysMap") => PpcImportDispatcherTarget::LMGetSysMap,
("InterfaceLib", "LMSetPaintWhite") => PpcImportDispatcherTarget::LMSetPaintWhite,
("InterfaceLib", "LMSetResumeProc") => PpcImportDispatcherTarget::LMSetResumeProc,
("InterfaceLib", "LMSetACount") => PpcImportDispatcherTarget::LMSetACount,
("InterfaceLib", "LMSetANumber") => PpcImportDispatcherTarget::LMSetANumber,
("InterfaceLib", "LMSetDlgFont") => PpcImportDispatcherTarget::LMSetDlgFont,
("InterfaceLib", "LMSetMenuFlash") | ("InterfaceLib", "SetMenuFlash") => {
PpcImportDispatcherTarget::SetMenuFlash
}
("InterfaceLib", "ErrorSound") => PpcImportDispatcherTarget::NoOpPreserve,
("InterfaceLib", "ClearMenuBar") => PpcImportDispatcherTarget::ClearMenuBar,
("InterfaceLib", "SetMenuBar") => PpcImportDispatcherTarget::SetMenuBar,
("InterfaceLib", "GetMenuHandle") => PpcImportDispatcherTarget::GetMenuHandle,
("InterfaceLib", "DrawMenuBar") => PpcImportDispatcherTarget::DrawMenuBar,
("InterfaceLib", "FlashMenuBar") => PpcImportDispatcherTarget::FlashMenuBar,
("InterfaceLib", "HMGetHelpMenuHandle") => PpcImportDispatcherTarget::HMGetHelpMenuHandle,
("InterfaceLib", "HiliteMenu") => PpcImportDispatcherTarget::HiliteMenu,
("InterfaceLib", "InvalMenuBar") => PpcImportDispatcherTarget::InvalMenuBar,
("InterfaceLib", "DrawGrowIcon") => PpcImportDispatcherTarget::DrawGrowIcon,
("InterfaceLib", "OpenCPicture") | ("InterfaceLib", "DebugStr") => {
PpcImportDispatcherTarget::MenuNoop
}
("InterfaceLib", "LocalToGlobal") => PpcImportDispatcherTarget::LocalToGlobal,
("InterfaceLib", "GlobalToLocal") => PpcImportDispatcherTarget::GlobalToLocal,
("InterfaceLib", "AddPt") => PpcImportDispatcherTarget::AddPt,
("InterfaceLib", "SubPt") => PpcImportDispatcherTarget::SubPt,
("InterfaceLib", "MenuKey") => PpcImportDispatcherTarget::MenuKey,
("AppearanceLib" | "InterfaceLib", "MenuEvent") => PpcImportDispatcherTarget::MenuEvent,
("InterfaceLib", "MenuChoice") => PpcImportDispatcherTarget::MenuChoice,
("InterfaceLib", "MenuSelect") => PpcImportDispatcherTarget::MenuSelect,
("InterfaceLib", "MoveTo") => PpcImportDispatcherTarget::MoveTo,
("InterfaceLib", "Move") => PpcImportDispatcherTarget::Move,
("InterfaceLib", "LineTo") => PpcImportDispatcherTarget::LineTo,
("InterfaceLib", "Line") => PpcImportDispatcherTarget::Line,
("InterfaceLib", "DrawChar") => PpcImportDispatcherTarget::DrawChar,
("InterfaceLib", "DrawText") => PpcImportDispatcherTarget::DrawText,
("InterfaceLib", "DrawString") => PpcImportDispatcherTarget::DrawString,
("InterfaceLib", "TextFont") => PpcImportDispatcherTarget::TextFont,
("InterfaceLib", "TextFace") => PpcImportDispatcherTarget::TextFace,
("InterfaceLib", "TextMode") => PpcImportDispatcherTarget::TextMode,
("InterfaceLib", "TextSize") => PpcImportDispatcherTarget::TextSize,
("InterfaceLib", "PaintRect") => PpcImportDispatcherTarget::PaintRect,
("InterfaceLib", "EraseRect") => PpcImportDispatcherTarget::EraseRect,
("InterfaceLib", "InvertRect") => PpcImportDispatcherTarget::InvertRect,
("InterfaceLib", "FrameRect") => PpcImportDispatcherTarget::FrameRect,
("InterfaceLib", "FillRect") => PpcImportDispatcherTarget::FillRect,
("InterfaceLib", "FrameOval") => PpcImportDispatcherTarget::FrameOval,
("InterfaceLib", "PaintOval") => PpcImportDispatcherTarget::PaintOval,
("InterfaceLib", "EraseOval") => PpcImportDispatcherTarget::EraseOval,
("InterfaceLib", "PaintArc") => PpcImportDispatcherTarget::PaintArc,
("InterfaceLib", "FrameRgn") => PpcImportDispatcherTarget::FrameRgn,
("InterfaceLib", "PaintRgn") => PpcImportDispatcherTarget::PaintRgn,
("InterfaceLib", "FillRgn") => PpcImportDispatcherTarget::FillRgn,
("InterfaceLib", "InvertRgn") => PpcImportDispatcherTarget::InvertRgn,
("InterfaceLib", "FillCRect") => PpcImportDispatcherTarget::FillCRect,
("InterfaceLib", "FrameRoundRect") => PpcImportDispatcherTarget::FrameRoundRect,
("InterfaceLib", "PaintRoundRect") => PpcImportDispatcherTarget::PaintRoundRect,
("InterfaceLib", "InvalRect") => PpcImportDispatcherTarget::InvalRect,
("InterfaceLib", "ValidRect") => PpcImportDispatcherTarget::ValidRect,
("InterfaceLib", "BeginUpdate") => PpcImportDispatcherTarget::BeginUpdate,
("InterfaceLib", "EndUpdate") => PpcImportDispatcherTarget::EndUpdate,
("InterfaceLib", "ClipRect") => PpcImportDispatcherTarget::ClipRect,
("InterfaceLib", "GetClip") => PpcImportDispatcherTarget::GetClip,
("InterfaceLib", "SetClip") => PpcImportDispatcherTarget::SetClip,
("InterfaceLib", "GetPen") => PpcImportDispatcherTarget::GetPen,
("InterfaceLib", "HidePen") => PpcImportDispatcherTarget::HidePen,
("InterfaceLib", "ShowPen") => PpcImportDispatcherTarget::ShowPen,
("InterfaceLib", "PenSize") => PpcImportDispatcherTarget::PenSize,
("InterfaceLib", "PenMode") => PpcImportDispatcherTarget::PenMode,
("InterfaceLib", "PenNormal") => PpcImportDispatcherTarget::PenNormal,
("InterfaceLib", "PenPixPat") => PpcImportDispatcherTarget::PenPixPat,
("InterfaceLib", "GetPenState") => PpcImportDispatcherTarget::GetPenState,
("InterfaceLib", "SetPenState") => PpcImportDispatcherTarget::SetPenState,
("InterfaceLib", "CopyBits") => PpcImportDispatcherTarget::CopyBits,
("InterfaceLib", "BitMapToRegion") => PpcImportDispatcherTarget::BitMapToRegion,
("InterfaceLib", "NewRgn") => PpcImportDispatcherTarget::NewRgn,
("InterfaceLib", "DisposeRgn") => PpcImportDispatcherTarget::DisposeRgn,
("InterfaceLib", "CopyRgn") => PpcImportDispatcherTarget::CopyRgn,
("InterfaceLib", "OpenRgn") => PpcImportDispatcherTarget::OpenRgn,
("InterfaceLib", "CloseRgn") => PpcImportDispatcherTarget::CloseRgn,
("InterfaceLib", "SectRgn") => PpcImportDispatcherTarget::SectRgn,
("InterfaceLib", "UnionRgn") => PpcImportDispatcherTarget::UnionRgn,
("InterfaceLib", "DiffRgn") => PpcImportDispatcherTarget::DiffRgn,
("InterfaceLib", "XorRgn") => PpcImportDispatcherTarget::XorRgn,
("InterfaceLib", "SetEmptyRgn") => PpcImportDispatcherTarget::SetEmptyRgn,
("InterfaceLib", "SetRectRgn") => PpcImportDispatcherTarget::SetRectRgn,
("InterfaceLib", "RectRgn") => PpcImportDispatcherTarget::RectRgn,
("InterfaceLib", "OffsetRgn") => PpcImportDispatcherTarget::OffsetRgn,
("InterfaceLib", "EmptyRgn") => PpcImportDispatcherTarget::EmptyRgn,
("InterfaceLib", "PtInRgn") => PpcImportDispatcherTarget::PtInRgn,
("InterfaceLib", "RectInRgn") => PpcImportDispatcherTarget::RectInRgn,
("InterfaceLib", "OpenPoly") => PpcImportDispatcherTarget::OpenPoly,
("InterfaceLib", "ClosePoly") => PpcImportDispatcherTarget::ClosePoly,
("InterfaceLib", "KillPoly") => PpcImportDispatcherTarget::KillPoly,
("InterfaceLib", "PaintPoly") => PpcImportDispatcherTarget::PaintPoly,
("InterfaceLib", "FramePoly") => PpcImportDispatcherTarget::FramePoly,
("InterfaceLib", "FillPoly") => PpcImportDispatcherTarget::FillPoly,
("InterfaceLib", "NewCWindow") => PpcImportDispatcherTarget::NewCWindow,
("InterfaceLib", "GetNewCWindow") => PpcImportDispatcherTarget::GetNewCWindow,
("InterfaceLib", "GetWRefCon") => PpcImportDispatcherTarget::GetWRefCon,
("InterfaceLib", "SetWRefCon") => PpcImportDispatcherTarget::SetWRefCon,
("InterfaceLib", "SizeWindow") => PpcImportDispatcherTarget::SizeWindow,
("InterfaceLib", "MoveWindow") => PpcImportDispatcherTarget::MoveWindow,
("InterfaceLib", "ShowWindow") => PpcImportDispatcherTarget::ShowWindow,
("InterfaceLib", "HideWindow") => PpcImportDispatcherTarget::HideWindow,
("InterfaceLib", "ShowHide") => PpcImportDispatcherTarget::ShowHide,
("InterfaceLib", "CloseWindow") => PpcImportDispatcherTarget::CloseWindow,
("InterfaceLib", "SelectWindow") => PpcImportDispatcherTarget::SelectWindow,
("InterfaceLib", "FrontWindow") => PpcImportDispatcherTarget::FrontWindow,
("InterfaceLib", "SetWinColor") => PpcImportDispatcherTarget::SetWinColor,
("InterfaceLib", "PaintOne") => PpcImportDispatcherTarget::PaintOne,
("InterfaceLib", "PaintBehind") => PpcImportDispatcherTarget::PaintBehind,
("InterfaceLib", "CalcVisBehind") => PpcImportDispatcherTarget::CalcVisBehind,
("InterfaceLib", "GetMouse") => PpcImportDispatcherTarget::GetMouse,
("InterfaceLib", "ActivatePalette") => PpcImportDispatcherTarget::ActivatePalette,
("InterfaceLib", "SetPalette") | ("InterfaceLib", "NSetPalette") => {
PpcImportDispatcherTarget::NSetPalette
}
("InterfaceLib", "GetPalette") => PpcImportDispatcherTarget::GetPalette,
("InterfaceLib", "GetPort") => PpcImportDispatcherTarget::GetPort,
("InterfaceLib", "GetWMgrPort") | ("InterfaceLib", "GetCWMgrPort") => {
PpcImportDispatcherTarget::GetWMgrPort
}
("InterfaceLib", "SetPort") => PpcImportDispatcherTarget::SetPort,
("InterfaceLib", "GetGDevice") => PpcImportDispatcherTarget::GetGDevice,
("InterfaceLib", "SetGDevice") => PpcImportDispatcherTarget::SetGDevice,
("InterfaceLib", "GetDeviceList") => PpcImportDispatcherTarget::GetDeviceList,
("InterfaceLib", "GetNextDevice") => PpcImportDispatcherTarget::GetNextDevice,
("InterfaceLib", "GetMainDevice") => PpcImportDispatcherTarget::GetMainDevice,
("InterfaceLib", "GetMaxDevice") => PpcImportDispatcherTarget::GetMaxDevice,
("InterfaceLib", "GetSysFont") => PpcImportDispatcherTarget::GetSysFont,
("InterfaceLib", "GetAppFont") => PpcImportDispatcherTarget::GetAppFont,
("InterfaceLib", "GetDefFontSize") => PpcImportDispatcherTarget::GetDefFontSize,
("InterfaceLib", "GetFontName") => PpcImportDispatcherTarget::GetFontName,
("InterfaceLib", "GetMBarHeight") | ("InterfaceLib", "LMGetMBarHeight") => {
PpcImportDispatcherTarget::GetMBarHeight
}
("InterfaceLib", "LMSetMBarHeight") => PpcImportDispatcherTarget::SetMBarHeight,
("InterfaceLib", "TestDeviceAttribute") => PpcImportDispatcherTarget::TestDeviceAttribute,
("InterfaceLib", "SetDeviceAttribute") => PpcImportDispatcherTarget::SetDeviceAttribute,
("InterfaceLib", "HasDepth") => PpcImportDispatcherTarget::HasDepth,
("InterfaceLib", "SetDepth") => PpcImportDispatcherTarget::SetDepth,
("InterfaceLib", "DMGetDisplayIDByGDevice") => {
PpcImportDispatcherTarget::DMGetDisplayIDByGDevice
}
("InterfaceLib", "DMGetGDeviceByDisplayID") => {
PpcImportDispatcherTarget::DMGetGDeviceByDisplayID
}
("InterfaceLib" | "DisplayLib", "DMGetFirstScreenDevice") => {
PpcImportDispatcherTarget::DMGetFirstScreenDevice
}
("InterfaceLib" | "DisplayLib", "DMGetNextScreenDevice") => {
PpcImportDispatcherTarget::DMGetNextScreenDevice
}
("InterfaceLib" | "DisplayLib", "DMGetDisplayMode") => {
PpcImportDispatcherTarget::DMGetDisplayMode
}
("InterfaceLib" | "DisplayLib", "DMCheckDisplayMode") => {
PpcImportDispatcherTarget::DMCheckDisplayMode
}
("InterfaceLib" | "DisplayLib", "DMSetDisplayMode") => {
PpcImportDispatcherTarget::DMSetDisplayMode
}
("InterfaceLib" | "DisplayLib", "DMNewDisplayModeList") => {
PpcImportDispatcherTarget::DMNewDisplayModeList
}
("InterfaceLib" | "DisplayLib", "DMGetIndexedDisplayModeFromList") => {
PpcImportDispatcherTarget::DMGetIndexedDisplayModeFromList
}
("InterfaceLib" | "DisplayLib", "DMDisposeList") => {
PpcImportDispatcherTarget::DMDisposeList
}
("InterfaceLib" | "DisplayLib", "DMBeginConfigureDisplays") => {
PpcImportDispatcherTarget::DMBeginConfigureDisplays
}
("InterfaceLib" | "DisplayLib", "DMEndConfigureDisplays") => {
PpcImportDispatcherTarget::DMEndConfigureDisplays
}
// Universal Interfaces 3.4.1 Displays.h: these configuration-session
// controls return OSErr and do not select a display mode themselves.
("InterfaceLib" | "DisplayLib", "DMResumeConfigure")
| ("InterfaceLib" | "DisplayLib", "DMSuspendConfigure")
| ("InterfaceLib" | "DisplayLib", "DMUseScreenPrefs") => {
PpcImportDispatcherTarget::ReturnNoErr
}
("InterfaceLib", "NewGWorld") => PpcImportDispatcherTarget::NewGWorld,
("InterfaceLib", "UpdateGWorld") => PpcImportDispatcherTarget::UpdateGWorld,
("InterfaceLib", "DisposeGWorld") => PpcImportDispatcherTarget::DisposeGWorld,
("InterfaceLib", "GetCTable") => PpcImportDispatcherTarget::GetCTable,
("InterfaceLib", "GetCTSeed") => PpcImportDispatcherTarget::GetCTSeed,
("InterfaceLib", "MakeITable") => PpcImportDispatcherTarget::MakeITable,
("InterfaceLib", "QDError") => PpcImportDispatcherTarget::QDError,
("InterfaceLib", "CTabChanged") => PpcImportDispatcherTarget::CTabChanged,
("InterfaceLib", "ProtectEntry") => PpcImportDispatcherTarget::ProtectEntry,
("InterfaceLib", "ReserveEntry") => PpcImportDispatcherTarget::ReserveEntry,
("InterfaceLib", "RestoreEntries") => PpcImportDispatcherTarget::RestoreEntries,
("InterfaceLib", "SetEntries") => PpcImportDispatcherTarget::SetEntries,
("InterfaceLib", "RestoreDeviceClut") => PpcImportDispatcherTarget::RestoreDeviceClut,
("InterfaceLib", "DisposeCTable") => PpcImportDispatcherTarget::DisposeCTable,
("InterfaceLib", "NewPixMap") => PpcImportDispatcherTarget::NewPixMap,
("InterfaceLib", "DisposePixMap") | ("InterfaceLib", "DisposPixMap") => {
PpcImportDispatcherTarget::DisposePixMap
}
("InterfaceLib", "GetGWorld") => PpcImportDispatcherTarget::GetGWorld,
("InterfaceLib", "SetGWorld") => PpcImportDispatcherTarget::SetGWorld,
("InterfaceLib", "GetGWorldDevice") => PpcImportDispatcherTarget::GetGWorldDevice,
("InterfaceLib", "GetGWorldPixMap") => PpcImportDispatcherTarget::GetGWorldPixMap,
("InterfaceLib", "OpenPort") => PpcImportDispatcherTarget::OpenPort,
("InterfaceLib", "OpenCPort") => PpcImportDispatcherTarget::OpenCPort,
("InterfaceLib", "ClosePort") | ("InterfaceLib", "CloseCPort") => {
PpcImportDispatcherTarget::CloseCPort
}
("InterfaceLib", "SetPortBits") => PpcImportDispatcherTarget::SetPortBits { color: false },
("InterfaceLib", "SetPortPix") => PpcImportDispatcherTarget::SetPortBits { color: true },
("InterfaceLib", "GetPixBaseAddr") => PpcImportDispatcherTarget::GetPixBaseAddr,
("InterfaceLib", "LockPixels") => PpcImportDispatcherTarget::LockPixels,
("InterfaceLib", "UnlockPixels") => PpcImportDispatcherTarget::UnlockPixels,
("InterfaceLib", "GetPixelsState") => PpcImportDispatcherTarget::GetPixelsState,
("InterfaceLib", "SetPixelsState") => PpcImportDispatcherTarget::SetPixelsState,
("InterfaceLib", "AllowPurgePixels") => PpcImportDispatcherTarget::AllowPurgePixels,
("InterfaceLib", "NoPurgePixels") => PpcImportDispatcherTarget::NoPurgePixels,
("InterfaceLib", "SetRect") => PpcImportDispatcherTarget::SetRect,
("InterfaceLib", "SectRect") => PpcImportDispatcherTarget::SectRect,
("InterfaceLib", "UnionRect") => PpcImportDispatcherTarget::UnionRect,
("InterfaceLib", "EqualRect") => PpcImportDispatcherTarget::EqualRect,
("InterfaceLib", "EmptyRect") => PpcImportDispatcherTarget::EmptyRect,
("InterfaceLib", "SetPt") => PpcImportDispatcherTarget::SetPt,
("InterfaceLib", "EqualPt") => PpcImportDispatcherTarget::EqualPt,
("InterfaceLib", "PtInRect") => PpcImportDispatcherTarget::PtInRect,
("InterfaceLib", "SetOrigin") => PpcImportDispatcherTarget::SetOrigin,
("InterfaceLib", "OffsetRect") => PpcImportDispatcherTarget::OffsetRect,
("InterfaceLib", "MapRect") => PpcImportDispatcherTarget::MapRect,
("InterfaceLib", "InsetRect") => PpcImportDispatcherTarget::InsetRect,
("InterfaceLib", "FindWindow") => PpcImportDispatcherTarget::FindWindow,
("InterfaceLib", "GetGrayRgn") | ("InterfaceLib", "LMGetGrayRgn") => {
PpcImportDispatcherTarget::GetGrayRgn
}
("InterfaceLib", "LMSetGrayRgn") => PpcImportDispatcherTarget::LMSetGrayRgn,
("InterfaceLib", "GetDCtlEntry") => PpcImportDispatcherTarget::GetDCtlEntry,
("InterfaceLib", "GetADBInfo") => PpcImportDispatcherTarget::GetADBInfo,
("InterfaceLib", "OpenDriver") => PpcImportDispatcherTarget::OpenDriver,
("InterfaceLib", "Control") => PpcImportDispatcherTarget::Control,
("InterfaceLib", "PBControl")
| ("InterfaceLib", "PBControlSync")
| ("InterfaceLib", "PBControlAsync") => PpcImportDispatcherTarget::PBControl,
("InterfaceLib", "PBStatus")
| ("InterfaceLib", "PBStatusSync")
| ("InterfaceLib", "PBStatusAsync") => PpcImportDispatcherTarget::PBStatus,
("InterfaceLib", "FindFolder") => PpcImportDispatcherTarget::FindFolder,
("InterfaceLib", "NewAlias") => PpcImportDispatcherTarget::NewAlias,
("InterfaceLib", "UpdateAlias") => PpcImportDispatcherTarget::UpdateAlias,
("InterfaceLib", "ResolveAlias") => PpcImportDispatcherTarget::ResolveAlias,
("InterfaceLib", "ResolveAliasFile") => PpcImportDispatcherTarget::ResolveAliasFile,
("InterfaceLib", "DirCreate") => PpcImportDispatcherTarget::DirCreate,
("InterfaceLib", "FSpDirCreate") => PpcImportDispatcherTarget::FSpDirCreate,
("InterfaceLib", "FSMakeFSSpec") => PpcImportDispatcherTarget::FSMakeFSSpec,
("InterfaceLib", "PBGetFInfo")
| ("InterfaceLib", "PBGetFInfoSync")
| ("InterfaceLib", "PBGetFInfoAsync") => PpcImportDispatcherTarget::PBGetFInfo,
("InterfaceLib", "PBHGetFInfo")
| ("InterfaceLib", "PBHGetFInfoSync")
| ("InterfaceLib", "PBHGetFInfoAsync") => PpcImportDispatcherTarget::PBHGetFInfo,
("InterfaceLib", "PBSetFInfo")
| ("InterfaceLib", "PBSetFInfoSync")
| ("InterfaceLib", "PBSetFInfoAsync") => PpcImportDispatcherTarget::PBSetFInfo,
("InterfaceLib", "PBHSetFInfo")
| ("InterfaceLib", "PBHSetFInfoSync")
| ("InterfaceLib", "PBHSetFInfoAsync") => PpcImportDispatcherTarget::PBHSetFInfo,
("InterfaceLib", "PBGetCatInfo")
| ("InterfaceLib", "PBGetCatInfoSync")
| ("InterfaceLib", "PBGetCatInfoAsync") => PpcImportDispatcherTarget::PBGetCatInfo,
("InterfaceLib", "PBSetCatInfo")
| ("InterfaceLib", "PBSetCatInfoSync")
| ("InterfaceLib", "PBSetCatInfoAsync") => PpcImportDispatcherTarget::PBSetCatInfo,
("InterfaceLib", "PBGetVInfo")
| ("InterfaceLib", "PBGetVInfoSync")
| ("InterfaceLib", "PBGetVInfoAsync")
| ("InterfaceLib", "PBHGetVInfo")
| ("InterfaceLib", "PBHGetVInfoSync")
| ("InterfaceLib", "PBHGetVInfoAsync") => PpcImportDispatcherTarget::PBHGetVInfo,
("InterfaceLib", "PBGetFCBInfo")
| ("InterfaceLib", "PBGetFCBInfoSync")
| ("InterfaceLib", "PBGetFCBInfoAsync") => PpcImportDispatcherTarget::PBGetFCBInfo,
("InterfaceLib", "FSpGetFInfo") => PpcImportDispatcherTarget::FSpGetFInfo,
("InterfaceLib", "GetFInfo") | ("InterfaceLib", "getfinfo") => {
PpcImportDispatcherTarget::GetFInfo
}
("InterfaceLib", "HGetFInfo") => PpcImportDispatcherTarget::HGetFInfo,
("InterfaceLib", "FSpSetFInfo") => PpcImportDispatcherTarget::FSpSetFInfo,
("InterfaceLib", "HSetFInfo") => PpcImportDispatcherTarget::HSetFInfo,
("InterfaceLib", "StandardGetFile") => PpcImportDispatcherTarget::StandardGetFile,
("InterfaceLib", "GetScrap") => PpcImportDispatcherTarget::GetScrap,
("InterfaceLib", "PutScrap") => PpcImportDispatcherTarget::PutScrap,
("InterfaceLib", "ZeroScrap") => PpcImportDispatcherTarget::ZeroScrap,
("InterfaceLib", "LoadScrap") => PpcImportDispatcherTarget::LoadScrap,
("InterfaceLib", "FSpOpenDF") => PpcImportDispatcherTarget::FSpOpenDF,
("InterfaceLib", "HOpen") | ("InterfaceLib", "HOpenDF") => PpcImportDispatcherTarget::HOpen,
("InterfaceLib", "FSOpen") => PpcImportDispatcherTarget::FSOpen,
("InterfaceLib", "PBHOpenDF")
| ("InterfaceLib", "PBHOpenDFSync")
| ("InterfaceLib", "PBHOpenDFAsync")
| ("InterfaceLib", "PBHOpen")
| ("InterfaceLib", "PBHOpenSync")
| ("InterfaceLib", "PBHOpenAsync") => PpcImportDispatcherTarget::PBHOpenDF,
("InterfaceLib", "FSpCreateResFile") => PpcImportDispatcherTarget::FSpCreateResFile,
("InterfaceLib", "HCreateResFile") => PpcImportDispatcherTarget::HCreateResFile,
("InterfaceLib", "FSpOpenResFile") => PpcImportDispatcherTarget::FSpOpenResFile,
("InterfaceLib", "FSClose") => PpcImportDispatcherTarget::FSClose,
("InterfaceLib", "PBClose")
| ("InterfaceLib", "PBCloseSync")
| ("InterfaceLib", "PBCloseAsync") => PpcImportDispatcherTarget::PBClose,
("InterfaceLib", "PBFlushFile")
| ("InterfaceLib", "PBFlushFileSync")
| ("InterfaceLib", "PBFlushFileAsync") => PpcImportDispatcherTarget::PBFlushFile,
("InterfaceLib", "FSRead") => PpcImportDispatcherTarget::FSRead,
("InterfaceLib", "PBRead")
| ("InterfaceLib", "PBReadSync")
| ("InterfaceLib", "PBReadAsync") => PpcImportDispatcherTarget::PBRead,
("InterfaceLib", "FSWrite") => PpcImportDispatcherTarget::FSWrite,
("InterfaceLib", "PBWrite")
| ("InterfaceLib", "PBWriteSync")
| ("InterfaceLib", "PBWriteAsync") => PpcImportDispatcherTarget::PBWrite,
("InterfaceLib", "GetEOF") => PpcImportDispatcherTarget::GetEOF,
("InterfaceLib", "PBGetEOF")
| ("InterfaceLib", "PBGetEOFSync")
| ("InterfaceLib", "PBGetEOFAsync") => PpcImportDispatcherTarget::PBGetEOF,
("InterfaceLib", "SetEOF") => PpcImportDispatcherTarget::SetEOF,
("InterfaceLib", "AllocContig") | ("InterfaceLib", "Allocate") => {
PpcImportDispatcherTarget::AllocContig
}
("InterfaceLib", "PBSetEOF")
| ("InterfaceLib", "PBSetEOFSync")
| ("InterfaceLib", "PBSetEOFAsync") => PpcImportDispatcherTarget::PBSetEOF,
("InterfaceLib", "GetFPos") => PpcImportDispatcherTarget::GetFPos,
("InterfaceLib", "SetFPos") => PpcImportDispatcherTarget::SetFPos,
("InterfaceLib", "PBSetFPos")
| ("InterfaceLib", "PBSetFPosSync")
| ("InterfaceLib", "PBSetFPosAsync") => PpcImportDispatcherTarget::PBSetFPos,
("InterfaceLib", "FSpCreate") => PpcImportDispatcherTarget::FSpCreate,
("InterfaceLib", "PBHCreate" | "PBHCreateSync" | "PBHCreateAsync") => {
PpcImportDispatcherTarget::PBCreate(PpcParameterBlockCreateOperation::Hierarchical)
}
("InterfaceLib", "PBCreate")
| ("InterfaceLib", "PBCreateSync")
| ("InterfaceLib", "PBCreateAsync") => {
PpcImportDispatcherTarget::PBCreate(PpcParameterBlockCreateOperation::Legacy)
}
("InterfaceLib", "FSpDelete") => PpcImportDispatcherTarget::FSpDelete,
("InterfaceLib", "HDelete") => PpcImportDispatcherTarget::DeleteByName(
PpcDeleteByNameOperation::HierarchicalHighLevel,
),
("InterfaceLib", "FSDelete") => PpcImportDispatcherTarget::DeleteByName(
PpcDeleteByNameOperation::LegacyHighLevel,
),
("InterfaceLib", "PBDelete")
| ("InterfaceLib", "PBDeleteSync")
| ("InterfaceLib", "PBDeleteAsync") => PpcImportDispatcherTarget::DeleteByName(
PpcDeleteByNameOperation::LegacyParameterBlock,
),
("InterfaceLib", "PBHDelete" | "PBHDeleteSync" | "PBHDeleteAsync") => {
PpcImportDispatcherTarget::DeleteByName(
PpcDeleteByNameOperation::HierarchicalParameterBlock,
)
}
("InterfaceLib", "HCreate") => PpcImportDispatcherTarget::HCreate,
("InterfaceLib", "Create") => PpcImportDispatcherTarget::Create,
("InterfaceLib", "GetNewDialog") => PpcImportDispatcherTarget::GetNewDialog,
("InterfaceLib", "NewDialog")
| ("InterfaceLib", "NewColorDialog")
| ("InterfaceLib", "NewCDialog") => PpcImportDispatcherTarget::NewDialog,
("AppearanceLib", "NewFeaturesDialog") | ("InterfaceLib", "NewFeaturesDialog") => {
PpcImportDispatcherTarget::NewFeaturesDialog
}
("InterfaceLib", "GetDialogItem") => PpcImportDispatcherTarget::GetDialogItem,
("InterfaceLib", "SetDialogItem") | ("InterfaceLib", "SetDItem") => {
PpcImportDispatcherTarget::SetDialogItem
}
("InterfaceLib", "GetDialogItemText") | ("InterfaceLib", "getdialogitemtext") => {
PpcImportDispatcherTarget::GetDialogItemText
}
("InterfaceLib", "SetDialogItemText") | ("InterfaceLib", "setdialogitemtext") => {
PpcImportDispatcherTarget::SetDialogItemText
}
("InterfaceLib", "SetDialogDefaultItem") => PpcImportDispatcherTarget::SetDialogDefaultItem,
("InterfaceLib" | "AppearanceLib", "SetDialogCancelItem") => {
PpcImportDispatcherTarget::SetDialogCancelItem
}
("InterfaceLib", "DrawDialog") => PpcImportDispatcherTarget::DrawDialog,
("InterfaceLib", "DrawControls") => PpcImportDispatcherTarget::DrawControls,
("InterfaceLib", "ModalDialog") => PpcImportDispatcherTarget::ModalDialog,
("InterfaceLib", "SetControlTitle") | ("InterfaceLib", "SetCTitle") => {
PpcImportDispatcherTarget::SetControlTitle
}
("InterfaceLib", "SetControlValue") => PpcImportDispatcherTarget::SetControlValue,
("InterfaceLib", "HiliteControl") => PpcImportDispatcherTarget::HiliteControl,
("InterfaceLib", "InitGraf") => PpcImportDispatcherTarget::InitGraf,
("InterfaceLib", "InitFonts") => PpcImportDispatcherTarget::InitFonts,
("InterfaceLib", "InitWindows") => PpcImportDispatcherTarget::InitWindows,
("InterfaceLib", "InitMenus") => PpcImportDispatcherTarget::InitMenus,
("InterfaceLib", "TEInit") => PpcImportDispatcherTarget::TEInit,
("InterfaceLib", "TENew") => PpcImportDispatcherTarget::TENew,
("InterfaceLib", "TEStyleNew") => PpcImportDispatcherTarget::TEStyleNew,
("InterfaceLib", "TESetStyle") => PpcImportDispatcherTarget::TESetStyle,
("InterfaceLib", "TEUseStyleScrap") => PpcImportDispatcherTarget::TEUseStyleScrap,
("InterfaceLib", "TEContinuousStyle") => PpcImportDispatcherTarget::TEContinuousStyle,
("InterfaceLib", "TEGetText") => PpcImportDispatcherTarget::TEGetText,
("InterfaceLib", "TEDispose") | ("InterfaceLib", "TEDispos") => PpcImportDispatcherTarget::TEDispose,
("InterfaceLib", "TEActivate") | ("InterfaceLib", "TEActivat") => PpcImportDispatcherTarget::TEActivate { active: true },
("InterfaceLib", "TEDeactivate") | ("InterfaceLib", "TEDeactivat") => PpcImportDispatcherTarget::TEActivate { active: false },
("InterfaceLib", "TESetSelect") => PpcImportDispatcherTarget::TESetSelect,
("InterfaceLib", "TESetText") => PpcImportDispatcherTarget::TESetText,
("InterfaceLib", "TECalText") => PpcImportDispatcherTarget::TECalText,
("InterfaceLib", "TEInsert") => PpcImportDispatcherTarget::TEInsert { styled: false },
("InterfaceLib", "TEStyleInsert") => PpcImportDispatcherTarget::TEInsert { styled: true },
("InterfaceLib", "TEDelete") => PpcImportDispatcherTarget::TEDelete,
("InterfaceLib", "TEKey") => PpcImportDispatcherTarget::TEKey,
("InterfaceLib", "TEClick") => PpcImportDispatcherTarget::TEClick,
("InterfaceLib", "TEIdle") => PpcImportDispatcherTarget::TEIdle,
("InterfaceLib", "TEUpdate") => PpcImportDispatcherTarget::TEUpdate,
("InterfaceLib", "TETextBox") => PpcImportDispatcherTarget::TETextBox,
("InterfaceLib", "TESetAlignment")
| ("InterfaceLib", "TESetJust") => PpcImportDispatcherTarget::TESetAlignment,
("InterfaceLib", "TEGetHeight") => PpcImportDispatcherTarget::TEGetHeight,
("InterfaceLib", "TEGetPoint") => PpcImportDispatcherTarget::TEGetPoint,
("InterfaceLib", "TEScroll") => PpcImportDispatcherTarget::TEScroll { pinned: false },
("InterfaceLib", "TEPinScroll") => PpcImportDispatcherTarget::TEScroll { pinned: true },
("InterfaceLib", "TEAutoView") => PpcImportDispatcherTarget::TEAutoView,
("InterfaceLib", "TECopy") => PpcImportDispatcherTarget::TECopy {
cut: false,
dialog: false,
},
("InterfaceLib", "TECut") => PpcImportDispatcherTarget::TECopy {
cut: true,
dialog: false,
},
("InterfaceLib", "DialogCopy") => PpcImportDispatcherTarget::TECopy {
cut: false,
dialog: true,
},
("InterfaceLib", "DialogCut") => PpcImportDispatcherTarget::TECopy {
cut: true,
dialog: true,
},
("InterfaceLib", "TEPaste" | "TEStylePaste") => {
PpcImportDispatcherTarget::TEPaste { dialog: false }
}
("InterfaceLib", "DialogPaste") => PpcImportDispatcherTarget::TEPaste { dialog: true },
("InterfaceLib", "TEToScrap") => PpcImportDispatcherTarget::TETransferScrap {
from_desktop: false,
},
("InterfaceLib", "TEFromScrap") => {
PpcImportDispatcherTarget::TETransferScrap { from_desktop: true }
}
("InterfaceLib", "TEScrapHandle") => PpcImportDispatcherTarget::TEScrapHandle,
("InterfaceLib", "LMGetTEScrpLength" | "TEGetScrapLength") => {
PpcImportDispatcherTarget::TEScrapLength { set: false }
}
("InterfaceLib", "LMSetTEScrpLength") => {
PpcImportDispatcherTarget::TEScrapLength { set: true }
}
("InterfaceLib", "SelectDialogItemText") => PpcImportDispatcherTarget::SelectDialogItemText,
("InterfaceLib", "InitDialogs") => PpcImportDispatcherTarget::InitDialogs,
("InterfaceLib", "SystemTask") => PpcImportDispatcherTarget::SystemTask,
("InterfaceLib", "SystemClick") => PpcImportDispatcherTarget::SystemClick,
("InterfaceLib", "OpenDeskAcc") => PpcImportDispatcherTarget::OpenDeskAcc,
("InterfaceLib", "AEProcessAppleEvent") => PpcImportDispatcherTarget::AEProcessAppleEvent,
("InterfaceLib", "LNew") => PpcImportDispatcherTarget::LNew,
("InterfaceLib", "LDispose") => PpcImportDispatcherTarget::LDispose,
("InterfaceLib", "LAddRow") => PpcImportDispatcherTarget::LAddRow,
("InterfaceLib", "LDelRow") => PpcImportDispatcherTarget::LDelRow,
("InterfaceLib", "LGetSelect") => PpcImportDispatcherTarget::LGetSelect,
("InterfaceLib", "LSetSelect") => PpcImportDispatcherTarget::LSetSelect,
("InterfaceLib", "LSetCell") => PpcImportDispatcherTarget::LSetCell,
("InterfaceLib", "LGetCell") => PpcImportDispatcherTarget::LGetCell,
("InterfaceLib", "LClick") => PpcImportDispatcherTarget::LClick,
("InterfaceLib", "LActivate") => PpcImportDispatcherTarget::LActivate,
("InterfaceLib", "LSetDrawingMode") => PpcImportDispatcherTarget::LSetDrawingMode,
("InterfaceLib", "LScroll") => PpcImportDispatcherTarget::LScroll,
("InterfaceLib", "LSize") => PpcImportDispatcherTarget::LSize,
("InterfaceLib", "LUpdate") => PpcImportDispatcherTarget::LUpdate,
("InterfaceLib", "LAutoScroll") => PpcImportDispatcherTarget::LAutoScroll,
("InterfaceLib", "LSearch") => PpcImportDispatcherTarget::LSearch,
("InterfaceLib", "FlushEvents") => PpcImportDispatcherTarget::FlushEvents,
("InterfaceLib", "SetEventMask") => PpcImportDispatcherTarget::SetEventMask,
("InterfaceLib", "DisposeDialog" | "CloseDialog") => {
PpcImportDispatcherTarget::DisposeDialog
}
("InterfaceLib", "GetNextEvent") => PpcImportDispatcherTarget::GetNextEvent(
PpcEventPollOperation::GetNextEvent,
),
("InterfaceLib", "WaitNextEvent") => PpcImportDispatcherTarget::GetNextEvent(
PpcEventPollOperation::WaitNextEvent,
),
("InterfaceLib", "GetOSEvent") => PpcImportDispatcherTarget::GetOSEvent,
("InterfaceLib", "EventAvail") => PpcImportDispatcherTarget::EventAvail,
("InterfaceLib", "OSEventAvail") => PpcImportDispatcherTarget::OSEventAvail,
("InterfaceLib", "PostEvent") => PpcImportDispatcherTarget::PostEvent,
("InterfaceLib", "Button") => PpcImportDispatcherTarget::Button,
("InterfaceLib", "StillDown") => PpcImportDispatcherTarget::StillDown,
("InterfaceLib", "WaitMouseUp") => PpcImportDispatcherTarget::WaitMouseUp,
("InterfaceLib", "GetKeys") => PpcImportDispatcherTarget::GetKeys,
("InterfaceLib", "GetDateTime") => PpcImportDispatcherTarget::GetDateTime,
("InterfaceLib", "ReadDateTime") => PpcImportDispatcherTarget::ReadDateTime,
("InterfaceLib", "ReadLocation") => PpcImportDispatcherTarget::ReadLocation,
("InterfaceLib", "GetTime") => PpcImportDispatcherTarget::GetTime,
("InterfaceLib", "Delay") => PpcImportDispatcherTarget::Delay,
("InterfaceLib", "GetDblTime") => PpcImportDispatcherTarget::GetDblTime,
("InterfaceLib", "LMGetTime") => PpcImportDispatcherTarget::LMGetTime,
("InterfaceLib", "LMGetUTableBase") => PpcImportDispatcherTarget::LMGetUTableBase,
("InterfaceLib", "LMGetCurDirStore") => PpcImportDispatcherTarget::LMGetCurDirStore,
("InterfaceLib", "LMSetCurDirStore") => PpcImportDispatcherTarget::LMSetCurDirStore,
("InterfaceLib", "LMGetRndSeed") => PpcImportDispatcherTarget::LMGetRndSeed,
("InterfaceLib", "LMSetRndSeed") => PpcImportDispatcherTarget::LMSetRndSeed,
("InterfaceLib", "SetCurrentA5") => PpcImportDispatcherTarget::SetCurrentA5,
("InterfaceLib", "SetA5") => PpcImportDispatcherTarget::SetA5,
("InterfaceLib", "SecondsToDate") | ("InterfaceLib", "Secs2Date") => {
PpcImportDispatcherTarget::SecondsToDate
}
("InterfaceLib", "Microseconds") => PpcImportDispatcherTarget::Microseconds,
("InterfaceLib", "LMGetTicks") => PpcImportDispatcherTarget::TickCount,
("InterfaceLib", "SysEnvirons") => PpcImportDispatcherTarget::SysEnvirons,
("InterfaceLib", "TextWidth") => PpcImportDispatcherTarget::TextWidth,
("InterfaceLib", "StringWidth") => PpcImportDispatcherTarget::StringWidth,
("InterfaceLib", "TruncString") => PpcImportDispatcherTarget::TruncString,
("InterfaceLib", "CharWidth") => PpcImportDispatcherTarget::CharWidth,
("InterfaceLib", "MeasureText") => PpcImportDispatcherTarget::MeasureText,
("InterfaceLib", "RealFont") => PpcImportDispatcherTarget::RealFont,
("InterfaceLib", "GetFontInfo") => PpcImportDispatcherTarget::GetFontInfo,
("InterfaceLib", "FontMetrics") => PpcImportDispatcherTarget::FontMetrics,
("InterfaceLib", "GetFNum") => PpcImportDispatcherTarget::GetFNum,
("InterfaceLib", "GetIntlResource") => PpcImportDispatcherTarget::GetIntlResource,
("InterfaceLib", "AESetInteractionAllowed") => {
PpcImportDispatcherTarget::AESetInteractionAllowed
}
("InterfaceLib", "AEGetInteractionAllowed") => {
PpcImportDispatcherTarget::AEGetInteractionAllowed
}
("InterfaceLib", "SVersion") => PpcImportDispatcherTarget::SVersion,
("InterfaceLib", "EqualString") => PpcImportDispatcherTarget::EqualString,
("InterfaceLib", "NumToString") => PpcImportDispatcherTarget::NumToString,
("InterfaceLib", "StringToNum") => PpcImportDispatcherTarget::StringToNum,
("InterfaceLib", "Random") => PpcImportDispatcherTarget::Random,
("InterfaceLib", "BitAnd") => PpcImportDispatcherTarget::BitAnd,
("InterfaceLib", "BitOr") => PpcImportDispatcherTarget::BitOr,
("InterfaceLib", "BitTst") => PpcImportDispatcherTarget::BitTst,
("InterfaceLib", "p2cstr") | ("InterfaceLib", "P2CStr") => {
PpcImportDispatcherTarget::P2CStr
}
("InterfaceLib", "c2pstr") | ("InterfaceLib", "C2PStr") => {
PpcImportDispatcherTarget::C2PStr
}
("InterfaceLib", "UpperText") => PpcImportDispatcherTarget::UpperText,
("InterfaceLib", "GetCurrentThread" | "MacGetCurrentThread") => {
PpcImportDispatcherTarget::GetCurrentThread
}
("InterfaceLib", "GetThreadCurrentTaskRef") => {
PpcImportDispatcherTarget::GetThreadCurrentTaskRef
}
("InterfaceLib", "GetThreadStateGivenTaskRef") => {
PpcImportDispatcherTarget::GetThreadStateGivenTaskRef
}
("InterfaceLib", "SetThreadReadyGivenTaskRef") => {
PpcImportDispatcherTarget::SetThreadReadyGivenTaskRef
}
("InterfaceLib", "GetThreadState") => PpcImportDispatcherTarget::GetThreadState,
("InterfaceLib", "SetThreadState") => PpcImportDispatcherTarget::SetThreadState,
("InterfaceLib", "SetThreadStateEndCritical") => {
PpcImportDispatcherTarget::SetThreadStateEndCritical
}
("InterfaceLib", "CreateThreadPool") => PpcImportDispatcherTarget::CreateThreadPool,
("InterfaceLib", "GetFreeThreadCount") => PpcImportDispatcherTarget::GetFreeThreadCount,
("InterfaceLib", "GetSpecificFreeThreadCount") => {
PpcImportDispatcherTarget::GetSpecificFreeThreadCount
}
("InterfaceLib", "GetDefaultThreadStackSize") => {
PpcImportDispatcherTarget::GetDefaultThreadStackSize
}
("InterfaceLib", "ThreadCurrentStackSpace") => {
PpcImportDispatcherTarget::ThreadCurrentStackSpace
}
("InterfaceLib", "NewThread") => PpcImportDispatcherTarget::NewThread,
("InterfaceLib", "YieldToThread") => PpcImportDispatcherTarget::YieldToThread,
("InterfaceLib", "YieldToAnyThread") => PpcImportDispatcherTarget::YieldToAnyThread,
("InterfaceLib", "DisposeThread") => PpcImportDispatcherTarget::DisposeThread,
("InterfaceLib", "ThreadBeginCritical") => PpcImportDispatcherTarget::ThreadBeginCritical,
("InterfaceLib", "ThreadEndCritical") => PpcImportDispatcherTarget::ThreadEndCritical,
("InterfaceLib", "GetCurrentProcess" | "GetFrontProcess") => {
PpcImportDispatcherTarget::GetCurrentProcess
}
("InterfaceLib", "WakeUpProcess") => PpcImportDispatcherTarget::WakeUpProcess,
("InterfaceLib", "SameProcess") => PpcImportDispatcherTarget::SameProcess,
("InterfaceLib", "GetProcessInformation") => {
PpcImportDispatcherTarget::GetProcessInformation
}
("InterfaceLib", "ExitToShell") => PpcImportDispatcherTarget::ExitToShell,
("InterfaceLib", "SndSoundManagerVersion") => {
PpcImportDispatcherTarget::SndSoundManagerVersion
}
("SoundLib" | "InterfaceLib", "UnsignedFixedMulDiv" | "UnsignedFixMulDiv") => {
PpcImportDispatcherTarget::UnsignedFixedMulDiv
}
("SoundLib" | "InterfaceLib", "GetSoundOutputInfo") => {
PpcImportDispatcherTarget::GetSoundOutputInfo
}
("InterfaceLib", "GetSoundVol") => PpcImportDispatcherTarget::GetSoundVol,
("InterfaceLib", "SetSoundVol") => PpcImportDispatcherTarget::SetSoundVol,
("InterfaceLib", "GetDefaultOutputVolume") => {
PpcImportDispatcherTarget::GetDefaultOutputVolume
}
("InterfaceLib", "SetDefaultOutputVolume") => {
PpcImportDispatcherTarget::SetDefaultOutputVolume
}
("InterfaceLib", "GetVol") => PpcImportDispatcherTarget::GetVol,
("InterfaceLib", "GetWDInfo") => PpcImportDispatcherTarget::GetWDInfo,
("InterfaceLib", "HGetVol") => PpcImportDispatcherTarget::HGetVol,
("InterfaceLib", "HSetVol") => PpcImportDispatcherTarget::HSetVol,
("InterfaceLib", "FlushVol") => PpcImportDispatcherTarget::FlushVol,
("InterfaceLib", "PBFlushVol")
| ("InterfaceLib", "PBFlushVolSync")
| ("InterfaceLib", "PBFlushVolAsync") => PpcImportDispatcherTarget::PBFlushVol,
("InterfaceLib", "SndNewChannel") => PpcImportDispatcherTarget::SndNewChannel,
("InterfaceLib", "SndDisposeChannel") => PpcImportDispatcherTarget::SndDisposeChannel,
("InterfaceLib", "SndPlay") => PpcImportDispatcherTarget::SndPlay,
("InterfaceLib", "SndChannelStatus") => PpcImportDispatcherTarget::SndChannelStatus,
("SoundLib" | "InterfaceLib", "SndGetInfo") => PpcImportDispatcherTarget::SndGetInfo,
("SoundLib", "ParseSndHeader") => PpcImportDispatcherTarget::ParseSndHeader,
("InterfaceLib", "SndDoImmediate") => PpcImportDispatcherTarget::SndDoImmediate,
("InterfaceLib", "SndDoCommand") => PpcImportDispatcherTarget::SndDoCommand,
("InterfaceLib", "SndPlayDoubleBuffer") => PpcImportDispatcherTarget::SndPlayDoubleBuffer,
("InterfaceLib", "SndStartFilePlay") => PpcImportDispatcherTarget::SndStartFilePlay,
("InterfaceLib", "SndPauseFilePlay") => PpcImportDispatcherTarget::SndPauseFilePlay,
("InterfaceLib", "SndStopFilePlay") => PpcImportDispatcherTarget::SndStopFilePlay,
("InterfaceLib", "GetSoundHeaderOffset") => PpcImportDispatcherTarget::GetSoundHeaderOffset,
("InterfaceLib", "CloseComponent") => PpcImportDispatcherTarget::CloseComponent,
("QuickTimeLib", "GetGraphicsImporterForFile") => {
PpcImportDispatcherTarget::QtGetGraphicsImporterForFile
}
("QuickTimeLib", "GraphicsImportGetBoundsRect") => {
PpcImportDispatcherTarget::QtGraphicsImportGetBoundsRect
}
("QuickTimeLib", "GraphicsImportSetGWorld") => {
PpcImportDispatcherTarget::QtGraphicsImportSetGWorld
}
("QuickTimeLib", "GraphicsImportDraw") => PpcImportDispatcherTarget::QtGraphicsImportDraw,
("QuickTimeLib", "OpenMovieFile") => PpcImportDispatcherTarget::QtOpenMovieFile,
("QuickTimeLib", "NewMovieFromFile") => PpcImportDispatcherTarget::QtNewMovieFromFile,
("QuickTimeLib", "GetMovieBox") => PpcImportDispatcherTarget::QtGetMovieBox,
("QuickTimeLib", "SetMovieBox") => PpcImportDispatcherTarget::QtSetMovieBox,
("QuickTimeLib", "SetMovieGWorld") => PpcImportDispatcherTarget::QtSetMovieGWorld,
("QuickTimeLib", "StartMovie") => PpcImportDispatcherTarget::QtStartMovie,
("QuickTimeLib", "StopMovie") => PpcImportDispatcherTarget::QtStopMovie,
("QuickTimeLib", "MoviesTask") => PpcImportDispatcherTarget::QtMoviesTask,
("QuickTimeLib", "DisposeMovie") => PpcImportDispatcherTarget::QtDisposeMovie,
("QuickTimeLib", "IsMovieDone") => PpcImportDispatcherTarget::QtIsMovieDone,
("QuickTimeLib", "GoToBeginningOfMovie") => {
PpcImportDispatcherTarget::QtGoToBeginningOfMovie
}
("QuickTimeLib", "GoToEndOfMovie") => PpcImportDispatcherTarget::QtGoToEndOfMovie,
("QuickTimeLib", "GetMovieDuration") => PpcImportDispatcherTarget::QtGetMovieDuration,
("QuickTimeLib", "LoadMovieIntoRam") => PpcImportDispatcherTarget::QtLoadMovieIntoRam,
("QuickTimeLib", "CloseMovieFile") => PpcImportDispatcherTarget::QtCloseMovieFile,
("QuickTimeLib", "EnterMovies") => PpcImportDispatcherTarget::QtEnterMovies,
("QuickTimeLib", "ExitMovies") => PpcImportDispatcherTarget::QtExitMovies,
("QuickTimeLib", "GetMoviesError") => PpcImportDispatcherTarget::QtGetMoviesError,
("QuickTimeLib", "GetMoviesStickyError") => {
PpcImportDispatcherTarget::QtGetMoviesStickyError
}
("QuickTimeLib", "ClearMoviesStickyError") => {
PpcImportDispatcherTarget::QtClearMoviesStickyError
}
("InterfaceLib", "ParamText") | ("InterfaceLib", "paramtext") => {
PpcImportDispatcherTarget::ParamText
}
("InterfaceLib", "X2Fix") => PpcImportDispatcherTarget::X2Fix,
("InterfaceLib", "Alert" | "StopAlert" | "NoteAlert" | "CautionAlert") => {
PpcImportDispatcherTarget::AlertReturnDefault
}
("InterfaceLib", "PurgeMem") => PpcImportDispatcherTarget::PurgeMem,
("InterfaceLib", "PurgeMemSys") => PpcImportDispatcherTarget::PurgeMemSys,
("InterfaceLib", "ReleaseResource") => PpcImportDispatcherTarget::ReleaseResource,
("InterfaceLib", "DetachResource") => PpcImportDispatcherTarget::DetachResource,
("InterfaceLib", "ReadPartialResource") => PpcImportDispatcherTarget::ReadPartialResource,
("InterfaceLib", "GetIcon") => PpcImportDispatcherTarget::GetIcon,
("InterfaceLib", "GetIconSuite") => PpcImportDispatcherTarget::GetIconSuite,
("InterfaceLib", "GetPattern") => PpcImportDispatcherTarget::GetPattern,
("InterfaceLib", "NewRoutineDescriptor") => PpcImportDispatcherTarget::NewRoutineDescriptor,
("InterfaceLib", "NewFatRoutineDescriptor") => {
PpcImportDispatcherTarget::NewFatRoutineDescriptor
}
("InterfaceLib", "DisposeRoutineDescriptor") => {
PpcImportDispatcherTarget::DisposeRoutineDescriptor
}
("InterfaceLib", "CallUniversalProc") => PpcImportDispatcherTarget::CallUniversalProc,
("InterfaceLib", "CallOSTrapUniversalProc") => {
PpcImportDispatcherTarget::CallOSTrapUniversalProc
}
("InterfaceLib", "NGetTrapAddress") => PpcImportDispatcherTarget::NGetTrapAddress,
("InterfaceLib", "GetToolTrapAddress") | ("InterfaceLib", "GetToolboxTrapAddress") => {
PpcImportDispatcherTarget::GetToolTrapAddress
}
("InterfaceLib", "GetOSTrapAddress") => PpcImportDispatcherTarget::GetOSTrapAddress,
("InterfaceLib", "SetToolTrapAddress") | ("InterfaceLib", "SetToolboxTrapAddress") => {
PpcImportDispatcherTarget::SetToolTrapAddress
}
("InterfaceLib", "SetOSTrapAddress") => PpcImportDispatcherTarget::SetOSTrapAddress,
("InterfaceLib", "NSetTrapAddress") => PpcImportDispatcherTarget::NSetTrapAddress,
("InterfaceLib", "LMGetCurrentA5") => PpcImportDispatcherTarget::LMGetCurrentA5,
("InterfaceLib", "InsTime") => PpcImportDispatcherTarget::InsTime,
("InterfaceLib", "InsXTime") => PpcImportDispatcherTarget::InsXTime,
("InterfaceLib", "PrimeTime") => PpcImportDispatcherTarget::PrimeTime,
("InterfaceLib", "RmvTime") => PpcImportDispatcherTarget::RmvTime,
("InterfaceLib", "VInstall") => PpcImportDispatcherTarget::VInstall,
("InterfaceLib", "VRemove") => PpcImportDispatcherTarget::VRemove,
("InterfaceLib", "SlotVInstall") => PpcImportDispatcherTarget::SlotVInstall,
("InterfaceLib", "SlotVRemove") => PpcImportDispatcherTarget::SlotVRemove,
("InterfaceLib", "BitClr") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::BitClear,
),
("InterfaceLib", "BitNot") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::BitNot,
),
("InterfaceLib", "BitSet") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::BitSet,
),
("InterfaceLib", "Fix2X") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::FixToExtended,
),
("InterfaceLib", "GetMyZone") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::GetMyZone,
),
("InterfaceLib", "HandleZone") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::HandleZone,
),
("InterfaceLib", "LockMemory") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::LockMemory,
),
("InterfaceLib", "MaxBlock") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::MaxBlock,
),
("InterfaceLib", "PurgeSpace") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::PurgeSpace,
),
("InterfaceLib", "ReserveMem") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::ReserveMem,
),
("InterfaceLib", "SetGrowZone") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::SetGrowZone,
),
("InterfaceLib", "StackSpace") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::StackSpace,
),
("InterfaceLib", "TempFreeMem") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::TempFreeMem,
),
("InterfaceLib", "UnlockMemory") => PpcImportDispatcherTarget::LegacyMemoryUtility(
PpcLegacyMemoryUtilityOperation::UnlockMemory,
),
("InterfaceLib", "DisposeControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::DisposeControl,
),
("InterfaceLib", "Draw1Control") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::DrawOneControl,
),
("InterfaceLib", "FindControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::FindControl,
),
("InterfaceLib", "GetControlMaximum") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::GetControlMaximum,
),
("InterfaceLib", "GetControlMinimum") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::GetControlMinimum,
),
("InterfaceLib", "GetControlTitle") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::GetControlTitle,
),
("InterfaceLib", "GetControlValue") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::GetControlValue,
),
("InterfaceLib", "GetNewControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::GetNewControl,
),
("InterfaceLib", "HideControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::HideControl,
),
("InterfaceLib", "KillControls") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::KillControls,
),
("InterfaceLib", "MoveControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::MoveControl,
),
("InterfaceLib", "NewControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::NewControl,
),
("InterfaceLib", "SetControlMaximum") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::SetControlMaximum,
),
("InterfaceLib", "SetControlMinimum") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::SetControlMinimum,
),
("InterfaceLib", "ShowControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::ShowControl,
),
("InterfaceLib", "SizeControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::SizeControl,
),
("InterfaceLib", "TestControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::TestControl,
),
("InterfaceLib", "TrackControl") => PpcImportDispatcherTarget::LegacyControl(
PpcLegacyControlOperation::TrackControl,
),
("InterfaceLib", "BringToFront") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::BringToFront,
),
("InterfaceLib", "CalcVis") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::CalculateVisibleRegion,
),
("InterfaceLib", "DisposeWindow") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::DisposeWindow,
),
("InterfaceLib", "DragWindow") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::DragWindow,
),
("InterfaceLib", "GetNewWindow") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::GetNewWindow,
),
("InterfaceLib", "GetWTitle") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::GetWindowTitle,
),
("InterfaceLib", "GrowWindow") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::GrowWindow,
),
("InterfaceLib", "HiliteWindow") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::HighlightWindow,
),
("InterfaceLib", "NewWindow") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::NewWindow,
),
("InterfaceLib", "SendBehind") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::SendBehind,
),
("InterfaceLib", "SetWTitle") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::SetWindowTitle,
),
("InterfaceLib", "TrackBox") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::TrackBox,
),
("InterfaceLib", "TrackGoAway") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::TrackGoAway,
),
("InterfaceLib", "ZoomWindow") => PpcImportDispatcherTarget::LegacyWindow(
PpcLegacyWindowOperation::ZoomWindow,
),
("InterfaceLib", "AECountItems") => PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::CountItems,
),
("InterfaceLib", "AECreateAppleEvent") => {
PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::CreateAppleEvent,
)
}
("InterfaceLib", "AECreateDesc") => PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::CreateDesc,
),
("InterfaceLib", "AEDisposeDesc") => {
PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::DisposeDesc,
)
}
("InterfaceLib", "AEGetAttributePtr") => {
PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::GetAttributePtr,
)
}
("InterfaceLib", "AEGetNthPtr") => PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::GetNthPtr,
),
("InterfaceLib", "AEGetParamDesc") => {
PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::GetParamDesc,
)
}
("InterfaceLib", "AEPutParamDesc") => {
PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::PutParamDesc,
)
}
("InterfaceLib", "AEPutParamPtr") => PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::PutParamPtr,
),
("InterfaceLib", "AESend") => PpcImportDispatcherTarget::AppleEventCompatibility(
PpcAppleEventCompatibilityOperation::Send,
),
("InterfaceLib", "AppendDITL") => PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::AppendDitl,
),
("InterfaceLib", "CountDITL") => PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::CountDitl,
),
("InterfaceLib", "DialogSelect") => PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::DialogSelect,
),
("InterfaceLib", "FindDialogItem") => PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::FindDialogItem,
),
("InterfaceLib", "HideDialogItem") => PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::HideDialogItem,
),
("InterfaceLib", "IsDialogEvent") => PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::IsDialogEvent,
),
("InterfaceLib", "ShortenDITL") => PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::ShortenDitl,
),
("InterfaceLib", "ShowDialogItem") => PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::ShowDialogItem,
),
("InterfaceLib", "UpdateDialog") => PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::UpdateDialog,
),
("InterfaceLib", "AnimateEntry") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::AnimateEntry),
("InterfaceLib", "AnimatePalette") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::AnimatePalette),
("InterfaceLib", "BackPat") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::BackPat),
("InterfaceLib", "BackPixPat") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::BackPixPat),
("InterfaceLib", "ClosePicture") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::ClosePicture),
("InterfaceLib", "CopyDeepMask") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::CopyDeepMask),
("InterfaceLib", "CopyMask") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::CopyMask),
("InterfaceLib", "CopyPalette") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::CopyPalette),
("InterfaceLib", "CTab2Palette") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::Ctab2Palette),
("InterfaceLib", "DisposeGDevice") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::DisposeGDevice),
("InterfaceLib", "DisposePalette") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::DisposePalette),
("InterfaceLib", "Exp1to3") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::Exp1To3),
("InterfaceLib", "Exp1to6") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::Exp1To6),
("InterfaceLib", "GetCPixel") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::GetCPixel),
("InterfaceLib", "GetEntryUsage") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::GetEntryUsage),
("InterfaceLib", "GetItemIcon") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::GetItemIcon),
("InterfaceLib", "GetItemStyle") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::GetItemStyle),
("InterfaceLib", "GetNewPalette") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::GetNewPalette),
("InterfaceLib", "NewGDevice") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::NewGDevice),
("InterfaceLib", "NewPalette") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::NewPalette),
("InterfaceLib", "OpenPicture") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::OpenPicture),
("InterfaceLib", "Palette2CTab") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::Palette2Ctab),
("InterfaceLib", "PenPat") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::PenPat),
("InterfaceLib", "PlotIcon") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::PlotIcon),
("InterfaceLib", "ScrollRect") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::ScrollRect),
("InterfaceLib", "SetCPixel") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::SetCPixel),
("InterfaceLib", "SetEntryColor") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::SetEntryColor),
("InterfaceLib", "SetEntryUsage") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::SetEntryUsage),
("InterfaceLib", "SetItemIcon") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::SetItemIcon),
("InterfaceLib", "SetItemStyle") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::SetItemStyle),
("InterfaceLib", "SetStdCProcs") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::SetStdCProcs),
("InterfaceLib", "SetStdProcs") => PpcImportDispatcherTarget::QuickDrawCompatibility(PpcQuickDrawCompatibilityOperation::SetStdProcs),
("InterfaceLib", "BuildDDPwds") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::BuildDdPwds),
("InterfaceLib", "CTBGetCTBVersion") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::CtbGetCtbVersion),
("InterfaceLib", "CallComponentUPP") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::CallComponentUpp),
("InterfaceLib", "DIBadMount") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::DiBadMount),
("InterfaceLib", "DILoad") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::DiLoad),
("InterfaceLib", "DIUnload") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::DiUnload),
("InterfaceLib", "Debugger") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::Debugger),
("InterfaceLib", "Dequeue") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::Dequeue),
("InterfaceLib", "Enqueue") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::Enqueue),
("InterfaceLib", "FindNextComponent") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::FindNextComponent),
("InterfaceLib", "GetNextProcess") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::GetNextProcess),
("InterfaceLib", "GetScript") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::GetScript),
("InterfaceLib", "GetScriptManagerVariable") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::GetScriptManagerVariable),
("InterfaceLib", "GetScriptVariable") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::GetScriptVariable),
("InterfaceLib", "GetSysBeepVolume") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::GetSysBeepVolume),
("InterfaceLib", "IUCompString") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::IuCompString),
("InterfaceLib", "IUDateString") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::IuDateString),
("InterfaceLib", "InitCRM") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::InitCrm),
("InterfaceLib", "InitCTBUtilities") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::InitCtbUtilities),
("InterfaceLib", "KeyTranslate") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::KeyTranslate),
("InterfaceLib", "LMGetCurApName") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::LmGetCurApName),
("InterfaceLib", "LMGetSFSaveDisk") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::LmGetSfSaveDisk),
("InterfaceLib", "LMGetSysFontFam") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::LmGetSysFontFam),
("InterfaceLib", "LMGetSysFontSize") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::LmGetSysFontSize),
("InterfaceLib", "LaunchApplication") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::LaunchApplication),
("InterfaceLib", "MIDIAddPort") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::MidiAddPort),
("InterfaceLib", "MIDIRemovePort") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::MidiRemovePort),
("InterfaceLib", "MIDISignOut") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::MidiSignOut),
("InterfaceLib", "MIDIWritePacket") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::MidiWritePacket),
("InterfaceLib", "Munger") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::Munger),
("InterfaceLib", "NMRemove") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::NmRemove),
("InterfaceLib", "ObscureCursor") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::ObscureCursor),
("InterfaceLib", "OpenDefaultComponent") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::OpenDefaultComponent),
("InterfaceLib", "ResetAlertStage") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::ResetAlertStage),
("InterfaceLib", "SetFrontProcess") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::SetFrontProcess),
("InterfaceLib", "StyledLineBreak") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::StyledLineBreak),
("InterfaceLib", "SystemEdit") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::SystemEdit),
("InterfaceLib", "TruncText") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::TruncText),
("InterfaceLib", "UpperString") => PpcImportDispatcherTarget::SystemCompatibility(PpcSystemCompatibilityOperation::UpperString),
("InterfaceLib", "OpenDF") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::OpenDf),
("InterfaceLib", "OpenRF") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::OpenRf),
("InterfaceLib", "PBCatSearchSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbCatSearchSync),
("InterfaceLib", "PBCloseWDSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbCloseWdSync),
("InterfaceLib", "PBDirCreateSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbDirCreateSync),
("InterfaceLib", "PBGetFPosSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbGetFPosSync),
("InterfaceLib", "PBGetWDInfoSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbGetWdInfoSync),
("InterfaceLib", "PBHGetVolParmsSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbHGetVolParmsSync),
("InterfaceLib", "PBHGetVolSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbHGetVolSync),
("InterfaceLib", "PBHOpenRFSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbHOpenRfSync),
("InterfaceLib", "PBHSetVolSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbHSetVolSync),
("InterfaceLib", "PBOpenWDSync") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::PbOpenWdSync),
("InterfaceLib", "create") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::Create),
("InterfaceLib", "fsopen") => PpcImportDispatcherTarget::FileCompatibility(PpcFileCompatibilityOperation::FsOpen),
("InterfaceLib", "GetBridgeAddress") => {
PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::GetBridgeAddress,
)
}
("InterfaceLib", "GetNodeAddress") => {
PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::GetNodeAddress,
)
}
("InterfaceLib", "GetZoneList") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::GetZoneList,
),
("InterfaceLib", "MPPOpen") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::MppOpen,
),
("InterfaceLib", "NBPExtract") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::NbpExtract,
),
("InterfaceLib", "NBPSetEntity") => {
PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::NbpSetEntity,
)
}
("InterfaceLib", "NBPSetNTE") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::NbpSetNte,
),
("InterfaceLib", "PCloseSkt") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::PCloseSkt,
),
("InterfaceLib", "PKillNBP") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::PKillNbp,
),
("InterfaceLib", "PLookupName") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::PLookupName,
),
("InterfaceLib", "POpenSkt") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::POpenSkt,
),
("InterfaceLib", "PRegisterName") => {
PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::PRegisterName,
)
}
("InterfaceLib", "PRemoveName") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::PRemoveName,
),
("InterfaceLib", "PSetSelfSend") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::PSetSelfSend,
),
("InterfaceLib", "PWriteDDP") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::PWriteDdp,
),
("InterfaceLib", "StandardNBP") => PpcImportDispatcherTarget::AppleTalkCompatibility(
PpcAppleTalkCompatibilityOperation::StandardNbp,
),
("InterfaceLib", "PrClose") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrClose,
),
("InterfaceLib", "PrCloseDoc") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrCloseDoc,
),
("InterfaceLib", "PrClosePage") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrClosePage,
),
("InterfaceLib", "PrError") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrError,
),
("InterfaceLib", "PrJobDialog") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrJobDialog,
),
("InterfaceLib", "PrOpen") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrOpen,
),
("InterfaceLib", "PrOpenDoc") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrOpenDoc,
),
("InterfaceLib", "PrOpenPage") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrOpenPage,
),
("InterfaceLib", "PrPicFile") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrPicFile,
),
("InterfaceLib", "PrStlDialog") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrStlDialog,
),
("InterfaceLib", "PrintDefault") => PpcImportDispatcherTarget::PrintingCompatibility(
PpcPrintingCompatibilityOperation::PrintDefault,
),
(
"InterfaceLib",
"SFindStruct" | "SGetBlock" | "SGetCString" | "SGetSRsrc" | "SGetTypeSRsrc"
| "SNextTypeSRsrc",
) => PpcImportDispatcherTarget::SlotCompatibility,
("InterfaceLib", "CustomGetFile") => PpcImportDispatcherTarget::StandardFileCompatibility(
PpcStandardFileOperation::CustomGetFile,
),
("InterfaceLib", "CustomPutFile") => PpcImportDispatcherTarget::StandardFileCompatibility(
PpcStandardFileOperation::CustomPutFile,
),
("InterfaceLib", "SFGetFile") => PpcImportDispatcherTarget::StandardFileCompatibility(
PpcStandardFileOperation::SfGetFile,
),
("InterfaceLib", "SFPGetFile") => PpcImportDispatcherTarget::StandardFileCompatibility(
PpcStandardFileOperation::SfpGetFile,
),
("InterfaceLib", "SFPPutFile") => PpcImportDispatcherTarget::StandardFileCompatibility(
PpcStandardFileOperation::SfpPutFile,
),
("InterfaceLib", "SFPutFile") => PpcImportDispatcherTarget::StandardFileCompatibility(
PpcStandardFileOperation::SfPutFile,
),
("InterfaceLib", "StandardPutFile") => {
PpcImportDispatcherTarget::StandardFileCompatibility(
PpcStandardFileOperation::StandardPutFile,
)
}
("InterfaceLib", "SPBCloseDevice") => {
PpcImportDispatcherTarget::SoundInputCompatibility(
PpcSoundInputCompatibilityOperation::CloseDevice,
)
}
("InterfaceLib", "SPBGetDeviceInfo") => {
PpcImportDispatcherTarget::SoundInputCompatibility(
PpcSoundInputCompatibilityOperation::GetDeviceInfo,
)
}
("InterfaceLib", "SPBOpenDevice") => {
PpcImportDispatcherTarget::SoundInputCompatibility(
PpcSoundInputCompatibilityOperation::OpenDevice,
)
}
("InterfaceLib", "SPBRecord") => PpcImportDispatcherTarget::SoundInputCompatibility(
PpcSoundInputCompatibilityOperation::Record,
),
("InterfaceLib", "SPBSetDeviceInfo") => {
PpcImportDispatcherTarget::SoundInputCompatibility(
PpcSoundInputCompatibilityOperation::SetDeviceInfo,
)
}
("InterfaceLib", "SPBStopRecording") => {
PpcImportDispatcherTarget::SoundInputCompatibility(
PpcSoundInputCompatibilityOperation::StopRecording,
)
}
("SpeechLib", "CountVoices") => PpcImportDispatcherTarget::SpeechCompatibility(
PpcSpeechCompatibilityOperation::CountVoices,
),
("SpeechLib", "DisposeSpeechChannel") => {
PpcImportDispatcherTarget::SpeechCompatibility(
PpcSpeechCompatibilityOperation::DisposeSpeechChannel,
)
}
("SpeechLib", "GetIndVoice") => PpcImportDispatcherTarget::SpeechCompatibility(
PpcSpeechCompatibilityOperation::GetIndVoice,
),
("SpeechLib", "GetVoiceDescription") => {
PpcImportDispatcherTarget::SpeechCompatibility(
PpcSpeechCompatibilityOperation::GetVoiceDescription,
)
}
("SpeechLib", "NewSpeechChannel") => {
PpcImportDispatcherTarget::SpeechCompatibility(
PpcSpeechCompatibilityOperation::NewSpeechChannel,
)
}
("SpeechLib", "SpeakString") => PpcImportDispatcherTarget::SpeechCompatibility(
PpcSpeechCompatibilityOperation::SpeakString,
),
("SpeechLib", "SpeakText") => PpcImportDispatcherTarget::SpeechCompatibility(
PpcSpeechCompatibilityOperation::SpeakText,
),
("SpeechLib", "SpeechBusy") => PpcImportDispatcherTarget::SpeechCompatibility(
PpcSpeechCompatibilityOperation::SpeechBusy,
),
("QuickTimeLib", "GetMovieTimeBase") => {
PpcImportDispatcherTarget::QuickTimeCompatibility(
PpcQuickTimeCompatibilityOperation::GetMovieTimeBase,
)
}
("QuickTimeLib", "GetMovieVolume") => {
PpcImportDispatcherTarget::QuickTimeCompatibility(
PpcQuickTimeCompatibilityOperation::GetMovieVolume,
)
}
("QuickTimeLib", "NewMovieFromDataFork") => {
PpcImportDispatcherTarget::QuickTimeCompatibility(
PpcQuickTimeCompatibilityOperation::NewMovieFromDataFork,
)
}
("QuickTimeLib", "PrerollMovie") => {
PpcImportDispatcherTarget::QuickTimeCompatibility(
PpcQuickTimeCompatibilityOperation::PrerollMovie,
)
}
("QuickTimeLib", "SetMovieVolume") => {
PpcImportDispatcherTarget::QuickTimeCompatibility(
PpcQuickTimeCompatibilityOperation::SetMovieVolume,
)
}
("QuickTimeLib", "SetTimeBaseFlags") => {
PpcImportDispatcherTarget::QuickTimeCompatibility(
PpcQuickTimeCompatibilityOperation::SetTimeBaseFlags,
)
}
("QuickTimeLib", "UpdateMovie") => {
PpcImportDispatcherTarget::QuickTimeCompatibility(
PpcQuickTimeCompatibilityOperation::UpdateMovie,
)
}
("InputSprocketLib", "ISpDevices_ActivateClass") => {
PpcImportDispatcherTarget::InputSprocketCompatibility(
PpcInputSprocketCompatibilityOperation::DevicesActivateClass,
)
}
("InputSprocketLib", "ISpElement_DisposeVirtual") => {
PpcImportDispatcherTarget::InputSprocketCompatibility(
PpcInputSprocketCompatibilityOperation::ElementDisposeVirtual,
)
}
("InputSprocketLib", "ISpElement_Flush") => {
PpcImportDispatcherTarget::InputSprocketCompatibility(
PpcInputSprocketCompatibilityOperation::ElementFlush,
)
}
("InputSprocketLib", "ISpElement_GetNextEvent") => {
PpcImportDispatcherTarget::InputSprocketCompatibility(
PpcInputSprocketCompatibilityOperation::ElementGetNextEvent,
)
}
("InputSprocketLib", "ISpTickle") => {
PpcImportDispatcherTarget::InputSprocketCompatibility(
PpcInputSprocketCompatibilityOperation::Tickle,
)
}
("MathLib", "dec2num") => PpcImportDispatcherTarget::MathCompatibility(
PpcMathCompatibilityOperation::Dec2Num,
),
("MathLib", "dec2str") => PpcImportDispatcherTarget::MathCompatibility(
PpcMathCompatibilityOperation::Dec2Str,
),
("MathLib", "feclearexcept") => PpcImportDispatcherTarget::MathCompatibility(
PpcMathCompatibilityOperation::FeClearExcept,
),
("MathLib", "fetestexcept") => PpcImportDispatcherTarget::MathCompatibility(
PpcMathCompatibilityOperation::FeTestExcept,
),
("MathLib", "floor") => PpcImportDispatcherTarget::MathCompatibility(
PpcMathCompatibilityOperation::Floor,
),
("MathLib", "modf") => PpcImportDispatcherTarget::MathCompatibility(
PpcMathCompatibilityOperation::Modf,
),
("MathLib", "num2dec") => PpcImportDispatcherTarget::MathCompatibility(
PpcMathCompatibilityOperation::Num2Dec,
),
("MathLib", "str2dec") => PpcImportDispatcherTarget::MathCompatibility(
PpcMathCompatibilityOperation::Str2Dec,
),
("StdCLib", "qsort") => PpcImportDispatcherTarget::StdCCompatibility(
PpcStdCCompatibilityOperation::Qsort,
),
("StdCLib", "signal") => PpcImportDispatcherTarget::StdCCompatibility(
PpcStdCCompatibilityOperation::Signal,
),
("StdCLib", "sscanf") => PpcImportDispatcherTarget::StdCCompatibility(
PpcStdCCompatibilityOperation::Sscanf,
),
("StdCLib", "strftime") => PpcImportDispatcherTarget::StdCCompatibility(
PpcStdCCompatibilityOperation::Strftime,
),
("StdCLib", "vsprintf") => PpcImportDispatcherTarget::StdCCompatibility(
PpcStdCCompatibilityOperation::Vsprintf,
),
("ObjectSupportLib", "CreateObjSpecifier") => {
PpcImportDispatcherTarget::ObjectSupportCompatibility
}
_ => PpcImportDispatcherTarget::Unsupported,
}
}
#[cfg(test)]
fn ppc_process_handle_state_bits(handle_states: &[PpcHandleStateRecord], handle: u32) -> u8 {
let state = handle_states.iter().find(|state| state.handle == handle);
let mut bits = 0u8;
if state.is_some_and(|state| state.locked) {
bits |= 0x80;
}
if state.is_none_or(|state| !state.no_purge) {
bits |= 0x40;
}
if state.is_some_and(|state| state.resource) {
bits |= 0x20;
}
bits
}
pub(super) fn ppc_apply_process_native_allocator(
memory_manager: &ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
) {
let Some(heap) = memory_manager.native_heap_state() else {
return;
};
*heap_cursor = heap.heap_cursor;
*last_mem_error = heap.last_mem_error;
// The zone's free-byte projection follows the guest-visible application
// boundary, while the native heap record retains the physical mapping
// ceiling for stack protection and loader validation. Inside Macintosh:
// Memory (1992), pp. 2-83--2-85.
let allocation_limit = memory_manager.native_allocation_limit(heap.heap_limit);
ppc_update_zone_free_bytes(memory, *heap_cursor, allocation_limit);
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_dispose_process_native_handle(
memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
_heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
handle: u32,
) -> bool {
let disposed = memory_manager
.dispose_native_handle(memory, handle)
.is_some();
ppc_apply_process_native_allocator(
memory_manager,
memory,
heap_cursor,
last_mem_error,
);
if disposed {
handles.retain(|record| record.handle != handle);
}
disposed
}
pub(super) fn ppc_apply_process_native_handle(
memory_manager: &ProcessNativeMemoryManager,
handles: &mut Vec<PpcHandleRecord>,
handle: u32,
) {
let Some(updated) = memory_manager.native_allocation(handle) else {
return;
};
if let Some(record) = handles.iter_mut().find(|record| record.handle == handle) {
*record = updated;
} else {
handles.push(updated);
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_apply_process_native_resource_handle(
memory_manager: &ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
handle: u32,
) {
if let Some(heap) = memory_manager.native_heap_state() {
*heap_cursor = heap.heap_cursor;
*last_mem_error = heap.last_mem_error;
let allocation_limit = memory_manager.native_allocation_limit(heap.heap_limit);
ppc_update_zone_free_bytes(memory, *heap_cursor, allocation_limit);
}
ppc_apply_process_native_handle(memory_manager, handles, handle);
}
struct PpcDispatchContext<'a> {
binding: &'a PpcImportBinding,
cpu: &'a mut PpcCpu,
memory: &'a mut PpcSectionMem,
process_memory_manager: &'a mut ProcessNativeMemoryManager,
heap_cursor: &'a mut u32,
heap_limit: u32,
native_heap_ceiling: u32,
last_mem_error: &'a mut i16,
tick_count: &'a mut u32,
cycles_per_tick: u32,
current_resource_refnum: &'a mut i16,
last_resource_error: &'a mut i16,
resource_policy: &'a SharedProcessResourcePolicy,
native_exception_handler: &'a Cell<u32>,
stdc_qsort_stack: &'a mut Vec<PpcQsortState>,
dialog_callback_stack: &'a mut Vec<PpcDialogCallbackState>,
apple_events: &'a mut PpcAppleEventState,
cfm_connections: &'a mut Vec<PpcCfmConnection>,
cfm_library_fragments: &'a mut Vec<PpcCfmLibraryFragment>,
next_cfm_connection_id: &'a mut u32,
import_run_state: &'a mut PpcImportRunState,
controls: &'a mut Vec<PpcControlRecord>,
aliases: &'a mut Vec<PpcAliasRecord>,
gworlds: &'a mut Vec<PpcGWorldRecord>,
gworld_pixel_states: &'a SharedProcessQuickDrawPixelStates,
window_list: &'a SharedProcessWindowList,
q3_objects: &'a mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &'a mut Vec<PpcQ3ObjectReferenceRecord>,
next_q3_object: &'a mut u32,
q3_error_state: &'a mut PpcQ3ErrorState,
q3_lifecycle: &'a mut PpcQ3LifecycleState,
q3_memory_storages: &'a mut Vec<PpcQ3MemoryStorageRecord>,
q3_files: &'a mut Vec<PpcQ3FileRecord>,
q3_group_memberships: &'a mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &'a mut Vec<PpcQ3FileGroupRecord>,
q3_views: &'a mut Vec<PpcQ3ViewStateRecord>,
q3_submissions: &'a mut Vec<PpcQ3SubmissionRecord>,
q3_view_transforms: &'a mut Vec<PpcQ3ViewTransformRecord>,
q3_submission_transforms: &'a mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &'a mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &'a mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &'a mut Vec<PpcQ3SubmissionLightRecord>,
q3_view_state_stack: &'a mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_completed_frames: &'a mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &'a mut Vec<PpcQ3RetainedFrameRecord>,
q3_state_only_completed_frame_batches: &'a mut Vec<PpcQ3StateOnlyCompletedFrameBatch>,
q3_fog_styles: &'a mut Vec<PpcQ3FogStyleRecord>,
q3_attributes: &'a mut Vec<PpcQ3AttributeRecord>,
q3_shader_uv_transforms: &'a mut Vec<PpcQ3ShaderUvTransformRecord>,
q3_shader_boundaries: &'a mut Vec<PpcQ3ShaderBoundaryRecord>,
q3_mipmap_textures: &'a mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &'a mut Vec<PpcQ3TextureShaderRecord>,
q3_renderer_preferences: &'a mut Vec<PpcQ3RendererPreferenceRecord>,
q3_draw_contexts: &'a mut Vec<PpcQ3DrawContextRecord>,
q3_trimeshes: &'a mut Vec<PpcQ3TriMeshRecord>,
q3_styles: &'a mut Vec<PpcQ3StyleRecord>,
q3_cameras: &'a mut Vec<PpcQ3CameraRecord>,
q3_lights: &'a mut Vec<PpcQ3LightRecord>,
input_sprocket: &'a mut PpcInputSprocketState,
input_sprocket_virtual_elements: &'a mut Vec<PpcInputSprocketVirtualElementRecord>,
toolbox_startup: &'a mut PpcToolboxStartupState,
quicktime: &'a mut PpcQuickTimeState,
sound: &'a mut PpcSoundState,
timer_tasks: &'a SharedProcessTimerTasks,
vbl_tasks: &'a SharedProcessVblTasks,
callback_scheduling: &'a SharedProcessCallbackScheduling,
files: &'a mut Vec<PpcFileRecord>,
writable_refnums: &'a mut HashSet<u16>,
vfs_files: &'a mut ProcessVfsFileRecords,
stdio_streams: &'a mut HashMap<u32, PpcStdioStreamRecord>,
deleted_vfs_file_paths: &'a mut Vec<String>,
resource_files: &'a mut Vec<PpcResourceFileRecord>,
vfs_resource_files: &'a mut ProcessVfsResourceFileRecords,
vfs_resources: &'a mut Vec<PpcVfsResourceRecord>,
next_file_ref_num: &'a mut i16,
current_gworld: &'a mut u32,
current_gdevice: &'a mut u32,
quickdraw_op_colors: &'a SharedProcessQuickDrawOpColors,
quickdraw_hilite_colors: &'a SharedProcessQuickDrawHiliteColors,
screen_clut: &'a mut [[u16; 3]; 256],
color_manager_clut: &'a mut [[u16; 3]; 256],
display_gamma: &'a SharedProcessDisplayGamma,
quickdraw_fore_color: &'a mut PpcRgbColor,
quickdraw_fore_indices: &'a mut HashMap<u32, u8>,
quickdraw_back_color: &'a mut PpcRgbColor,
quickdraw_pen_h: &'a mut i16,
quickdraw_pen_v: &'a mut i16,
quickdraw_text_mode: &'a mut i16,
quickdraw_text_size: &'a mut i16,
cursor_state: &'a SharedProcessCursorState,
vfs_volumes: &'a [PpcVfsVolumeRecord],
vfs_directories: &'a mut Vec<PpcVfsDirectory>,
next_vfs_dir_id: &'a mut u32,
default_dir_id: u32,
working_directories: &'a mut HashMap<i16, ProcessWorkingDirectory>,
next_working_directory_ref_num: &'a mut i16,
application_working_directory_ref_num: &'a mut i16,
launched_app_path: Option<&'a str>,
param_text: &'a SharedProcessDialogText,
scrap: &'a mut PpcScrapState,
list_manager: &'a mut ProcessListManagerState,
input: PpcInputSnapshot,
event_queue: &'a mut EventQueue,
draw_sprocket: &'a mut PpcDrawSprocketState,
}
fn dispatch_supported_import(context: PpcDispatchContext<'_>) -> Option<PpcImportAction> {
let PpcDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
native_heap_ceiling,
last_mem_error,
tick_count,
cycles_per_tick,
current_resource_refnum,
last_resource_error,
resource_policy,
native_exception_handler,
stdc_qsort_stack,
dialog_callback_stack,
apple_events,
cfm_connections,
cfm_library_fragments,
next_cfm_connection_id,
import_run_state,
controls,
aliases,
gworlds,
gworld_pixel_states,
window_list,
q3_objects,
q3_object_refs,
next_q3_object,
q3_error_state,
q3_lifecycle,
q3_memory_storages,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_state_only_completed_frame_batches,
q3_fog_styles,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_renderer_preferences,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
input_sprocket,
input_sprocket_virtual_elements,
toolbox_startup,
quicktime,
sound,
timer_tasks,
vbl_tasks,
callback_scheduling,
files,
writable_refnums,
vfs_files,
stdio_streams,
deleted_vfs_file_paths,
resource_files,
vfs_resource_files,
vfs_resources,
next_file_ref_num,
current_gworld,
current_gdevice,
quickdraw_op_colors,
quickdraw_hilite_colors,
screen_clut,
color_manager_clut,
display_gamma,
quickdraw_fore_color,
quickdraw_fore_indices,
quickdraw_back_color,
quickdraw_pen_h,
quickdraw_pen_v,
quickdraw_text_mode,
quickdraw_text_size,
cursor_state,
vfs_volumes,
vfs_directories,
next_vfs_dir_id,
default_dir_id,
working_directories,
next_working_directory_ref_num,
application_working_directory_ref_num,
launched_app_path,
param_text,
scrap,
list_manager,
input,
event_queue,
draw_sprocket,
} = context;
let _menu_root = (matches!(
binding.dispatcher_target,
PpcImportDispatcherTarget::MenuSelect | PpcImportDispatcherTarget::PopUpMenuSelect
))
.then(|| {
let call = match binding.dispatcher_target {
PpcImportDispatcherTarget::PopUpMenuSelect => ppc_popup_menu_call(cpu),
_ => ppc_menu_select_call(cpu, cpu.gpr[3]),
};
toolbox_startup.execution.enter_menu_call(call)
});
// The process registry is authoritative. Refresh the legacy vector
// booleans at each native boundary so rendering/debugging code that still
// reads them sees any classic-side transition before this import runs.
ppc_sync_gworld_pixel_state_mirrors(gworlds, gworld_pixel_states);
// Toolbox helpers use an import-scoped read view for guest ABI decoding.
// Allocation ownership remains in the process Memory Manager, and the
// next import observes its canonical records immediately.
let handles = &mut process_memory_manager.native_handle_records().to_vec();
if is_quickdraw_3d_library(&binding.library_name)
&& !matches!(
binding.dispatcher_target,
PpcImportDispatcherTarget::Q3ErrorGet
)
&& q3_error_state.clear_on_next_q3_call
{
q3_error_state.clear();
}
if let Some(action) = dispatch_qd3d::dispatch_q3_core_import(
dispatch_qd3d::PpcQ3CoreDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
q3_objects,
next_q3_object,
q3_error_state,
q3_lifecycle,
},
) {
return Some(action);
}
if let Some(action) = dispatch_qd3d::dispatch_q3_storage_file_import(
dispatch_qd3d::PpcQ3StorageFileDispatchContext {
target: &binding.dispatcher_target,
cpu,
process_memory_manager,
memory,
stores: PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
},
next_q3_object,
q3_error_state,
heap_cursor,
heap_limit,
last_mem_error,
vfs_directories,
vfs_files,
},
) {
return Some(action);
}
if let Some(action) = dispatch_qd3d::dispatch_q3_geometry_import(
dispatch_qd3d::PpcQ3GeometryDispatchContext {
target: &binding.dispatcher_target,
cpu,
process_memory_manager,
memory,
stores: PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
},
next_q3_object,
q3_error_state,
heap_cursor,
last_mem_error,
gworlds,
},
) {
return Some(action);
}
if let Some(action) = dispatch_qd3d::dispatch_q3_group_view_import(
dispatch_qd3d::PpcQ3GroupViewDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
stores: PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
},
next_q3_object,
q3_state_only_completed_frame_batches,
gworlds,
current_gworld: *current_gworld,
q3_error_state,
input_idle: input.is_idle(),
},
) {
return Some(action);
}
let mut current_menu_list = ppc_current_menu_list(memory);
if let Some(action) = dispatch_cfm::dispatch_cfm_import(dispatch_cfm::PpcCfmDispatchContext {
binding,
cpu,
guest_calls: &toolbox_startup.execution.calls(),
process_memory_manager,
memory,
heap_cursor,
heap_limit,
cfm_connections,
cfm_library_fragments,
next_cfm_connection_id,
import_run_state,
}) {
return Some(action);
}
if let Some(action) = dispatch_files::dispatch_file_import(
dispatch_files::PpcFileDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
last_mem_error,
handles,
aliases,
files,
writable_refnums,
vfs_files,
vfs_directories,
next_vfs_dir_id,
deleted_vfs_file_paths,
vfs_resource_files,
resource_files,
vfs_resources,
next_file_ref_num,
current_resource_refnum,
last_resource_error,
default_dir_id,
launched_app_path,
vfs_volumes,
working_directories,
next_working_directory_ref_num,
application_working_directory_ref_num,
},
) {
return Some(action);
}
if let Some(action) = dispatch_resources::dispatch_resource_import(
dispatch_resources::PpcResourceDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
resource_files,
vfs_resource_files,
vfs_resources,
current_resource_refnum,
resource_policy,
last_resource_error,
},
) {
return Some(action);
}
if let Some(action) = dispatch_stdc::dispatch_stdc_import(
dispatch_stdc::PpcStdCDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
last_mem_error,
stdc_qsort_stack,
stdc_signal_state: &mut toolbox_startup.stdc_signal_state,
},
) {
return Some(action);
}
if let Some(action) = dispatch_regions::dispatch_region_import(
dispatch_regions::PpcRegionDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
current_gworld: *current_gworld,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_polygons::dispatch_polygon_import(
dispatch_polygons::PpcPolygonDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
gworlds,
current_gworld: *current_gworld,
quickdraw_fore_color,
quickdraw_fore_indices,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_bit_transfers::dispatch_bit_transfer_import(
dispatch_bit_transfers::PpcBitTransferDispatchContext {
binding,
cpu,
memory,
gworlds,
window_list,
current_gworld: *current_gworld,
current_gdevice: *current_gdevice,
quickdraw_op_colors,
color_manager_clut,
quickdraw_fore_color: *quickdraw_fore_color,
quickdraw_fore_index: quickdraw_fore_indices.get(current_gworld).copied(),
quickdraw_back_color: *quickdraw_back_color,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_graphics_devices::dispatch_graphics_device_import(
dispatch_graphics_devices::PpcGraphicsDeviceDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
gworlds,
current_gdevice,
toolbox_startup,
screen_clut,
color_manager_clut,
},
) {
return Some(action);
}
if let Some(action) = dispatch_color_tables::dispatch_color_table_import(
dispatch_color_tables::PpcColorTableDispatchContext {
binding,
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
current_gworld,
quickdraw_hilite_colors,
tick_count,
current_gdevice,
screen_clut,
color_manager_clut,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_palettes::dispatch_palette_import(
dispatch_palettes::PpcPaletteDispatchContext {
binding,
cpu,
memory,
gworlds,
window_list,
current_gdevice: *current_gdevice,
screen_clut,
color_manager_clut,
toolbox_startup,
event_queue,
tick_count: *tick_count,
input,
},
) {
return Some(action);
}
if let Some(action) = dispatch_gworlds::dispatch_gworld_import(
dispatch_gworlds::PpcGWorldDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
gworlds,
gworld_pixel_states,
current_gworld,
current_gdevice,
quickdraw_op_colors,
quickdraw_hilite_colors,
quickdraw_fore_color,
quickdraw_fore_indices,
quickdraw_back_color,
quickdraw_pen_h,
quickdraw_pen_v,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_quickdraw::dispatch_quickdraw_import(
dispatch_quickdraw::PpcQuickDrawDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
last_mem_error,
handles,
gworlds,
tick_count: *tick_count,
current_gworld: *current_gworld,
current_gdevice: *current_gdevice,
quickdraw_op_colors,
quickdraw_hilite_colors,
screen_clut,
color_manager_clut,
quickdraw_fore_color,
quickdraw_fore_indices,
quickdraw_back_color,
quickdraw_pen_h,
quickdraw_pen_v,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_picture::dispatch_picture_import(
dispatch_picture::PpcPictureDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
gworlds,
current_gworld: *current_gworld,
screen_clut,
color_manager_clut,
},
) {
return Some(action);
}
if let Some(action) = dispatch_fonts::dispatch_font_import(
dispatch_fonts::PpcFontDispatchContext {
binding,
cpu,
memory,
toolbox_startup,
gworlds,
current_gworld: *current_gworld,
quickdraw_text_mode,
quickdraw_text_size,
quickdraw_fore_color,
quickdraw_fore_indices,
quickdraw_pen_h,
quickdraw_pen_v,
vfs_resources,
},
) {
return Some(action);
}
if let Some(action) = dispatch_sound::dispatch_sound_import(
dispatch_sound::PpcSoundDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
last_mem_error,
current_resource_refnum: *current_resource_refnum,
handles,
files,
vfs_files,
vfs_resources,
sound,
},
) {
return Some(action);
}
if let Some(action) = dispatch_event::dispatch_time_import(
dispatch_event::PpcTimeDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
tick_count: *tick_count,
cycles_per_tick,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_event::dispatch_event_import(
dispatch_event::PpcEventDispatchContext {
binding,
cpu,
memory,
handles,
gworlds,
current_gworld: *current_gworld,
current_menu_list,
screen_clut,
toolbox_startup,
apple_events,
event_queue,
input,
tick_count: *tick_count,
},
) {
return Some(action);
}
if let Some(action) = dispatch_low_memory::dispatch_low_memory_import(
dispatch_low_memory::PpcLowMemoryDispatchContext {
target: &binding.dispatcher_target,
cpu,
memory,
current_menu_list,
default_dir_id,
},
) {
return Some(action);
}
if let Some(action) =
dispatch_math::dispatch_math_import(&binding.dispatcher_target, cpu, memory)
{
return Some(action);
}
if let Some(action) = dispatch_toolbox::dispatch_toolbox_import(
dispatch_toolbox::PpcToolboxDispatchContext {
binding,
cpu,
memory,
},
) {
return Some(action);
}
if let Some(action) = dispatch_memory::dispatch_memory_import(
dispatch_memory::PpcMemoryDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
native_heap_ceiling,
last_mem_error,
handles,
aliases,
vfs_resources,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_menu::dispatch_menu_import(
dispatch_menu::PpcMenuDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
last_resource_error,
handles,
vfs_resources,
current_resource_refnum: *current_resource_refnum,
resource_policy,
toolbox_startup,
current_menu_list: &mut current_menu_list,
gworlds,
screen_clut,
current_gworld,
current_gdevice,
event_queue,
input,
},
) {
return Some(action);
}
if let Some(action) = dispatch_threads::dispatch_thread_import(
dispatch_threads::PpcThreadDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_textedit::dispatch_textedit_import(
dispatch_textedit::PpcTextEditDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
toolbox_startup,
current_gworld: *current_gworld,
tick_count: *tick_count,
quickdraw_text_mode: *quickdraw_text_mode,
quickdraw_text_size: *quickdraw_text_size,
quickdraw_fore_color,
quickdraw_back_color,
quickdraw_fore_indices,
scrap,
gworlds,
input,
event_queue,
},
) {
return Some(action);
}
if let Some(action) = dispatch_drawsprocket::dispatch_drawsprocket_import(
dispatch_drawsprocket::PpcDrawSprocketDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
gworlds,
gworld_allocations: &mut toolbox_startup.gworld_allocations,
current_gdevice: *current_gdevice,
draw_sprocket,
input,
screen_clut,
},
) {
return Some(action);
}
if let Some(action) = dispatch_inputsprocket::dispatch_inputsprocket_import(
dispatch_inputsprocket::PpcInputSprocketDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
input_sprocket,
input_sprocket_virtual_elements,
input,
tick_count: *tick_count,
},
) {
return Some(action);
}
if let Some(action) = dispatch_quicktime::dispatch_quicktime_import(
dispatch_quicktime::PpcQuickTimeDispatchContext {
binding,
cpu,
memory,
vfs_directories,
vfs_files,
vfs_resource_files,
vfs_resources,
gworlds,
current_gworld: *current_gworld,
quicktime,
sound,
},
) {
return Some(action);
}
if let Some(action) = dispatch_time::dispatch_time_import(
dispatch_time::PpcTimeDispatchContext {
binding,
cpu,
memory,
timer_tasks,
vbl_tasks,
callback_scheduling,
tick_count: *tick_count,
},
) {
return Some(action);
}
if let Some(action) = dispatch_standard_file::dispatch_standard_file_import(
dispatch_standard_file::PpcStandardFileDispatchContext {
binding,
cpu,
memory,
startup: toolbox_startup,
process_memory_manager,
heap_cursor,
last_mem_error,
gworlds,
vfs_directories,
vfs_files,
vfs_resource_files,
vfs_volumes,
default_dir_id,
working_directories,
next_working_directory_ref_num,
event_queue,
},
) {
return Some(action);
}
if let Some(action) = dispatch_control::dispatch_control_import(
dispatch_control::PpcControlDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
controls,
gworlds,
screen_clut,
current_gworld: *current_gworld,
toolbox_startup,
input,
vfs_resources,
current_resource_refnum: *current_resource_refnum,
last_resource_error,
},
) {
return Some(action);
}
if let Some(action) = dispatch_list::dispatch_list_import(
dispatch_list::PpcListDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
controls,
list_manager,
gworlds,
vfs_resources,
current_resource_refnum: *current_resource_refnum,
tick_count: *tick_count,
},
) {
return Some(action);
}
if let Some(action) = dispatch_dialog::dispatch_dialog_import(
dispatch_dialog::PpcDialogDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
controls,
gworlds,
screen_clut,
color_manager_clut,
current_gworld,
current_gdevice,
window_list,
toolbox_startup,
event_queue,
dialog_callback_stack,
vfs_resources,
current_resource_refnum: *current_resource_refnum,
last_resource_error,
param_text,
tick_count: *tick_count,
input,
quickdraw_text_mode: *quickdraw_text_mode,
quickdraw_text_size: *quickdraw_text_size,
quickdraw_fore_color,
quickdraw_back_color,
quickdraw_fore_indices,
},
) {
return Some(action);
}
if let Some(action) = dispatch_window::dispatch_window_import(
dispatch_window::PpcWindowDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
controls,
gworlds,
window_list,
current_gworld,
current_gdevice,
quickdraw_fore_color,
quickdraw_fore_indices,
quickdraw_back_color,
screen_clut,
color_manager_clut,
toolbox_startup,
input,
tick_count: *tick_count,
event_queue,
vfs_resources,
current_resource_refnum: *current_resource_refnum,
last_resource_error,
},
) {
return Some(action);
}
if let Some(action) = dispatch_display::dispatch_display_import(
dispatch_display::PpcDisplayDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
gworlds,
toolbox_startup,
screen_clut,
color_manager_clut,
},
) {
return Some(action);
}
if let Some(action) = dispatch_devices::dispatch_device_import(
dispatch_devices::PpcDeviceDispatchContext {
binding,
cpu,
memory,
current_gdevice: *current_gdevice,
screen_clut,
display_gamma,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_desk::dispatch_desk_import(
dispatch_desk::PpcDeskDispatchContext { binding },
) {
return Some(action);
}
if let Some(action) = dispatch_gestalt::dispatch_gestalt_import(
dispatch_gestalt::PpcGestaltDispatchContext {
binding,
cpu,
memory,
},
) {
return Some(action);
}
if let Some(action) = dispatch_cursor::dispatch_cursor_import(
dispatch_cursor::PpcCursorDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum: *current_resource_refnum,
last_resource_error,
cursor_state,
gworlds,
current_gworld: *current_gworld,
screen_clut,
},
) {
return Some(action);
}
if let Some(action) = dispatch_apple_events::dispatch_apple_event_import(
dispatch_apple_events::PpcAppleEventDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
apple_events,
toolbox_startup,
},
) {
return Some(action);
}
if let Some(action) = dispatch_process::dispatch_process_import(
dispatch_process::PpcProcessDispatchContext {
binding,
cpu,
memory,
vfs_directories,
vfs_files,
vfs_resource_files,
launched_app_path,
},
) {
return Some(action);
}
if let Some(action) = dispatch_scrap::dispatch_scrap_import(
dispatch_scrap::PpcScrapDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
scrap,
},
) {
return Some(action);
}
if let Some(action) = dispatch_mixed_mode::dispatch_mixed_mode_import(
dispatch_mixed_mode::PpcMixedModeDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
toolbox_startup,
cfm_connections,
next_cfm_connection_id,
import_run_state,
},
) {
return action;
}
if let Some(action) = dispatch_native_exceptions::dispatch_native_exception_import(
dispatch_native_exceptions::PpcNativeExceptionDispatchContext {
binding,
cpu,
native_exception_handler,
},
) {
return Some(action);
}
match binding.dispatcher_target {
PpcImportDispatcherTarget::InstallExceptionHandler => {
unreachable!(
"native exception imports return through dispatch_native_exception_import"
)
}
PpcImportDispatcherTarget::NewPtr { .. }
| PpcImportDispatcherTarget::DisposePtr
| PpcImportDispatcherTarget::GetPtrSize
| PpcImportDispatcherTarget::SetPtrSize
| PpcImportDispatcherTarget::RecoverHandle
| PpcImportDispatcherTarget::BlockMove
| PpcImportDispatcherTarget::PtrToHand
| PpcImportDispatcherTarget::HandToHand
| PpcImportDispatcherTarget::HandAndHand
| PpcImportDispatcherTarget::NewHandle { .. }
| PpcImportDispatcherTarget::TempNewHandle
| PpcImportDispatcherTarget::DisposeHandle
| PpcImportDispatcherTarget::EmptyHandle
| PpcImportDispatcherTarget::GetHandleSize
| PpcImportDispatcherTarget::SetHandleSize
| PpcImportDispatcherTarget::HLock
| PpcImportDispatcherTarget::HLockHi
| PpcImportDispatcherTarget::HGetState
| PpcImportDispatcherTarget::HSetState
| PpcImportDispatcherTarget::HUnlock
| PpcImportDispatcherTarget::MoveHHi
| PpcImportDispatcherTarget::HNoPurge
| PpcImportDispatcherTarget::HPurge
| PpcImportDispatcherTarget::GetZone
| PpcImportDispatcherTarget::SetZone
| PpcImportDispatcherTarget::InitZone
| PpcImportDispatcherTarget::SystemZone
| PpcImportDispatcherTarget::ApplicationZone
| PpcImportDispatcherTarget::MaxApplZone
| PpcImportDispatcherTarget::MoreMasters
| PpcImportDispatcherTarget::GetApplLimit
| PpcImportDispatcherTarget::SetApplLimit
| PpcImportDispatcherTarget::HeapFreeBytes
| PpcImportDispatcherTarget::MaxMem
| PpcImportDispatcherTarget::PurgeMem
| PpcImportDispatcherTarget::PurgeMemSys
| PpcImportDispatcherTarget::MemError => {
unreachable!("memory imports return through dispatch_memory_import")
}
PpcImportDispatcherTarget::InitMenus
| PpcImportDispatcherTarget::NewMenu
| PpcImportDispatcherTarget::DisposeMenu
| PpcImportDispatcherTarget::GetMenu
| PpcImportDispatcherTarget::GetItemCmd
| PpcImportDispatcherTarget::SetItemCmd
| PpcImportDispatcherTarget::GetItemMark
| PpcImportDispatcherTarget::CountMItems
| PpcImportDispatcherTarget::GetMenuItemText
| PpcImportDispatcherTarget::SetMenuItemText
| PpcImportDispatcherTarget::DeleteMenuItem
| PpcImportDispatcherTarget::CalcMenuSize
| PpcImportDispatcherTarget::PopUpMenuSelect
| PpcImportDispatcherTarget::InsertMenu
| PpcImportDispatcherTarget::DeleteMenu
| PpcImportDispatcherTarget::AppendMenu
| PpcImportDispatcherTarget::InsertMenuItem
| PpcImportDispatcherTarget::AppendResMenu
| PpcImportDispatcherTarget::InsertResMenu
| PpcImportDispatcherTarget::EnableMenuItem
| PpcImportDispatcherTarget::DisableMenuItem
| PpcImportDispatcherTarget::SetItemMark
| PpcImportDispatcherTarget::CheckItem
| PpcImportDispatcherTarget::GetMenuBar
| PpcImportDispatcherTarget::GetNewMBar
| PpcImportDispatcherTarget::ClearMenuBar
| PpcImportDispatcherTarget::SetMenuBar
| PpcImportDispatcherTarget::GetMenuHandle
| PpcImportDispatcherTarget::DrawMenuBar
| PpcImportDispatcherTarget::InvalMenuBar
| PpcImportDispatcherTarget::FlashMenuBar
| PpcImportDispatcherTarget::HMGetHelpMenuHandle
| PpcImportDispatcherTarget::HiliteMenu
| PpcImportDispatcherTarget::MenuNoop
| PpcImportDispatcherTarget::MenuKey
| PpcImportDispatcherTarget::MenuEvent
| PpcImportDispatcherTarget::MenuChoice
| PpcImportDispatcherTarget::GetMBarHeight
| PpcImportDispatcherTarget::SetMBarHeight
| PpcImportDispatcherTarget::MenuSelect => {
unreachable!("menu imports return through dispatch_menu_import")
}
PpcImportDispatcherTarget::GetCurrentThread
| PpcImportDispatcherTarget::GetThreadState
| PpcImportDispatcherTarget::GetThreadCurrentTaskRef
| PpcImportDispatcherTarget::GetThreadStateGivenTaskRef
| PpcImportDispatcherTarget::SetThreadReadyGivenTaskRef
| PpcImportDispatcherTarget::SetThreadState
| PpcImportDispatcherTarget::SetThreadStateEndCritical
| PpcImportDispatcherTarget::CreateThreadPool
| PpcImportDispatcherTarget::GetFreeThreadCount
| PpcImportDispatcherTarget::GetSpecificFreeThreadCount
| PpcImportDispatcherTarget::GetDefaultThreadStackSize
| PpcImportDispatcherTarget::ThreadCurrentStackSpace
| PpcImportDispatcherTarget::NewThread
| PpcImportDispatcherTarget::YieldToThread
| PpcImportDispatcherTarget::YieldToAnyThread
| PpcImportDispatcherTarget::DisposeThread
| PpcImportDispatcherTarget::ThreadBeginCritical
| PpcImportDispatcherTarget::ThreadEndCritical => {
unreachable!("thread imports return through dispatch_thread_import")
}
PpcImportDispatcherTarget::TEInit
| PpcImportDispatcherTarget::TENew
| PpcImportDispatcherTarget::TEStyleNew
| PpcImportDispatcherTarget::TESetStyle
| PpcImportDispatcherTarget::TEUseStyleScrap
| PpcImportDispatcherTarget::TEContinuousStyle
| PpcImportDispatcherTarget::TEGetText
| PpcImportDispatcherTarget::TEDispose
| PpcImportDispatcherTarget::TEActivate { .. }
| PpcImportDispatcherTarget::TESetSelect
| PpcImportDispatcherTarget::TESetText
| PpcImportDispatcherTarget::TECalText
| PpcImportDispatcherTarget::TEInsert { .. }
| PpcImportDispatcherTarget::TEDelete
| PpcImportDispatcherTarget::TEKey
| PpcImportDispatcherTarget::TEClick
| PpcImportDispatcherTarget::TEIdle
| PpcImportDispatcherTarget::TEUpdate
| PpcImportDispatcherTarget::TETextBox
| PpcImportDispatcherTarget::TESetAlignment
| PpcImportDispatcherTarget::TEGetHeight
| PpcImportDispatcherTarget::TEGetPoint
| PpcImportDispatcherTarget::TEScroll { .. }
| PpcImportDispatcherTarget::TEAutoView
| PpcImportDispatcherTarget::TECopy { .. }
| PpcImportDispatcherTarget::TEPaste { .. }
| PpcImportDispatcherTarget::TETransferScrap { .. }
| PpcImportDispatcherTarget::TEScrapHandle
| PpcImportDispatcherTarget::TEScrapLength { .. } => {
unreachable!("textedit imports return through dispatch_textedit_import")
}
PpcImportDispatcherTarget::DSpStartup
| PpcImportDispatcherTarget::DSpShutdown
| PpcImportDispatcherTarget::DSpGetFirstContext
| PpcImportDispatcherTarget::DSpGetNextContext
| PpcImportDispatcherTarget::DSpProcessEvent
| PpcImportDispatcherTarget::DSpCanUserSelectContext
| PpcImportDispatcherTarget::DSpGetMouse
| PpcImportDispatcherTarget::DSpFindContextFromPoint
| PpcImportDispatcherTarget::DSpContextGlobalToLocal
| PpcImportDispatcherTarget::DSpFindBestContext
| PpcImportDispatcherTarget::DSpUserSelectContext
| PpcImportDispatcherTarget::DSpSetBlankingColor
| PpcImportDispatcherTarget::DSpAltBufferNew
| PpcImportDispatcherTarget::DSpAltBufferGetCGrafPtr
| PpcImportDispatcherTarget::DSpContextReserve
| PpcImportDispatcherTarget::DSpContextRelease
| PpcImportDispatcherTarget::DSpContextSetState
| PpcImportDispatcherTarget::DSpContextFadeGamma
| PpcImportDispatcherTarget::DSpContextFadeGammaIn
| PpcImportDispatcherTarget::DSpContextFadeGammaOut
| PpcImportDispatcherTarget::DSpContextGetFrontBuffer
| PpcImportDispatcherTarget::DSpContextGetBackBuffer
| PpcImportDispatcherTarget::DSpContextSwapBuffers
| PpcImportDispatcherTarget::DSpContextSetClutEntries
| PpcImportDispatcherTarget::DSpContextGetDisplayID
| PpcImportDispatcherTarget::DSpContextGetAttributes
| PpcImportDispatcherTarget::DSpContextSetVblProc
| PpcImportDispatcherTarget::DSpContextIsBusy
| PpcImportDispatcherTarget::DSpAltBufferDispose
| PpcImportDispatcherTarget::DSpContextInvalBackBufferRect
| PpcImportDispatcherTarget::DSpContextSetUnderlayAltBuffer => {
unreachable!("drawsprocket imports return through dispatch_drawsprocket_import")
}
PpcImportDispatcherTarget::ISpElementNewVirtualFromNeeds
| PpcImportDispatcherTarget::ISpElementListNew
| PpcImportDispatcherTarget::ISpElementListAddElements
| PpcImportDispatcherTarget::ISpElementListGetNextEvent
| PpcImportDispatcherTarget::ISpElementListFlush
| PpcImportDispatcherTarget::ISpDevicesExtract
| PpcImportDispatcherTarget::ISpDevicesExtractByClass
| PpcImportDispatcherTarget::ISpDeviceGetDefinition
| PpcImportDispatcherTarget::ISpDeviceGetElementList
| PpcImportDispatcherTarget::ISpElementListExtract
| PpcImportDispatcherTarget::ISpElementGetInfo
| PpcImportDispatcherTarget::ISpElementGetSimpleState
| PpcImportDispatcherTarget::ISpGetVersion
| PpcImportDispatcherTarget::ISpStartup
| PpcImportDispatcherTarget::ISpShutdown
| PpcImportDispatcherTarget::ISpInit
| PpcImportDispatcherTarget::ISpStop
| PpcImportDispatcherTarget::ISpSuspend
| PpcImportDispatcherTarget::ISpResume
| PpcImportDispatcherTarget::ISpDevicesActivate
| PpcImportDispatcherTarget::ISpDevicesDeactivate
| PpcImportDispatcherTarget::ISpConfigure => {
unreachable!("inputsprocket imports return through dispatch_inputsprocket_import")
}
PpcImportDispatcherTarget::QtEnterMovies
| PpcImportDispatcherTarget::QtExitMovies
| PpcImportDispatcherTarget::QtGetMoviesError
| PpcImportDispatcherTarget::QtGetMoviesStickyError
| PpcImportDispatcherTarget::QtClearMoviesStickyError
| PpcImportDispatcherTarget::QtGetGraphicsImporterForFile
| PpcImportDispatcherTarget::QtGraphicsImportGetBoundsRect
| PpcImportDispatcherTarget::QtGraphicsImportSetGWorld
| PpcImportDispatcherTarget::QtGraphicsImportDraw
| PpcImportDispatcherTarget::QtOpenMovieFile
| PpcImportDispatcherTarget::QtNewMovieFromFile
| PpcImportDispatcherTarget::QtGetMovieBox
| PpcImportDispatcherTarget::QtSetMovieBox
| PpcImportDispatcherTarget::QtSetMovieGWorld
| PpcImportDispatcherTarget::QtStartMovie
| PpcImportDispatcherTarget::QtStopMovie
| PpcImportDispatcherTarget::QtMoviesTask
| PpcImportDispatcherTarget::QtDisposeMovie
| PpcImportDispatcherTarget::QtIsMovieDone
| PpcImportDispatcherTarget::QtGoToBeginningOfMovie
| PpcImportDispatcherTarget::QtGoToEndOfMovie
| PpcImportDispatcherTarget::QtGetMovieDuration
| PpcImportDispatcherTarget::QtLoadMovieIntoRam
| PpcImportDispatcherTarget::QtCloseMovieFile => {
unreachable!("quicktime imports return through dispatch_quicktime_import")
}
PpcImportDispatcherTarget::InsTime
| PpcImportDispatcherTarget::InsXTime
| PpcImportDispatcherTarget::PrimeTime
| PpcImportDispatcherTarget::RmvTime
| PpcImportDispatcherTarget::VInstall
| PpcImportDispatcherTarget::VRemove
| PpcImportDispatcherTarget::SlotVInstall
| PpcImportDispatcherTarget::SlotVRemove => {
unreachable!("time and vbl imports return through dispatch_time_import")
}
PpcImportDispatcherTarget::DrawGrowIcon => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::GetPictInfo
| PpcImportDispatcherTarget::DrawPicture
| PpcImportDispatcherTarget::KillPicture => {
unreachable!("picture imports return through dispatch_picture_import")
}
PpcImportDispatcherTarget::InitCursor
| PpcImportDispatcherTarget::HideCursor
| PpcImportDispatcherTarget::ShowCursor
| PpcImportDispatcherTarget::ShieldCursor
| PpcImportDispatcherTarget::CrsrDevNextDevice
| PpcImportDispatcherTarget::CrsrDevMoveTo
| PpcImportDispatcherTarget::GetCursor
| PpcImportDispatcherTarget::SetCursor
| PpcImportDispatcherTarget::GetCCursor
| PpcImportDispatcherTarget::SetCCursor
| PpcImportDispatcherTarget::DisposeCCursor
| PpcImportDispatcherTarget::GetCIcon
| PpcImportDispatcherTarget::PlotCIcon
| PpcImportDispatcherTarget::DisposeCIcon => {
unreachable!("cursor and cicon imports return through dispatch_cursor_import")
}
PpcImportDispatcherTarget::FSClose
| PpcImportDispatcherTarget::PBClose
| PpcImportDispatcherTarget::PBFlushFile
| PpcImportDispatcherTarget::FSRead
| PpcImportDispatcherTarget::PBRead
| PpcImportDispatcherTarget::FSWrite
| PpcImportDispatcherTarget::PBWrite
| PpcImportDispatcherTarget::GetEOF
| PpcImportDispatcherTarget::PBGetEOF
| PpcImportDispatcherTarget::SetEOF
| PpcImportDispatcherTarget::AllocContig
| PpcImportDispatcherTarget::PBSetEOF
| PpcImportDispatcherTarget::GetFPos
| PpcImportDispatcherTarget::SetFPos
| PpcImportDispatcherTarget::PBSetFPos
| PpcImportDispatcherTarget::PBCreate(_)
| PpcImportDispatcherTarget::FSpCreate
| PpcImportDispatcherTarget::HCreate
| PpcImportDispatcherTarget::Create
| PpcImportDispatcherTarget::FSpDelete
| PpcImportDispatcherTarget::DeleteByName(_)
| PpcImportDispatcherTarget::FSOpen
| PpcImportDispatcherTarget::FSpCreateResFile
| PpcImportDispatcherTarget::HCreateResFile
| PpcImportDispatcherTarget::FSpOpenResFile
| PpcImportDispatcherTarget::FSpOpenDF
| PpcImportDispatcherTarget::HOpen
| PpcImportDispatcherTarget::PBHOpenDF
| PpcImportDispatcherTarget::CurResFile
| PpcImportDispatcherTarget::UseResFile
| PpcImportDispatcherTarget::OpenResFile
| PpcImportDispatcherTarget::HOpenResFile
| PpcImportDispatcherTarget::ResError
| PpcImportDispatcherTarget::GetVol
| PpcImportDispatcherTarget::GetWDInfo
| PpcImportDispatcherTarget::HGetVol
| PpcImportDispatcherTarget::HSetVol
| PpcImportDispatcherTarget::FlushVol
| PpcImportDispatcherTarget::PBFlushVol
| PpcImportDispatcherTarget::PBHGetVInfo
| PpcImportDispatcherTarget::PBGetFInfo
| PpcImportDispatcherTarget::PBHGetFInfo
| PpcImportDispatcherTarget::PBSetFInfo
| PpcImportDispatcherTarget::PBHSetFInfo
| PpcImportDispatcherTarget::FSpGetFInfo
| PpcImportDispatcherTarget::GetFInfo
| PpcImportDispatcherTarget::HGetFInfo
| PpcImportDispatcherTarget::FSpSetFInfo
| PpcImportDispatcherTarget::HSetFInfo
| PpcImportDispatcherTarget::PBGetCatInfo
| PpcImportDispatcherTarget::PBSetCatInfo
| PpcImportDispatcherTarget::DirCreate
| PpcImportDispatcherTarget::FSpDirCreate
| PpcImportDispatcherTarget::FSMakeFSSpec
| PpcImportDispatcherTarget::PBGetFCBInfo
| PpcImportDispatcherTarget::FindFolder
| PpcImportDispatcherTarget::ResolveAliasFile
| PpcImportDispatcherTarget::ResolveAlias
| PpcImportDispatcherTarget::UpdateAlias
| PpcImportDispatcherTarget::NewAlias
| PpcImportDispatcherTarget::FileCompatibility(_) => {
unreachable!("file imports return through dispatch_file_import")
}
PpcImportDispatcherTarget::SetResLoad
| PpcImportDispatcherTarget::LoadResource
| PpcImportDispatcherTarget::GetResource
| PpcImportDispatcherTarget::Get1Resource
| PpcImportDispatcherTarget::GetNamedResource
| PpcImportDispatcherTarget::Get1NamedResource
| PpcImportDispatcherTarget::GetIndResource
| PpcImportDispatcherTarget::Get1IndResource
| PpcImportDispatcherTarget::CountResources
| PpcImportDispatcherTarget::Count1Resources
| PpcImportDispatcherTarget::UniqueID
| PpcImportDispatcherTarget::Unique1ID
| PpcImportDispatcherTarget::ReleaseResource
| PpcImportDispatcherTarget::DetachResource
| PpcImportDispatcherTarget::GetIndString
| PpcImportDispatcherTarget::GetString
| PpcImportDispatcherTarget::GetResAttrs
| PpcImportDispatcherTarget::SetResAttrs
| PpcImportDispatcherTarget::GetResInfo
| PpcImportDispatcherTarget::GetResourceSizeOnDisk
| PpcImportDispatcherTarget::SetResInfo
| PpcImportDispatcherTarget::HomeResFile
| PpcImportDispatcherTarget::UpdateResFile
| PpcImportDispatcherTarget::AddResource
| PpcImportDispatcherTarget::ChangedResource
| PpcImportDispatcherTarget::WriteResource
| PpcImportDispatcherTarget::RemoveResource
| PpcImportDispatcherTarget::ReadPartialResource
| PpcImportDispatcherTarget::CloseResFile
| PpcImportDispatcherTarget::GetPicture
| PpcImportDispatcherTarget::GetIconSuite
| PpcImportDispatcherTarget::GetIcon
| PpcImportDispatcherTarget::GetPattern
| PpcImportDispatcherTarget::GetIndPattern
| PpcImportDispatcherTarget::GetPixPat
| PpcImportDispatcherTarget::GetIntlResource => {
unreachable!("resource imports return through dispatch_resource_import")
}
PpcImportDispatcherTarget::InitGraf
| PpcImportDispatcherTarget::GetForeColor
| PpcImportDispatcherTarget::GetBackColor
| PpcImportDispatcherTarget::ForeColor
| PpcImportDispatcherTarget::BackColor
| PpcImportDispatcherTarget::RGBForeColor
| PpcImportDispatcherTarget::RGBBackColor
| PpcImportDispatcherTarget::OpColor
| PpcImportDispatcherTarget::HiliteColor
| PpcImportDispatcherTarget::PmForeColor
| PpcImportDispatcherTarget::PmBackColor
| PpcImportDispatcherTarget::Color2Index
| PpcImportDispatcherTarget::Index2Color
| PpcImportDispatcherTarget::RGB2HSL
| PpcImportDispatcherTarget::RGB2HSV
| PpcImportDispatcherTarget::HSV2RGB
| PpcImportDispatcherTarget::SetRect
| PpcImportDispatcherTarget::SectRect
| PpcImportDispatcherTarget::UnionRect
| PpcImportDispatcherTarget::EqualRect
| PpcImportDispatcherTarget::EmptyRect
| PpcImportDispatcherTarget::SetPt
| PpcImportDispatcherTarget::EqualPt
| PpcImportDispatcherTarget::AddPt
| PpcImportDispatcherTarget::SubPt
| PpcImportDispatcherTarget::LocalToGlobal
| PpcImportDispatcherTarget::GlobalToLocal
| PpcImportDispatcherTarget::PtInRect
| PpcImportDispatcherTarget::OffsetRect
| PpcImportDispatcherTarget::MapRect
| PpcImportDispatcherTarget::InsetRect => {
unreachable!("QuickDraw imports return through dispatch_quickdraw_import")
}
PpcImportDispatcherTarget::MathCeil
| PpcImportDispatcherTarget::MathSqrt
| PpcImportDispatcherTarget::MathExp
| PpcImportDispatcherTarget::MathSin
| PpcImportDispatcherTarget::MathCos
| PpcImportDispatcherTarget::MathAsin
| PpcImportDispatcherTarget::MathTan
| PpcImportDispatcherTarget::MathAtan
| PpcImportDispatcherTarget::MathAtan2
| PpcImportDispatcherTarget::MathPow
| PpcImportDispatcherTarget::MathFmod
| PpcImportDispatcherTarget::MathLog
| PpcImportDispatcherTarget::MathLog10
| PpcImportDispatcherTarget::MathDtox80
| PpcImportDispatcherTarget::X2Fix
| PpcImportDispatcherTarget::FixRatio
| PpcImportDispatcherTarget::FixMul
| PpcImportDispatcherTarget::FixDiv
| PpcImportDispatcherTarget::Long2Fix
| PpcImportDispatcherTarget::Fix2Long
| PpcImportDispatcherTarget::FixRound
| PpcImportDispatcherTarget::Fix2Frac
| PpcImportDispatcherTarget::Frac2Fix
| PpcImportDispatcherTarget::Frac2X
| PpcImportDispatcherTarget::X2Frac
| PpcImportDispatcherTarget::FracSin
| PpcImportDispatcherTarget::FracCos
| PpcImportDispatcherTarget::FracSqrt
| PpcImportDispatcherTarget::FracMul
| PpcImportDispatcherTarget::FracDiv
| PpcImportDispatcherTarget::FixATan2
| PpcImportDispatcherTarget::WideAdd
| PpcImportDispatcherTarget::WideSubtract
| PpcImportDispatcherTarget::WideNegate
| PpcImportDispatcherTarget::WideShift
| PpcImportDispatcherTarget::WideMultiply
| PpcImportDispatcherTarget::WideDivide
| PpcImportDispatcherTarget::WideWideDivide
| PpcImportDispatcherTarget::WideCompare
| PpcImportDispatcherTarget::WideSquareRoot => {
unreachable!("math imports return through dispatch_math_import")
}
PpcImportDispatcherTarget::MoveTo
| PpcImportDispatcherTarget::Move
| PpcImportDispatcherTarget::LineTo
| PpcImportDispatcherTarget::Line => {
unreachable!("QuickDraw imports return through dispatch_quickdraw_import")
}
PpcImportDispatcherTarget::DrawChar
| PpcImportDispatcherTarget::DrawText
| PpcImportDispatcherTarget::DrawString
| PpcImportDispatcherTarget::TextFont
| PpcImportDispatcherTarget::TextFace
| PpcImportDispatcherTarget::TextMode
| PpcImportDispatcherTarget::TextSize => {
unreachable!("font and text imports return through dispatch_font_import")
}
PpcImportDispatcherTarget::PaintRect
| PpcImportDispatcherTarget::EraseRect
| PpcImportDispatcherTarget::InvertRect
| PpcImportDispatcherTarget::FrameRect
| PpcImportDispatcherTarget::FillRect
| PpcImportDispatcherTarget::FillCRect => {
unreachable!("QuickDraw imports return through dispatch_quickdraw_import")
}
PpcImportDispatcherTarget::FrameOval
| PpcImportDispatcherTarget::PaintOval
| PpcImportDispatcherTarget::EraseOval
| PpcImportDispatcherTarget::PaintArc => {
unreachable!("QuickDraw imports return through dispatch_quickdraw_import")
}
PpcImportDispatcherTarget::FrameRgn
| PpcImportDispatcherTarget::PaintRgn
| PpcImportDispatcherTarget::FillRgn
| PpcImportDispatcherTarget::InvertRgn => {
unreachable!("QuickDraw imports return through dispatch_quickdraw_import")
}
PpcImportDispatcherTarget::FrameRoundRect | PpcImportDispatcherTarget::PaintRoundRect => {
unreachable!("QuickDraw imports return through dispatch_quickdraw_import")
}
PpcImportDispatcherTarget::InvalRect
| PpcImportDispatcherTarget::ValidRect
| PpcImportDispatcherTarget::BeginUpdate
| PpcImportDispatcherTarget::EndUpdate => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::ClipRect
| PpcImportDispatcherTarget::GetClip
| PpcImportDispatcherTarget::SetClip
| PpcImportDispatcherTarget::BitMapToRegion
| PpcImportDispatcherTarget::NewRgn
| PpcImportDispatcherTarget::DisposeRgn
| PpcImportDispatcherTarget::CopyRgn
| PpcImportDispatcherTarget::OpenRgn
| PpcImportDispatcherTarget::CloseRgn
| PpcImportDispatcherTarget::SectRgn
| PpcImportDispatcherTarget::UnionRgn
| PpcImportDispatcherTarget::DiffRgn
| PpcImportDispatcherTarget::XorRgn
| PpcImportDispatcherTarget::SetEmptyRgn
| PpcImportDispatcherTarget::SetRectRgn
| PpcImportDispatcherTarget::RectRgn
| PpcImportDispatcherTarget::OffsetRgn
| PpcImportDispatcherTarget::EmptyRgn
| PpcImportDispatcherTarget::PtInRgn
| PpcImportDispatcherTarget::RectInRgn => {
unreachable!("Region Manager imports return through dispatch_region_import")
}
PpcImportDispatcherTarget::GetPen
| PpcImportDispatcherTarget::HidePen
| PpcImportDispatcherTarget::ShowPen
| PpcImportDispatcherTarget::PenSize
| PpcImportDispatcherTarget::PenMode
| PpcImportDispatcherTarget::PenNormal
| PpcImportDispatcherTarget::PenPixPat
| PpcImportDispatcherTarget::GetPenState
| PpcImportDispatcherTarget::SetPenState => {
unreachable!("QuickDraw imports return through dispatch_quickdraw_import")
}
PpcImportDispatcherTarget::CopyBits => {
unreachable!("bit-transfer imports return through dispatch_bit_transfer_import")
}
PpcImportDispatcherTarget::OpenPoly
| PpcImportDispatcherTarget::ClosePoly
| PpcImportDispatcherTarget::KillPoly
| PpcImportDispatcherTarget::FramePoly
| PpcImportDispatcherTarget::PaintPoly
| PpcImportDispatcherTarget::FillPoly => {
unreachable!("Polygon Manager imports return through dispatch_polygon_import")
}
PpcImportDispatcherTarget::NewCWindow
| PpcImportDispatcherTarget::GetNewCWindow
| PpcImportDispatcherTarget::GetWRefCon
| PpcImportDispatcherTarget::SetWRefCon
| PpcImportDispatcherTarget::SizeWindow
| PpcImportDispatcherTarget::MoveWindow => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::ShowWindow
| PpcImportDispatcherTarget::HideWindow
| PpcImportDispatcherTarget::ShowHide
| PpcImportDispatcherTarget::CloseWindow => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::DisposeDialog => {
unreachable!("dialog imports return through dispatch_dialog_import")
}
PpcImportDispatcherTarget::FrontWindow
| PpcImportDispatcherTarget::SetWinColor
| PpcImportDispatcherTarget::PaintOne
| PpcImportDispatcherTarget::PaintBehind
| PpcImportDispatcherTarget::CalcVisBehind => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::SelectWindow => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::ActivatePalette
| PpcImportDispatcherTarget::NSetPalette
| PpcImportDispatcherTarget::GetPalette => {
unreachable!("palette imports return through dispatch_palette_import")
}
PpcImportDispatcherTarget::GetPort
| PpcImportDispatcherTarget::SetPort
| PpcImportDispatcherTarget::NewGWorld
| PpcImportDispatcherTarget::UpdateGWorld
| PpcImportDispatcherTarget::DisposeGWorld
| PpcImportDispatcherTarget::QDError
| PpcImportDispatcherTarget::GetGWorld
| PpcImportDispatcherTarget::SetGWorld
| PpcImportDispatcherTarget::GetGWorldDevice
| PpcImportDispatcherTarget::GetGWorldPixMap
| PpcImportDispatcherTarget::OpenPort
| PpcImportDispatcherTarget::OpenCPort
| PpcImportDispatcherTarget::CloseCPort
| PpcImportDispatcherTarget::SetPortBits { .. }
| PpcImportDispatcherTarget::GetPixBaseAddr
| PpcImportDispatcherTarget::LockPixels
| PpcImportDispatcherTarget::UnlockPixels
| PpcImportDispatcherTarget::GetPixelsState
| PpcImportDispatcherTarget::SetPixelsState
| PpcImportDispatcherTarget::AllowPurgePixels
| PpcImportDispatcherTarget::NoPurgePixels
| PpcImportDispatcherTarget::SetOrigin => {
unreachable!("GWorld imports return through dispatch_gworld_import")
}
PpcImportDispatcherTarget::GetWMgrPort => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::GetGDevice
| PpcImportDispatcherTarget::SetGDevice
| PpcImportDispatcherTarget::GetDeviceList
| PpcImportDispatcherTarget::GetMainDevice
| PpcImportDispatcherTarget::GetMaxDevice
| PpcImportDispatcherTarget::GetNextDevice
| PpcImportDispatcherTarget::TestDeviceAttribute
| PpcImportDispatcherTarget::SetDeviceAttribute
| PpcImportDispatcherTarget::HasDepth
| PpcImportDispatcherTarget::SetDepth => {
unreachable!("graphics-device imports return through dispatch_graphics_device_import")
}
PpcImportDispatcherTarget::GetSysFont
| PpcImportDispatcherTarget::GetAppFont
| PpcImportDispatcherTarget::GetDefFontSize
| PpcImportDispatcherTarget::GetFontName => {
unreachable!("Font Manager imports return through dispatch_font_import")
}
PpcImportDispatcherTarget::DMGetDisplayIDByGDevice
| PpcImportDispatcherTarget::DMGetGDeviceByDisplayID => {
unreachable!("display manager imports return through dispatch_display_import")
}
PpcImportDispatcherTarget::GetCTable
| PpcImportDispatcherTarget::GetCTSeed
| PpcImportDispatcherTarget::MakeITable
| PpcImportDispatcherTarget::CTabChanged
| PpcImportDispatcherTarget::ProtectEntry
| PpcImportDispatcherTarget::ReserveEntry
| PpcImportDispatcherTarget::RestoreEntries
| PpcImportDispatcherTarget::SetEntries
| PpcImportDispatcherTarget::RestoreDeviceClut
| PpcImportDispatcherTarget::DisposeCTable
| PpcImportDispatcherTarget::NewPixMap
| PpcImportDispatcherTarget::DisposePixMap => {
unreachable!("color-table imports return through dispatch_color_table_import")
}
PpcImportDispatcherTarget::FindWindow => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::GetDCtlEntry
| PpcImportDispatcherTarget::GetADBInfo
| PpcImportDispatcherTarget::OpenDriver
| PpcImportDispatcherTarget::Control
| PpcImportDispatcherTarget::PBControl
| PpcImportDispatcherTarget::PBStatus => {
unreachable!("Device Manager imports return through dispatch_device_import")
}
PpcImportDispatcherTarget::Gestalt => {
unreachable!("Gestalt imports return through dispatch_gestalt_import")
}
PpcImportDispatcherTarget::GetSharedLibrary
| PpcImportDispatcherTarget::FindSymbol
| PpcImportDispatcherTarget::CountSymbols
| PpcImportDispatcherTarget::GetIndSymbol
| PpcImportDispatcherTarget::CloseConnection
| PpcImportDispatcherTarget::GetMemFragment => {
unreachable!("cfm imports return through dispatch_cfm_import")
}
PpcImportDispatcherTarget::StandardGetFile => {
unreachable!("standard file imports return through dispatch_standard_file_import")
}
PpcImportDispatcherTarget::GetScrap
| PpcImportDispatcherTarget::PutScrap
| PpcImportDispatcherTarget::ZeroScrap
| PpcImportDispatcherTarget::LoadScrap => {
unreachable!("Scrap Manager imports return through dispatch_scrap_import")
}
PpcImportDispatcherTarget::DMGetFirstScreenDevice
| PpcImportDispatcherTarget::DMGetNextScreenDevice
| PpcImportDispatcherTarget::DMGetDisplayMode
| PpcImportDispatcherTarget::DMCheckDisplayMode
| PpcImportDispatcherTarget::DMSetDisplayMode
| PpcImportDispatcherTarget::DMNewDisplayModeList
| PpcImportDispatcherTarget::DMGetIndexedDisplayModeFromList
| PpcImportDispatcherTarget::DMDisposeList
| PpcImportDispatcherTarget::DMBeginConfigureDisplays
| PpcImportDispatcherTarget::DMEndConfigureDisplays => {
unreachable!("display manager imports return through dispatch_display_import")
}
PpcImportDispatcherTarget::GetNewDialog
| PpcImportDispatcherTarget::NewDialog
| PpcImportDispatcherTarget::NewFeaturesDialog
| PpcImportDispatcherTarget::GetDialogItem
| PpcImportDispatcherTarget::SetDialogItem
| PpcImportDispatcherTarget::GetDialogItemText
| PpcImportDispatcherTarget::SetDialogItemText
| PpcImportDispatcherTarget::SetDialogDefaultItem
| PpcImportDispatcherTarget::SetDialogCancelItem
| PpcImportDispatcherTarget::DrawDialog
| PpcImportDispatcherTarget::ModalDialog => {
unreachable!("dialog imports return through dispatch_dialog_import")
}
PpcImportDispatcherTarget::DrawControls => {
unreachable!("control imports return through dispatch_control_import")
}
PpcImportDispatcherTarget::SetControlTitle
| PpcImportDispatcherTarget::SetControlValue
| PpcImportDispatcherTarget::HiliteControl => {
unreachable!("control imports return through dispatch_control_import")
}
PpcImportDispatcherTarget::InitFonts => {
unreachable!("Font Manager imports return through dispatch_font_import")
}
PpcImportDispatcherTarget::InitWindows => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::MeasureText | PpcImportDispatcherTarget::RealFont => {
unreachable!("Font Manager imports return through dispatch_font_import")
}
PpcImportDispatcherTarget::SelectDialogItemText
| PpcImportDispatcherTarget::InitDialogs => {
unreachable!("dialog imports return through dispatch_dialog_import")
}
PpcImportDispatcherTarget::SystemTask
| PpcImportDispatcherTarget::SystemClick
| PpcImportDispatcherTarget::OpenDeskAcc => {
unreachable!("Desk Manager imports return through dispatch_desk_import")
}
PpcImportDispatcherTarget::AEInstallEventHandler
| PpcImportDispatcherTarget::AEProcessAppleEvent => {
unreachable!("Apple Event imports return through dispatch_apple_event_import")
}
PpcImportDispatcherTarget::LNew
| PpcImportDispatcherTarget::LDispose
| PpcImportDispatcherTarget::LAddRow
| PpcImportDispatcherTarget::LDelRow
| PpcImportDispatcherTarget::LGetSelect
| PpcImportDispatcherTarget::LSetSelect
| PpcImportDispatcherTarget::LSetCell
| PpcImportDispatcherTarget::LGetCell
| PpcImportDispatcherTarget::LClick
| PpcImportDispatcherTarget::LActivate
| PpcImportDispatcherTarget::LSetDrawingMode
| PpcImportDispatcherTarget::LScroll
| PpcImportDispatcherTarget::LSize
| PpcImportDispatcherTarget::LUpdate
| PpcImportDispatcherTarget::LAutoScroll
| PpcImportDispatcherTarget::LSearch => {
unreachable!("list imports return through dispatch_list_import")
}
PpcImportDispatcherTarget::SysEnvirons
| PpcImportDispatcherTarget::SVersion
| PpcImportDispatcherTarget::EqualString
| PpcImportDispatcherTarget::NumToString
| PpcImportDispatcherTarget::StringToNum
| PpcImportDispatcherTarget::Random
| PpcImportDispatcherTarget::BitAnd
| PpcImportDispatcherTarget::BitOr
| PpcImportDispatcherTarget::BitTst => {
unreachable!("Toolbox Utilities imports return through dispatch_toolbox_import")
}
PpcImportDispatcherTarget::TextWidth
| PpcImportDispatcherTarget::TruncString
| PpcImportDispatcherTarget::StringWidth
| PpcImportDispatcherTarget::CharWidth
| PpcImportDispatcherTarget::GetFontInfo
| PpcImportDispatcherTarget::FontMetrics
| PpcImportDispatcherTarget::GetFNum => {
unreachable!("Font Manager imports return through dispatch_font_import")
}
PpcImportDispatcherTarget::AESetInteractionAllowed
| PpcImportDispatcherTarget::AEGetInteractionAllowed => {
unreachable!("Apple Event imports return through dispatch_apple_event_import")
}
PpcImportDispatcherTarget::StdMemset
| PpcImportDispatcherTarget::StdMemcmp
| PpcImportDispatcherTarget::StdMemcpy
| PpcImportDispatcherTarget::StdMemmove => {
unreachable!("stdc imports return through dispatch_stdc_import")
}
PpcImportDispatcherTarget::StdMalloc
| PpcImportDispatcherTarget::StdFree
| PpcImportDispatcherTarget::StdCalloc
| PpcImportDispatcherTarget::StdRealloc
| PpcImportDispatcherTarget::StdStrcpy
| PpcImportDispatcherTarget::StdStrncpy
| PpcImportDispatcherTarget::StdStrcat
| PpcImportDispatcherTarget::StdStrncat
| PpcImportDispatcherTarget::StdStrcmp
| PpcImportDispatcherTarget::StdStrncmp
| PpcImportDispatcherTarget::StdStrlen
| PpcImportDispatcherTarget::StdMemchr
| PpcImportDispatcherTarget::StdStrchr
| PpcImportDispatcherTarget::StdStrrchr
| PpcImportDispatcherTarget::StdStrspn
| PpcImportDispatcherTarget::StdStrcspn
| PpcImportDispatcherTarget::StdStrpbrk
| PpcImportDispatcherTarget::StdStrstr
| PpcImportDispatcherTarget::StdAtoi
| PpcImportDispatcherTarget::StdGetenv
| PpcImportDispatcherTarget::StdSprintf => {
unreachable!("stdc imports return through dispatch_stdc_import")
}
PpcImportDispatcherTarget::StdIoCompatibility(operation) => {
Some(ppc_dispatch_process_stdio_compatibility(
operation,
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
files,
writable_refnums,
vfs_files,
next_file_ref_num,
stdio_streams,
))
}
PpcImportDispatcherTarget::StdAbs
| PpcImportDispatcherTarget::StdToupper
| PpcImportDispatcherTarget::StdTolower
| PpcImportDispatcherTarget::StdIsalnum
| PpcImportDispatcherTarget::StdIsalpha
| PpcImportDispatcherTarget::StdIsascii
| PpcImportDispatcherTarget::StdIscntrl
| PpcImportDispatcherTarget::StdIsdigit
| PpcImportDispatcherTarget::StdIsgraph
| PpcImportDispatcherTarget::StdIslower
| PpcImportDispatcherTarget::StdIsprint
| PpcImportDispatcherTarget::StdIspunct
| PpcImportDispatcherTarget::StdIsspace
| PpcImportDispatcherTarget::StdIsupper
| PpcImportDispatcherTarget::StdIsxdigit
| PpcImportDispatcherTarget::StdToascii
| PpcImportDispatcherTarget::StdSrand
| PpcImportDispatcherTarget::StdRand
| PpcImportDispatcherTarget::P2CStr
| PpcImportDispatcherTarget::C2PStr
| PpcImportDispatcherTarget::UpperText => {
unreachable!("stdc imports return through dispatch_stdc_import")
}
PpcImportDispatcherTarget::GetCurrentProcess
| PpcImportDispatcherTarget::WakeUpProcess
| PpcImportDispatcherTarget::SameProcess
| PpcImportDispatcherTarget::GetProcessInformation => {
unreachable!("Process Manager imports return through dispatch_process_import")
}
PpcImportDispatcherTarget::ParamText
| PpcImportDispatcherTarget::AlertReturnDefault => {
unreachable!("dialog imports return through dispatch_dialog_import")
}
PpcImportDispatcherTarget::Q3Initialize | PpcImportDispatcherTarget::Q3Exit => {
unreachable!("QuickDraw 3D core imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3MemoryStorageNew
| PpcImportDispatcherTarget::Q3MemoryStorageNewBuffer
| PpcImportDispatcherTarget::Q3FSSpecStorageNew => {
unreachable!("QuickDraw 3D storage imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3NewObject => {
unreachable!("QuickDraw 3D core imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3FileNew => {
unreachable!("QuickDraw 3D file imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3ViewNew | PpcImportDispatcherTarget::Q3DisplayGroupNew => {
unreachable!("QuickDraw 3D group/view imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3ErrorGet => {
unreachable!("QuickDraw 3D core imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3ObjectDispose
| PpcImportDispatcherTarget::Q3ObjectDuplicate
| PpcImportDispatcherTarget::Q3SharedGetReference
| PpcImportDispatcherTarget::Q3SharedIsReferenced
| PpcImportDispatcherTarget::Q3SharedGetType
| PpcImportDispatcherTarget::Q3ShapeGetType
| PpcImportDispatcherTarget::Q3ShapeGetLeafType
| PpcImportDispatcherTarget::Q3ObjectIsDrawable
| PpcImportDispatcherTarget::Q3ObjectIsType
| PpcImportDispatcherTarget::Q3ObjectGetType
| PpcImportDispatcherTarget::Q3ObjectGetLeafType
| PpcImportDispatcherTarget::Q3GeometryGetType => {
unreachable!("QuickDraw 3D object imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3ShaderGetType => {
unreachable!("QuickDraw 3D shader imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3GroupGetType
| PpcImportDispatcherTarget::Q3RendererNewFromType
| PpcImportDispatcherTarget::Q3RendererGetType
| PpcImportDispatcherTarget::Q3RendererSync
| PpcImportDispatcherTarget::Q3RendererFlush => {
unreachable!("QuickDraw 3D object/renderer imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3InteractiveRendererSetDoubleBufferBypass
| PpcImportDispatcherTarget::Q3InteractiveRendererSetPreferences
| PpcImportDispatcherTarget::Q3InteractiveRendererSetRaveContextHints
| PpcImportDispatcherTarget::Q3InteractiveRendererGetRaveContextHints
| PpcImportDispatcherTarget::Q3InteractiveRendererGetRaveDrawContexts
| PpcImportDispatcherTarget::Q3InteractiveRendererSetRaveTextureFilter => {
unreachable!("QuickDraw 3D object/renderer imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3TextureShaderNew
| PpcImportDispatcherTarget::Q3LambertIlluminationNew
| PpcImportDispatcherTarget::Q3NullIlluminationNew
| PpcImportDispatcherTarget::Q3PhongIlluminationNew
| PpcImportDispatcherTarget::Q3TextureShaderGetTexture
| PpcImportDispatcherTarget::Q3MipmapTextureNew
| PpcImportDispatcherTarget::Q3MipmapTextureGetMipmap => {
unreachable!(
"QuickDraw 3D shader imports return through dispatch_q3_shader_style_import_fast"
)
}
PpcImportDispatcherTarget::Q3StorageGetType
| PpcImportDispatcherTarget::Q3MemoryStorageSet
| PpcImportDispatcherTarget::Q3MemoryStorageGetBuffer
| PpcImportDispatcherTarget::Q3MemoryStorageSetBuffer
| PpcImportDispatcherTarget::Q3MemoryStorageGetType => {
unreachable!("QuickDraw 3D storage imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3ViewAngleAspectCameraNew
| PpcImportDispatcherTarget::Q3OrthographicCameraNew
| PpcImportDispatcherTarget::Q3ViewPlaneCameraNew
| PpcImportDispatcherTarget::Q3CameraGetPlacement
| PpcImportDispatcherTarget::Q3CameraSetPlacement
| PpcImportDispatcherTarget::Q3CameraGetRange
| PpcImportDispatcherTarget::Q3CameraSetRange
| PpcImportDispatcherTarget::Q3CameraGetViewPort
| PpcImportDispatcherTarget::Q3CameraSetViewPort
| PpcImportDispatcherTarget::Q3CameraGetWorldToView
| PpcImportDispatcherTarget::Q3CameraGetViewToFrustum => {
unreachable!("QuickDraw 3D scene imports return through dispatch_q3_scene_import_fast")
}
PpcImportDispatcherTarget::Q3LightGetType
| PpcImportDispatcherTarget::Q3LightGetState
| PpcImportDispatcherTarget::Q3LightSetState
| PpcImportDispatcherTarget::Q3LightGetBrightness
| PpcImportDispatcherTarget::Q3LightSetBrightness
| PpcImportDispatcherTarget::Q3LightGetColor
| PpcImportDispatcherTarget::Q3LightSetColor
| PpcImportDispatcherTarget::Q3LightGetData
| PpcImportDispatcherTarget::Q3LightSetData
| PpcImportDispatcherTarget::Q3AmbientLightNew
| PpcImportDispatcherTarget::Q3AmbientLightGetData
| PpcImportDispatcherTarget::Q3AmbientLightSetData
| PpcImportDispatcherTarget::Q3DirectionalLightNew
| PpcImportDispatcherTarget::Q3DirectionalLightGetCastShadowsState
| PpcImportDispatcherTarget::Q3DirectionalLightSetCastShadowsState
| PpcImportDispatcherTarget::Q3DirectionalLightGetDirection
| PpcImportDispatcherTarget::Q3DirectionalLightSetDirection
| PpcImportDispatcherTarget::Q3DirectionalLightGetData
| PpcImportDispatcherTarget::Q3DirectionalLightSetData => {
unreachable!("QuickDraw 3D scene imports return through dispatch_q3_scene_import_fast")
}
PpcImportDispatcherTarget::Q3PointLightNew
| PpcImportDispatcherTarget::Q3PointLightGetCastShadowsState
| PpcImportDispatcherTarget::Q3PointLightSetCastShadowsState
| PpcImportDispatcherTarget::Q3PointLightGetAttenuation
| PpcImportDispatcherTarget::Q3PointLightSetAttenuation
| PpcImportDispatcherTarget::Q3PointLightGetLocation
| PpcImportDispatcherTarget::Q3PointLightSetLocation
| PpcImportDispatcherTarget::Q3PointLightGetData
| PpcImportDispatcherTarget::Q3PointLightSetData
| PpcImportDispatcherTarget::Q3SpotLightNew
| PpcImportDispatcherTarget::Q3SpotLightGetCastShadowsState
| PpcImportDispatcherTarget::Q3SpotLightSetCastShadowsState
| PpcImportDispatcherTarget::Q3SpotLightGetAttenuation
| PpcImportDispatcherTarget::Q3SpotLightSetAttenuation
| PpcImportDispatcherTarget::Q3SpotLightGetLocation
| PpcImportDispatcherTarget::Q3SpotLightSetLocation
| PpcImportDispatcherTarget::Q3SpotLightGetDirection
| PpcImportDispatcherTarget::Q3SpotLightSetDirection
| PpcImportDispatcherTarget::Q3SpotLightGetHotAngle
| PpcImportDispatcherTarget::Q3SpotLightSetHotAngle
| PpcImportDispatcherTarget::Q3SpotLightGetOuterAngle
| PpcImportDispatcherTarget::Q3SpotLightSetOuterAngle
| PpcImportDispatcherTarget::Q3SpotLightGetFallOff
| PpcImportDispatcherTarget::Q3SpotLightSetFallOff
| PpcImportDispatcherTarget::Q3SpotLightGetData
| PpcImportDispatcherTarget::Q3SpotLightSetData => {
unreachable!("QuickDraw 3D scene imports return through dispatch_q3_scene_import_fast")
}
PpcImportDispatcherTarget::Q3ShaderGetUVTransform
| PpcImportDispatcherTarget::Q3ShaderSetUVTransform
| PpcImportDispatcherTarget::Q3ShaderGetUBoundary
| PpcImportDispatcherTarget::Q3ShaderSetUBoundary
| PpcImportDispatcherTarget::Q3ShaderGetVBoundary
| PpcImportDispatcherTarget::Q3ShaderSetVBoundary => {
unreachable!(
"QuickDraw 3D shader imports return through dispatch_q3_shader_style_import_fast"
)
}
PpcImportDispatcherTarget::Q3BackfacingStyleNew
| PpcImportDispatcherTarget::Q3BackfacingStyleGet
| PpcImportDispatcherTarget::Q3BackfacingStyleSet
| PpcImportDispatcherTarget::Q3InterpolationStyleNew
| PpcImportDispatcherTarget::Q3InterpolationStyleGet
| PpcImportDispatcherTarget::Q3InterpolationStyleSet
| PpcImportDispatcherTarget::Q3FillStyleNew
| PpcImportDispatcherTarget::Q3FillStyleGet
| PpcImportDispatcherTarget::Q3FillStyleSet
| PpcImportDispatcherTarget::Q3OrientationStyleNew
| PpcImportDispatcherTarget::Q3OrientationStyleGet
| PpcImportDispatcherTarget::Q3OrientationStyleSet => {
unreachable!(
"QuickDraw 3D style imports return through dispatch_q3_shader_style_import_fast"
)
}
PpcImportDispatcherTarget::Q3TriMeshNew
| PpcImportDispatcherTarget::Q3TriMeshGetData
| PpcImportDispatcherTarget::Q3TriMeshSetData
| PpcImportDispatcherTarget::Q3TriMeshEmptyData
| PpcImportDispatcherTarget::Q3AttributeSetNew
| PpcImportDispatcherTarget::Q3AttributeSetAdd
| PpcImportDispatcherTarget::Q3AttributeSetGet
| PpcImportDispatcherTarget::Q3AttributeSetClear
| PpcImportDispatcherTarget::Q3AttributeSetContains
| PpcImportDispatcherTarget::Q3AttributeSetGetNextAttributeType => {
unreachable!("QuickDraw 3D geometry imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3StorageGetSize
| PpcImportDispatcherTarget::Q3StorageGetData
| PpcImportDispatcherTarget::Q3StorageSetData => {
unreachable!("QuickDraw 3D storage imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3PixmapDrawContextNew
| PpcImportDispatcherTarget::Q3MacDrawContextNew
| PpcImportDispatcherTarget::Q3DrawContextGetPane => {
unreachable!("QuickDraw 3D geometry imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3Vector3DNormalize
| PpcImportDispatcherTarget::Q3Vector2DNormalize
| PpcImportDispatcherTarget::Q3Vector3DCross
| PpcImportDispatcherTarget::Q3Point2DDistance
| PpcImportDispatcherTarget::Q3Point3DDistance
| PpcImportDispatcherTarget::Q3Point3DCrossProductTri
| PpcImportDispatcherTarget::Q3Matrix3x3SetTranslate
| PpcImportDispatcherTarget::Q3Matrix4x4SetIdentity
| PpcImportDispatcherTarget::Q3Matrix4x4SetTranslate
| PpcImportDispatcherTarget::Q3Matrix4x4SetScale
| PpcImportDispatcherTarget::Q3Matrix4x4SetRotateX
| PpcImportDispatcherTarget::Q3Matrix4x4SetRotateY
| PpcImportDispatcherTarget::Q3Matrix4x4SetRotateZ
| PpcImportDispatcherTarget::Q3Matrix4x4SetRotateXyz
| PpcImportDispatcherTarget::Q3Matrix4x4Multiply
| PpcImportDispatcherTarget::Q3Matrix4x4Transpose
| PpcImportDispatcherTarget::Q3Matrix4x4Invert
| PpcImportDispatcherTarget::Q3Point3DTransform
| PpcImportDispatcherTarget::Q3Point3DTo3DTransformArray
| PpcImportDispatcherTarget::Q3Point3DTo4DTransformArray
| PpcImportDispatcherTarget::Q3Vector3DTransform
| PpcImportDispatcherTarget::Q3MatrixTransformNew
| PpcImportDispatcherTarget::Q3MatrixTransformSet
| PpcImportDispatcherTarget::Q3TransformGetMatrix => {
unreachable!("QuickDraw 3D math imports return through dispatch_q3_math_import_fast")
}
PpcImportDispatcherTarget::Q3FileSetStorage
| PpcImportDispatcherTarget::Q3FileOpenRead
| PpcImportDispatcherTarget::Q3FileReadObject
| PpcImportDispatcherTarget::Q3FileIsEndOfFile
| PpcImportDispatcherTarget::Q3FileClose => {
unreachable!("QuickDraw 3D file imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3GroupAddObject
| PpcImportDispatcherTarget::Q3GroupAddObjectBefore
| PpcImportDispatcherTarget::Q3GroupCountObjects
| PpcImportDispatcherTarget::Q3GroupGetFirstPosition
| PpcImportDispatcherTarget::Q3GroupGetNextPosition
| PpcImportDispatcherTarget::Q3GroupGetFirstPositionOfType
| PpcImportDispatcherTarget::Q3GroupGetPositionObject
| PpcImportDispatcherTarget::Q3GroupRemovePosition
| PpcImportDispatcherTarget::Q3LightGroupNew => {
unreachable!("QuickDraw 3D group imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3ViewSetRenderer
| PpcImportDispatcherTarget::Q3ViewGetRenderer
| PpcImportDispatcherTarget::Q3ViewSetLightGroup
| PpcImportDispatcherTarget::Q3ViewGetLightGroup
| PpcImportDispatcherTarget::Q3ViewSetDrawContext
| PpcImportDispatcherTarget::Q3ViewGetDrawContext
| PpcImportDispatcherTarget::Q3ViewSetCamera
| PpcImportDispatcherTarget::Q3ViewGetCamera
| PpcImportDispatcherTarget::Q3ViewStartRendering
| PpcImportDispatcherTarget::Q3ViewEndRendering
| PpcImportDispatcherTarget::Q3ViewStartBoundingBox
| PpcImportDispatcherTarget::Q3ViewEndBoundingBox
| PpcImportDispatcherTarget::Q3ViewCancel => {
unreachable!("QuickDraw 3D view imports return through typed dispatch")
}
PpcImportDispatcherTarget::Q3ShaderSubmit
| PpcImportDispatcherTarget::Q3StyleSubmit => {
unreachable!("QuickDraw 3D submissions return through typed dispatch")
}
PpcImportDispatcherTarget::Q3BackfacingStyleSubmit
| PpcImportDispatcherTarget::Q3InterpolationStyleSubmit
| PpcImportDispatcherTarget::Q3FillStyleSubmit
| PpcImportDispatcherTarget::Q3OrientationStyleSubmit => {
unreachable!("QuickDraw 3D submissions return through typed dispatch")
}
PpcImportDispatcherTarget::Q3FogStyleSubmit
| PpcImportDispatcherTarget::Q3TriMeshSubmit => {
unreachable!("QuickDraw 3D submissions return through typed dispatch")
}
PpcImportDispatcherTarget::Q3MatrixTransformSubmit
| PpcImportDispatcherTarget::Q3ResetTransformSubmit => {
unreachable!("QuickDraw 3D submissions return through typed dispatch")
}
PpcImportDispatcherTarget::Q3PushSubmit
| PpcImportDispatcherTarget::Q3PopSubmit
| PpcImportDispatcherTarget::Q3ObjectSubmit => {
unreachable!("QuickDraw 3D submissions return through typed dispatch")
}
PpcImportDispatcherTarget::QADeviceGetFirstEngine => {
Some(PpcImportAction::Return(PPC_QA_ENGINE))
}
PpcImportDispatcherTarget::QADeviceGetNextEngine => Some(PpcImportAction::Return(0)),
PpcImportDispatcherTarget::QAEngineGestalt => {
Some(PpcImportAction::Return(ppc_qa_engine_gestalt(cpu, memory)))
}
PpcImportDispatcherTarget::CloseComponent => Some(PpcImportAction::Return(ppc_i16_result(
ppc_close_component(cpu, quicktime),
))),
PpcImportDispatcherTarget::NewRoutineDescriptor
| PpcImportDispatcherTarget::NewFatRoutineDescriptor
| PpcImportDispatcherTarget::DisposeRoutineDescriptor
| PpcImportDispatcherTarget::CallUniversalProc
| PpcImportDispatcherTarget::CallOSTrapUniversalProc => {
unreachable!("mixed mode imports return through dispatch_mixed_mode_import")
}
PpcImportDispatcherTarget::NGetTrapAddress
| PpcImportDispatcherTarget::GetToolTrapAddress
| PpcImportDispatcherTarget::GetOSTrapAddress => {
let trap_word = cpu.gpr[3] as u16;
let toolbox = matches!(
binding.dispatcher_target,
PpcImportDispatcherTarget::GetToolTrapAddress
) || (matches!(
binding.dispatcher_target,
PpcImportDispatcherTarget::NGetTrapAddress
) && cpu.gpr[4] != 0);
Some(PpcImportAction::Return(
ppc_logical_trap_address(memory, trap_word, toolbox).unwrap_or(0),
))
}
PpcImportDispatcherTarget::SetToolTrapAddress
| PpcImportDispatcherTarget::SetOSTrapAddress
| PpcImportDispatcherTarget::NSetTrapAddress => {
let toolbox = matches!(
binding.dispatcher_target,
PpcImportDispatcherTarget::SetToolTrapAddress
) || (matches!(
binding.dispatcher_target,
PpcImportDispatcherTarget::NSetTrapAddress
) && cpu.gpr[5] != 0);
Some(
if ppc_set_logical_trap_address(memory, cpu.gpr[4] as u16, toolbox, cpu.gpr[3]) {
PpcImportAction::ReturnPreserve
} else {
PpcImportAction::Halt
},
)
}
PpcImportDispatcherTarget::LegacyMemoryUtility(operation) => {
ppc_dispatch_legacy_memory_utility(
operation,
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
)
}
PpcImportDispatcherTarget::LegacyControl(_) => {
unreachable!("control imports return through dispatch_control_import")
}
PpcImportDispatcherTarget::LegacyWindow(_) => {
unreachable!("window imports return through dispatch_window_import")
}
PpcImportDispatcherTarget::AppleEventCompatibility(_) => {
unreachable!("Apple Event imports return through dispatch_apple_event_import")
}
PpcImportDispatcherTarget::DialogCompatibility(_) => {
unreachable!("dialog imports return through dispatch_dialog_import")
}
PpcImportDispatcherTarget::QuickDrawCompatibility(operation) => {
Some(ppc_dispatch_quickdraw_compatibility(
operation,
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
*current_resource_refnum,
gworlds,
*current_gworld,
*current_gdevice,
screen_clut,
color_manager_clut,
*quickdraw_fore_color,
quickdraw_fore_indices.get(current_gworld).copied(),
*quickdraw_back_color,
toolbox_startup,
))
}
PpcImportDispatcherTarget::SystemCompatibility(operation) => Some(ppc_dispatch_system_compatibility(
operation,
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
launched_app_path,
)),
PpcImportDispatcherTarget::AppleTalkCompatibility(operation) => {
Some(ppc_dispatch_appletalk_compatibility(operation, cpu, memory))
}
PpcImportDispatcherTarget::PrintingCompatibility(operation) => {
Some(ppc_dispatch_printing_compatibility(operation))
}
PpcImportDispatcherTarget::SlotCompatibility => {
Some(ppc_dispatch_slot_compatibility(binding, cpu, memory))
}
PpcImportDispatcherTarget::StandardFileCompatibility(_) => {
unreachable!("standard file imports return through dispatch_standard_file_import")
}
PpcImportDispatcherTarget::SysBeep
| PpcImportDispatcherTarget::SndSoundManagerVersion
| PpcImportDispatcherTarget::UnsignedFixedMulDiv
| PpcImportDispatcherTarget::GetSoundOutputInfo
| PpcImportDispatcherTarget::GetSoundVol
| PpcImportDispatcherTarget::SetSoundVol
| PpcImportDispatcherTarget::GetDefaultOutputVolume
| PpcImportDispatcherTarget::SetDefaultOutputVolume
| PpcImportDispatcherTarget::SndNewChannel
| PpcImportDispatcherTarget::SndDisposeChannel
| PpcImportDispatcherTarget::SndPlay
| PpcImportDispatcherTarget::SndChannelStatus
| PpcImportDispatcherTarget::SndGetInfo
| PpcImportDispatcherTarget::ParseSndHeader
| PpcImportDispatcherTarget::SndDoCommand
| PpcImportDispatcherTarget::SndDoImmediate
| PpcImportDispatcherTarget::SndPlayDoubleBuffer
| PpcImportDispatcherTarget::SndStartFilePlay
| PpcImportDispatcherTarget::SndPauseFilePlay
| PpcImportDispatcherTarget::SndStopFilePlay
| PpcImportDispatcherTarget::GetSoundHeaderOffset
| PpcImportDispatcherTarget::SoundInputCompatibility(_) => {
unreachable!("sound imports return through dispatch_sound_import")
}
PpcImportDispatcherTarget::SpeechCompatibility(operation) => {
Some(ppc_dispatch_speech_compatibility(operation, cpu, memory))
}
PpcImportDispatcherTarget::QuickTimeCompatibility(operation) => Some(
dispatch_quicktime_compatibility(operation, cpu, memory, quicktime),
),
PpcImportDispatcherTarget::InputSprocketCompatibility(operation) => {
Some(ppc_dispatch_input_sprocket_compatibility(
operation,
cpu,
memory,
input_sprocket,
input_sprocket_virtual_elements,
))
}
PpcImportDispatcherTarget::MathCompatibility(operation) => {
Some(ppc_dispatch_math_compatibility(operation, cpu, memory))
}
PpcImportDispatcherTarget::Math64(operation) => {
Some(ppc_dispatch_math64(operation, cpu, memory))
}
PpcImportDispatcherTarget::StdCCompatibility(_) => {
unreachable!("stdc imports return through dispatch_stdc_import")
}
PpcImportDispatcherTarget::ObjectSupportCompatibility => {
Some(ppc_dispatch_object_support_compatibility(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
))
}
PpcImportDispatcherTarget::GlideSstQueryBoards => {
// 3Dfx Glide 2.4 Reference Manual, grSstQueryBoards: the routine
// returns FXFALSE when it detects no Voodoo Graphics subsystem.
// Systemless exposes the generic QuickDraw 3D Accelerator path,
// not a fabricated 3Dfx board, so leave hwConfig untouched.
Some(PpcImportAction::Return(0))
}
PpcImportDispatcherTarget::FlushEvents
| PpcImportDispatcherTarget::SetEventMask
| PpcImportDispatcherTarget::GetNextEvent(_)
| PpcImportDispatcherTarget::GetOSEvent
| PpcImportDispatcherTarget::EventAvail
| PpcImportDispatcherTarget::OSEventAvail
| PpcImportDispatcherTarget::PostEvent
| PpcImportDispatcherTarget::Button
| PpcImportDispatcherTarget::StillDown
| PpcImportDispatcherTarget::WaitMouseUp
| PpcImportDispatcherTarget::GetKeys
| PpcImportDispatcherTarget::GetMouse => {
unreachable!("event imports return through dispatch_event_import")
}
PpcImportDispatcherTarget::LMGetMenuList
| PpcImportDispatcherTarget::LMGetMenuFlash
| PpcImportDispatcherTarget::LMGetPaintWhite
| PpcImportDispatcherTarget::LMGetSysMap
| PpcImportDispatcherTarget::LMSetPaintWhite
| PpcImportDispatcherTarget::LMSetResumeProc
| PpcImportDispatcherTarget::LMSetACount
| PpcImportDispatcherTarget::LMSetANumber
| PpcImportDispatcherTarget::LMSetDlgFont
| PpcImportDispatcherTarget::SetMenuFlash
| PpcImportDispatcherTarget::GetGrayRgn
| PpcImportDispatcherTarget::LMSetGrayRgn
| PpcImportDispatcherTarget::LMGetUTableBase
| PpcImportDispatcherTarget::LMGetCurDirStore
| PpcImportDispatcherTarget::LMSetCurDirStore
| PpcImportDispatcherTarget::LMGetRndSeed
| PpcImportDispatcherTarget::LMSetRndSeed
| PpcImportDispatcherTarget::SetCurrentA5
| PpcImportDispatcherTarget::SetA5
| PpcImportDispatcherTarget::LMGetCurrentA5 => {
unreachable!("low-memory imports return through dispatch_low_memory_import")
}
PpcImportDispatcherTarget::TickCount
| PpcImportDispatcherTarget::GetDateTime
| PpcImportDispatcherTarget::ReadDateTime
| PpcImportDispatcherTarget::ReadLocation
| PpcImportDispatcherTarget::GetTime
| PpcImportDispatcherTarget::Delay
| PpcImportDispatcherTarget::GetDblTime
| PpcImportDispatcherTarget::LMGetTime
| PpcImportDispatcherTarget::SecondsToDate
| PpcImportDispatcherTarget::Microseconds => {
unreachable!("time imports return through dispatch_time_import")
}
PpcImportDispatcherTarget::ReturnError(error) => {
Some(PpcImportAction::Return(ppc_i16_result(error)))
}
PpcImportDispatcherTarget::ReturnNoErr => Some(PpcImportAction::Return(0)),
PpcImportDispatcherTarget::ReturnOne => Some(PpcImportAction::Return(1)),
PpcImportDispatcherTarget::NoOpPreserve => Some(PpcImportAction::ReturnPreserve),
PpcImportDispatcherTarget::ExitToShell => Some(PpcImportAction::Halt),
PpcImportDispatcherTarget::UnresolvedWeak | PpcImportDispatcherTarget::Unsupported => None,
}
}
fn ppc_zero_guest_bytes(memory: &mut PpcSectionMem, addr: u32, len: u32) -> bool {
if addr == 0 || !ppc_memory_can_write_bytes(memory, addr, len) {
return false;
}
for offset in 0..len {
if memory.write_u8(addr + offset, 0).is_none() {
return false;
}
}
true
}
#[allow(clippy::too_many_arguments)]
fn ppc_dispatch_quickdraw_compatibility(
operation: PpcQuickDrawCompatibilityOperation,
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
color_manager_clut: &mut [[u16; 3]; 256],
fore_color: PpcRgbColor,
fore_index: Option<u8>,
back_color: PpcRgbColor,
toolbox_startup: &mut PpcToolboxStartupState,
) -> PpcImportAction {
match operation {
PpcQuickDrawCompatibilityOperation::SetCPixel => {
let color = ppc_read_rgb_color(memory, cpu.gpr[5]);
let surface = ppc_live_quickdraw_surface(memory, gworlds, current_gworld);
if let (Some(color), Some(surface)) = (color, surface) {
let point = surface.local_point((
cpu.gpr[3] as u16 as i16 as i32,
cpu.gpr[4] as u16 as i16 as i32,
));
if let Some(pixel) = ppc_quickdraw_surface_color_pixel(memory, surface, color) {
let _ = ppc_quickdraw_write_raw_pixel(memory, surface.front_buffer, point, pixel);
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::GetCPixel => {
let color = ppc_live_quickdraw_surface(memory, gworlds, current_gworld)
.and_then(|surface| {
let front = surface.front_buffer;
ppc_quickdraw_read_pixel(
memory,
front,
surface.local_point((
cpu.gpr[3] as u16 as i16 as i32,
cpu.gpr[4] as u16 as i16 as i32,
)),
)
.map(|pixel| match front.depth {
depth @ (1 | 2 | 4 | 8) => {
let fallback = TrapDispatcher::standard_mac_indexed_clut(depth as u16)
.map(|(clut, _)| clut)
.unwrap_or_else(TrapDispatcher::standard_mac_8bpp_clut);
let clut = surface
.ctable_handle
.and_then(|handle| ppc_read_ctable_clut(memory, handle, &fallback))
.unwrap_or(fallback);
let [red, green, blue] = clut[usize::from(pixel as u8)];
PpcRgbColor { red, green, blue }
}
16 => {
let [red, green, blue] = ppc_rgb555_to_rgb16(pixel);
PpcRgbColor { red, green, blue }
}
_ => PPC_RGB_BLACK,
})
})
.unwrap_or(PPC_RGB_BLACK);
let _ = ppc_write_rgb_color(memory, cpu.gpr[5], color);
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::GetItemIcon => {
// GetItemIcon reads the one-byte icon number stored after the
// item's Pascal text. Macintosh Toolbox Essentials (1992),
// pp. 3-132--3-133.
let icon =
ppc_menu_item_attribute_address(memory, cpu.gpr[3], cpu.gpr[4] as u16 as i16, 0)
.and_then(|address| memory.read_u8(address))
.unwrap_or(0);
let _ = memory.write_u8(cpu.gpr[5], icon);
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::SetItemIcon => {
// SetItemIcon stores only the icon-number byte; the standard
// MDEF resolves resource ID icon+256 when it draws the item.
// Macintosh Toolbox Essentials (1992), pp. 3-137--3-138.
ppc_mutate_menu_items_in_place(memory, handles, cpu.gpr[3], |items| {
items.set_icon(cpu.gpr[4] as u16 as i16, cpu.gpr[5] as u8)
});
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::GetItemStyle => {
// GetItemStyle returns the item's QuickDraw Style byte.
// Macintosh Toolbox Essentials (1992), pp. 3-132--3-133.
let style =
ppc_menu_item_attribute_address(memory, cpu.gpr[3], cpu.gpr[4] as u16 as i16, 3)
.and_then(|address| memory.read_u8(address))
.unwrap_or(0);
let _ = memory.write_u8(cpu.gpr[5], style);
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::SetItemStyle => {
// SetItemStyle replaces the one-byte QuickDraw face bitset used
// by the standard MDEF. Macintosh Toolbox Essentials (1992),
// pp. 3-133--3-134.
ppc_mutate_menu_items_in_place(memory, handles, cpu.gpr[3], |items| {
items.set_style(cpu.gpr[4] as u16 as i16, cpu.gpr[5] as u8)
});
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::OpenPicture => {
let rect = ppc_read_rect(memory, cpu.gpr[3]).unwrap_or((0, 0, 1, 1));
let mut bytes = Vec::from(minimal_pict_bytes());
bytes[2..4].copy_from_slice(&rect.0.to_be_bytes());
bytes[4..6].copy_from_slice(&rect.1.to_be_bytes());
bytes[6..8].copy_from_slice(&rect.2.to_be_bytes());
bytes[8..10].copy_from_slice(&rect.3.to_be_bytes());
let handle = ppc_process_alloc_handle_with_bytes(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
&bytes,
);
*last_mem_error = if handle == 0 {
PPC_MEM_FULL_ERR
} else {
toolbox_startup.open_picture = Some((handle, current_gworld, rect, Vec::new()));
PPC_NO_ERR
};
PpcImportAction::Return(handle)
}
PpcQuickDrawCompatibilityOperation::ClosePicture => {
if let Some((handle, _, frame, commands)) = toolbox_startup.open_picture.take() {
let picture = pict::finish_recording(frame, commands);
let size = u32::try_from(picture.len()).unwrap_or(u32::MAX);
let result = process_memory_manager.set_native_handle_size(memory, handle, size);
ppc_apply_process_native_resource_handle(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
handle,
);
if result == PPC_NO_ERR {
if let Some(ptr) = memory.read_u32_be(handle) {
*last_mem_error = if memory.write_bytes(ptr, &picture).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
}
} else {
*last_mem_error = result;
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::PlotIcon => {
let rect = ppc_read_rect(memory, cpu.gpr[3]);
let icon = ppc_handle_bytes(memory, handles, cpu.gpr[4]);
let surface = ppc_live_quickdraw_surface(memory, gworlds, current_gworld);
if let (Some(rect), Some(icon), Some(surface)) = (rect, icon, surface) {
let front = surface.front_buffer;
let rect = surface.local_rect(rect);
let width = (rect.3 - rect.1).max(0);
let height = (rect.2 - rect.0).max(0);
let fore_pixel =
ppc_quickdraw_surface_fore_pixel(memory, surface, fore_color, fore_index);
if let (true, Some(fore_pixel)) = (
icon.len() >= 128 && width > 0 && height > 0,
fore_pixel,
) {
for y in 0..height {
for x in 0..width {
let sx = (x * 32 / width).clamp(0, 31) as usize;
let sy = (y * 32 / height).clamp(0, 31) as usize;
let bit = icon[sy * 4 + sx / 8] & (0x80 >> (sx & 7)) != 0;
if bit {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(rect.1 + x, rect.0 + y),
fore_pixel,
);
}
}
}
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::CopyPalette => {
let src_palette = cpu.gpr[3];
let dst_palette = cpu.gpr[4];
let src_entry = cpu.gpr[5] as u16 as i16;
let dst_entry = cpu.gpr[6] as u16 as i16;
let dst_length = cpu.gpr[7] as u16 as i16;
if src_palette == 0
|| dst_palette == 0
|| src_entry < 0
|| dst_entry < 0
|| dst_length <= 0
{
return PpcImportAction::ReturnPreserve;
}
let Some(src_ptr) = memory.read_u32_be(src_palette).filter(|ptr| *ptr != 0) else {
return PpcImportAction::ReturnPreserve;
};
let src_count = u32::from(memory.read_u16_be(src_ptr).unwrap_or(0));
let src_entry = u32::from(src_entry as u16);
let dst_entry = u32::from(dst_entry as u16);
let dst_length = u32::from(dst_length as u16);
let mut entries = Vec::new();
for offset in 0..dst_length {
let source = src_entry.saturating_add(offset);
if source >= src_count {
break;
}
let Some(info) = ppc_memory_read_bytes(memory, src_ptr + 16 + source * 16, 10)
else {
break;
};
entries.push(info);
}
let required_entries = dst_entry.saturating_add(dst_length);
let Some(mut dst_ptr) = memory.read_u32_be(dst_palette).filter(|ptr| *ptr != 0) else {
return PpcImportAction::ReturnPreserve;
};
let dst_count = u32::from(memory.read_u16_be(dst_ptr).unwrap_or(0));
if required_entries > dst_count && required_entries <= i16::MAX as u32 {
let size = 16u32.saturating_add(required_entries.saturating_mul(16));
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let result = allocator.resize_handle(
memory,
heap_cursor,
last_mem_error,
handles,
dst_palette,
size,
);
*last_mem_error = result;
if result != PPC_NO_ERR {
return PpcImportAction::ReturnPreserve;
}
let Some(resized_ptr) = memory.read_u32_be(dst_palette).filter(|ptr| *ptr != 0)
else {
return PpcImportAction::ReturnPreserve;
};
dst_ptr = resized_ptr;
let _ = memory.write_u16_be(dst_ptr, required_entries as u16);
}
let dst_count = u32::from(memory.read_u16_be(dst_ptr).unwrap_or(0));
for (offset, info) in entries.into_iter().enumerate() {
let destination = dst_entry.saturating_add(offset as u32);
if destination >= dst_count {
break;
}
let _ = memory.write_bytes(dst_ptr + 16 + destination * 16, &info);
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::NewPalette => {
let entry_count = u32::from(cpu.gpr[3] as u16);
let byte_count = 16u32.saturating_add(entry_count.saturating_mul(16));
let handle = ppc_process_alloc_handle(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
byte_count,
true,
);
*last_mem_error = if handle == 0 {
PPC_MEM_FULL_ERR
} else {
PPC_NO_ERR
};
if let Some(palette_ptr) = (handle != 0)
.then(|| memory.read_u32_be(handle))
.flatten()
.filter(|ptr| *ptr != 0)
{
let _ = memory.write_u16_be(palette_ptr, entry_count as u16);
let src_ctab = memory.read_u32_be(cpu.gpr[4]).filter(|ptr| *ptr != 0);
let src_entries = src_ctab
.and_then(|ptr| memory.read_u16_be(ptr + 6))
.map_or(0, |last| u32::from(last) + 1);
for entry in 0..entry_count {
let info_ptr = palette_ptr + 16 + entry * 16;
if let Some(ctab_ptr) = src_ctab.filter(|_| entry < src_entries) {
let spec_ptr = ctab_ptr + 8 + entry * 8;
for offset in [0, 2, 4] {
if let Some(component) = memory.read_u16_be(spec_ptr + 2 + offset) {
let _ = memory.write_u16_be(info_ptr + offset, component);
}
}
}
let _ = memory.write_u16_be(info_ptr + 6, cpu.gpr[5] as u16);
let _ = memory.write_u16_be(info_ptr + 8, cpu.gpr[6] as u16);
}
}
PpcImportAction::Return(handle)
}
PpcQuickDrawCompatibilityOperation::NewGDevice
| PpcQuickDrawCompatibilityOperation::DisposeGDevice => {
unreachable!("graphics-device imports return through dispatch_graphics_device_import")
}
PpcQuickDrawCompatibilityOperation::DisposePalette => {
// Inside Macintosh Volume VI 1991, p. 20-24: DisposePalette
// releases the relocatable Palette record and its master pointer.
ppc_release_palette_allocations_and_restore(
memory,
toolbox_startup,
cpu.gpr[3],
current_gdevice,
screen_clut,
color_manager_clut,
);
if toolbox_startup.application_palette == cpu.gpr[3] {
toolbox_startup.application_palette = 0;
toolbox_startup.application_palette_updates = 0;
}
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let _ = allocator.dispose_handle(
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
cpu.gpr[3],
);
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::Palette2Ctab => {
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
ppc_palette_to_ctab(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
toolbox_startup,
cpu.gpr[3],
cpu.gpr[4],
);
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::Ctab2Palette => {
let ctable_handle = cpu.gpr[3];
let palette_handle = cpu.gpr[4];
let usage = cpu.gpr[5] as u16;
let tolerance = cpu.gpr[6] as u16;
let Some(ctable_ptr) = memory.read_u32_be(ctable_handle).filter(|ptr| *ptr != 0) else {
return PpcImportAction::ReturnPreserve;
};
if palette_handle == 0 || memory.read_u32_be(palette_handle).unwrap_or(0) == 0 {
return PpcImportAction::ReturnPreserve;
}
// Inside Macintosh Volume VI (1991), p. 20-24: replacing a
// palette from a color table first relinquishes every animated
// device index allocated to that palette.
ppc_release_palette_allocations_and_restore(
memory,
toolbox_startup,
palette_handle,
current_gdevice,
screen_clut,
color_manager_clut,
);
let entry_count = memory
.read_u16_be(ctable_ptr + 6)
.map_or(0, |last| u32::from(last) + 1)
.min(256);
let size = 16u32.saturating_add(entry_count.saturating_mul(16));
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let result = allocator.resize_handle(
memory,
heap_cursor,
last_mem_error,
handles,
palette_handle,
size,
);
*last_mem_error = result;
if result != PPC_NO_ERR {
return PpcImportAction::ReturnPreserve;
}
let Some(palette_ptr) = memory.read_u32_be(palette_handle).filter(|ptr| *ptr != 0)
else {
return PpcImportAction::ReturnPreserve;
};
let _ = memory.write_u16_be(palette_ptr, entry_count as u16);
for entry in 0..entry_count {
let spec_ptr = ctable_ptr + 8 + entry * 8;
let info_ptr = palette_ptr + 16 + entry * 16;
for offset in [0, 2, 4] {
if let Some(component) = memory.read_u16_be(spec_ptr + 2 + offset) {
let _ = memory.write_u16_be(info_ptr + offset, component);
}
}
let _ = memory.write_u16_be(info_ptr + 6, usage);
let _ = memory.write_u16_be(info_ptr + 8, tolerance);
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::GetNewPalette => {
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let palette = ppc_copy_palette_resource(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
cpu.gpr[3] as u16 as i16,
);
if palette != 0 && current_gworld != 0 {
let _ = memory.write_u32_be(
current_gworld + PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET,
palette,
);
let _ =
memory.write_u16_be(current_gworld + PPC_CGRAF_PORT_PALETTE_UPDATES_OFFSET, 1);
}
PpcImportAction::Return(palette)
}
PpcQuickDrawCompatibilityOperation::ScrollRect => {
let rect = ppc_read_rect(memory, cpu.gpr[3]);
let surface = ppc_live_quickdraw_surface(memory, gworlds, current_gworld);
if let (Some(port_rect), Some(surface)) = (rect, surface) {
let front = surface.front_buffer;
if !matches!(front.depth, 1 | 2 | 4 | 8 | 16) {
return PpcImportAction::ReturnPreserve;
}
let requested_rect = surface.local_rect(port_rect);
// ScrollRect operates on the intersection of the requested
// rectangle and the live PixMap. Keep both the source
// snapshot and every destination write inside that
// intersection; otherwise a positive delta can overwrite
// pixels outside r.
let rect = (
requested_rect.0.clamp(0, front.height as i32),
requested_rect.1.clamp(0, front.width as i32),
requested_rect.2.clamp(0, front.height as i32),
requested_rect.3.clamp(0, front.width as i32),
);
let dh = cpu.gpr[4] as u16 as i16 as i32;
let dv = cpu.gpr[5] as u16 as i16 as i32;
if rect.0 < rect.2 && rect.1 < rect.3 {
let width = (rect.3 - rect.1) as usize;
let height = (rect.2 - rect.0) as usize;
let background_pattern = ppc_quickdraw_background_pattern(
memory,
current_gworld,
toolbox_startup.quickdraw_back_pattern,
);
let mut pixels = vec![0; width * height];
for y in rect.0..rect.2 {
for x in rect.1..rect.3 {
if let Some(pixel) = ppc_quickdraw_read_pixel(memory, front, (x, y))
{
pixels[((y - rect.0) as usize) * width + (x - rect.1) as usize] =
pixel;
}
}
}
// Read all pixels before writing any destination pixel so
// overlapping scrolls use the original raster. Exposed
// cells retain the port's background color/pattern pixel.
for y in rect.0..rect.2 {
for x in rect.1..rect.3 {
let src_x = x - dh;
let src_y = y - dv;
let pixel = if src_x >= rect.1
&& src_x < rect.3
&& src_y >= rect.0
&& src_y < rect.2
{
pixels[((src_y - rect.0) as usize) * width
+ (src_x - rect.1) as usize]
} else {
ppc_quickdraw_surface_background_pixel(
memory,
surface,
(x, y),
fore_color,
back_color,
toolbox_startup
.quickdraw_back_indices
.get(¤t_gworld)
.copied(),
background_pattern,
)
.unwrap_or(0)
};
let _ = ppc_quickdraw_write_raw_pixel(memory, front, (x, y), pixel);
}
}
}
if cpu.gpr[6] != 0 {
let top = ppc_i32_to_i16_saturating(i32::from(surface.top) + rect.0);
let left = ppc_i32_to_i16_saturating(i32::from(surface.left) + rect.1);
let bottom = ppc_i32_to_i16_saturating(i32::from(surface.top) + rect.2);
let right = ppc_i32_to_i16_saturating(i32::from(surface.left) + rect.3);
let width = i32::from(right) - i32::from(left);
let height = i32::from(bottom) - i32::from(top);
let horizontal_exposed = dh.unsigned_abs().min(width.max(0) as u32) as i32;
let vertical_exposed = dv.unsigned_abs().min(height.max(0) as u32) as i32;
let mut rows = vec![Vec::new(); height.max(0) as usize];
for row in 0..height.max(0) {
let full_row = (dv > 0 && row < vertical_exposed)
|| (dv < 0 && row >= height - vertical_exposed);
rows[row as usize] = if full_row {
vec![left, right]
} else if horizontal_exposed > 0 && dh > 0 {
vec![
left,
ppc_i32_to_i16_saturating(
i32::from(left) + horizontal_exposed,
),
]
} else if horizontal_exposed > 0 && dh < 0 {
vec![
ppc_i32_to_i16_saturating(
i32::from(right) - horizontal_exposed,
),
right,
]
} else {
Vec::new()
};
}
let storage = ppc_region_storage_from_rows(top, &rows)
.unwrap_or_else(|| vec![0, 10, 0, 0, 0, 0, 0, 0, 0, 0]);
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let _ = ppc_write_region_storage(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
cpu.gpr[6],
&storage,
);
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::CopyMask
| PpcQuickDrawCompatibilityOperation::CopyDeepMask => {
unreachable!("bit-transfer imports return through dispatch_bit_transfer_import")
}
PpcQuickDrawCompatibilityOperation::SetEntryColor => {
// PaletteHandle, entry index, and RGBColor pointer. Inside Macintosh
// Volume VI 1991, p. 20-25.
let palette_handle = cpu.gpr[3];
let entry = cpu.gpr[4] as u16 as i16;
let rgb_ptr = cpu.gpr[5];
if entry >= 0 {
if let Some(palette_ptr) = memory
.read_u32_be(palette_handle)
.filter(|palette_ptr| *palette_ptr != 0)
{
let entry = entry as u32;
if memory
.read_u16_be(palette_ptr)
.is_some_and(|count| entry < u32::from(count))
{
let info_ptr = palette_ptr + 16 + entry * 16;
if let (Some(red), Some(green), Some(blue)) = (
memory.read_u16_be(rgb_ptr),
memory.read_u16_be(rgb_ptr + 2),
memory.read_u16_be(rgb_ptr + 4),
) {
let _ = memory.write_u16_be(info_ptr, red);
let _ = memory.write_u16_be(info_ptr + 2, green);
let _ = memory.write_u16_be(info_ptr + 4, blue);
}
}
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::GetEntryUsage => {
let palette_handle = cpu.gpr[3];
let entry = cpu.gpr[4] as u16 as i16;
if entry >= 0 {
if let Some(palette_ptr) = memory
.read_u32_be(palette_handle)
.filter(|palette_ptr| *palette_ptr != 0)
{
let entry = entry as u32;
if memory
.read_u16_be(palette_ptr)
.is_some_and(|count| entry < u32::from(count))
{
let info_ptr = palette_ptr + 16 + entry * 16;
if let Some(usage) = memory.read_u16_be(info_ptr + 6) {
let _ = memory.write_u16_be(cpu.gpr[5], usage);
}
if let Some(tolerance) = memory.read_u16_be(info_ptr + 8) {
let _ = memory.write_u16_be(cpu.gpr[6], tolerance);
}
}
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::SetEntryUsage => {
// Inside Macintosh Volume VI 1991, pp. 20-24--20-25.
let palette_handle = cpu.gpr[3];
let entry = cpu.gpr[4] as u16 as i16;
if entry >= 0 {
if let Some(palette_ptr) = memory
.read_u32_be(palette_handle)
.filter(|palette_ptr| *palette_ptr != 0)
{
let entry = entry as u32;
if memory
.read_u16_be(palette_ptr)
.is_some_and(|count| entry < u32::from(count))
{
let info_ptr = palette_ptr + 16 + entry * 16;
// Inside Macintosh Volume VI (1991), p. 20-25:
// $FFFF independently preserves the corresponding
// usage or tolerance field.
if cpu.gpr[5] as u16 != u16::MAX {
let _ = memory.write_u16_be(info_ptr + 6, cpu.gpr[5] as u16);
}
if cpu.gpr[6] as u16 != u16::MAX {
let _ = memory.write_u16_be(info_ptr + 8, cpu.gpr[6] as u16);
}
}
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::AnimateEntry => {
let window = cpu.gpr[3];
let entry = usize::from(cpu.gpr[4] as u16);
let assigned_palette = memory
.read_u32_be(window.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET))
.unwrap_or(0);
let palette = if assigned_palette != 0 {
assigned_palette
} else {
toolbox_startup.application_palette
};
let palette_ptr = memory.read_u32_be(palette).unwrap_or(0);
let info = palette_ptr.wrapping_add(16 + entry as u32 * 16);
let usage = memory.read_u16_be(info + 6).unwrap_or(0);
if usage & 0x0004 != 0 {
let allocations = toolbox_startup
.palette_allocations
.iter()
.filter(|allocation| allocation.palette == palette)
.filter_map(|allocation| {
allocation
.entry_mappings
.get(entry)
.copied()
.and_then(PpcPaletteEntryMapping::animated_index)
.map(|index| (allocation.gdevice, index))
})
.collect::<Vec<_>>();
if let Some(color) =
ppc_read_rgb_color(memory, cpu.gpr[5]).filter(|_| !allocations.is_empty())
{
let _ = ppc_write_rgb_color(memory, info, color);
for (gdevice, index) in allocations {
let slot = usize::from(index);
if gdevice == current_gdevice {
screen_clut[slot] = [color.red, color.green, color.blue];
color_manager_clut[slot] = [color.red, color.green, color.blue];
}
if let Some(table) = ppc_gdevice_ctable_handle(memory, gdevice)
.and_then(|handle| memory.read_u32_be(handle))
.filter(|ptr| *ptr != 0)
{
let _ = ppc_write_rgb_color(
memory,
table + 10 + u32::from(index) * 8,
color,
);
}
}
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::AnimatePalette => {
// Inside Macintosh Volume VI (1991), pp. 20-22--20-23:
// copy a source ColorTable range into animated destination
// palette entries and immediately update their device indexes.
let window = cpu.gpr[3];
let ctable_handle = cpu.gpr[4];
let src_index = u32::from(cpu.gpr[5] as u16);
let dst_entry = u32::from(cpu.gpr[6] as u16);
let dst_length = u32::from(cpu.gpr[7] as u16);
let assigned_palette = memory
.read_u32_be(window + PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET)
.unwrap_or(0);
let palette_handle = if assigned_palette != 0 {
assigned_palette
} else {
toolbox_startup.application_palette
};
let palette_ptr = memory.read_u32_be(palette_handle).unwrap_or(0);
let ctable_ptr = memory.read_u32_be(ctable_handle).unwrap_or(0);
let palette_count = u32::from(memory.read_u16_be(palette_ptr).unwrap_or(0));
let source_count = memory
.read_u16_be(ctable_ptr + 6)
.map_or(0, |last| u32::from(last) + 1);
for offset in 0..dst_length {
let source = src_index + offset;
let destination = dst_entry + offset;
if source >= source_count || destination >= palette_count {
break;
}
let spec_ptr = ctable_ptr + 8 + source * 8;
let info_ptr = palette_ptr + 16 + destination * 16;
let usage = memory.read_u16_be(info_ptr + 6).unwrap_or(0);
if usage & 0x0004 == 0 {
continue;
}
let destination = destination as usize;
let allocations = toolbox_startup
.palette_allocations
.iter()
.filter(|allocation| allocation.palette == palette_handle)
.filter_map(|allocation| {
allocation
.entry_mappings
.get(destination)
.copied()
.and_then(PpcPaletteEntryMapping::animated_index)
.map(|index| (allocation.gdevice, index))
})
.collect::<Vec<_>>();
if allocations.is_empty() {
continue;
}
let Some(color) = ppc_read_rgb_color(memory, spec_ptr + 2) else {
break;
};
let _ = ppc_write_rgb_color(memory, info_ptr, color);
let rgb = [color.red, color.green, color.blue];
// Inside Macintosh Volume VI (1991), pp. 20-22--20-23:
// animation changes only the RGB at the reserved device
// index. It is not a color-environment change, so preserve
// the table seed, ColorSpec.value metadata, and all other
// entries.
for (gdevice, index) in allocations {
if let Some(device_ctable) = ppc_gdevice_ctable_handle(memory, gdevice)
.and_then(|handle| memory.read_u32_be(handle))
.filter(|ptr| *ptr != 0)
{
let device_spec = device_ctable + 8 + u32::from(index) * 8;
let _ = ppc_write_rgb_color(memory, device_spec + 2, color);
}
if gdevice == current_gdevice {
screen_clut[usize::from(index)] = rgb;
color_manager_clut[usize::from(index)] = rgb;
}
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::PenPat => {
let mut pattern = [0; 8];
if memory.read_bytes_into(cpu.gpr[3], &mut pattern).is_some() {
// Imaging With QuickDraw (1994), pp. 3-38--3-40: PenPat
// installs the 8-by-8 bit pattern used by Paint and Frame
// shape operations. A set bit selects the foreground color;
// a clear bit selects the background color.
toolbox_startup.quickdraw_pen_pattern = pattern;
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::BackPat => {
let mut pattern = [0u8; 8];
if memory.read_bytes_into(cpu.gpr[3], &mut pattern).is_some() {
// BackPat changes the legacy pattern used to fill exposed
// ScrollRect pixels. A prior PixPat must not continue to
// shadow the newly installed Pattern (IM:V V-72).
toolbox_startup.quickdraw_back_pattern = pattern;
let _ = memory.write_u32_be(
current_gworld.wrapping_add(PPC_CGRAF_PORT_BK_PIXPAT_OFFSET),
0,
);
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::BackPixPat => {
let pattern_handle = cpu.gpr[3];
if pattern_handle != 0 {
// Keep the handle in the live CGrafPort so subsequent
// ScrollRect calls see exactly the PixPat selected by the
// application. Its pat1Data shadow is used by the common
// monochrome fallback path.
let _ = memory.write_u32_be(
current_gworld.wrapping_add(PPC_CGRAF_PORT_BK_PIXPAT_OFFSET),
pattern_handle,
);
if let Some(pattern_ptr) = memory
.read_u32_be(pattern_handle)
.filter(|ptr| *ptr != 0)
{
let mut pattern = [0u8; 8];
if memory
.read_bytes_into(pattern_ptr.wrapping_add(20), &mut pattern)
.is_some()
{
toolbox_startup.quickdraw_back_pattern = pattern;
}
}
}
PpcImportAction::ReturnPreserve
}
PpcQuickDrawCompatibilityOperation::SetStdCProcs
| PpcQuickDrawCompatibilityOperation::SetStdProcs
| PpcQuickDrawCompatibilityOperation::Exp1To3
| PpcQuickDrawCompatibilityOperation::Exp1To6 => {
PpcImportAction::ReturnPreserve
}
}
}
fn ppc_munger_compatibility(
cpu: &PpcCpu,
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> u32 {
let handle = cpu.gpr[3];
let offset = cpu.gpr[4] as i32;
let search_len = cpu.gpr[6] as i32;
let replacement_len = cpu.gpr[8] as i32;
if offset < 0 || search_len < 0 || replacement_len < 0 {
return u32::MAX;
}
let Some(mut contents) = ppc_handle_bytes(memory, handles, handle) else {
*last_mem_error = PPC_NIL_HANDLE_ERR;
return u32::MAX;
};
let start = offset as usize;
if start > contents.len() {
return u32::MAX;
}
let Some(needle) = ppc_memory_read_bytes(memory, cpu.gpr[5], search_len as u32)
.or_else(|| (search_len == 0).then(Vec::new))
else {
return u32::MAX;
};
let position = if needle.is_empty() {
Some(start)
} else {
contents[start..]
.windows(needle.len())
.position(|window| window == needle)
.map(|relative| start + relative)
};
let Some(position) = position else {
return u32::MAX;
};
if cpu.gpr[7] == 0 && replacement_len == 0 {
return u32::try_from(position).unwrap_or(u32::MAX);
}
let Some(replacement) = ppc_memory_read_bytes(memory, cpu.gpr[7], replacement_len as u32)
.or_else(|| (replacement_len == 0).then(Vec::new))
else {
return u32::MAX;
};
contents.splice(position..position + needle.len(), replacement);
let result = ppc_allocator_view_resize_handle(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
u32::try_from(contents.len()).unwrap_or(u32::MAX),
);
*last_mem_error = result;
if result != PPC_NO_ERR {
return u32::MAX;
}
let Some(ptr) = memory.read_u32_be(handle) else {
return u32::MAX;
};
if memory.write_bytes(ptr, &contents).is_none() {
*last_mem_error = PPC_PARAM_ERR;
return u32::MAX;
}
u32::try_from(position).unwrap_or(u32::MAX)
}
fn ppc_enqueue_compatibility(memory: &mut PpcSectionMem, element: u32, header: u32) -> bool {
if element == 0
|| header == 0
|| !ppc_memory_can_write_bytes(memory, element, 4)
|| !ppc_memory_can_write_bytes(memory, header, 10)
{
return false;
}
let tail = memory.read_u32_be(header + 6).unwrap_or(0);
let _ = memory.write_u32_be(element, 0);
if tail == 0 {
let _ = memory.write_u32_be(header + 2, element);
} else {
let _ = memory.write_u32_be(tail, element);
}
memory.write_u32_be(header + 6, element).is_some()
}
fn ppc_dequeue_compatibility(memory: &mut PpcSectionMem, element: u32, header: u32) -> i16 {
if element == 0 || header == 0 || !ppc_memory_can_write_bytes(memory, header, 10) {
return PPC_PARAM_ERR;
}
let mut previous = 0;
let mut current = memory.read_u32_be(header + 2).unwrap_or(0);
while current != 0 {
let next = memory.read_u32_be(current).unwrap_or(0);
if current == element {
if previous == 0 {
let _ = memory.write_u32_be(header + 2, next);
} else {
let _ = memory.write_u32_be(previous, next);
}
if memory.read_u32_be(header + 6) == Some(element) {
let _ = memory.write_u32_be(header + 6, previous);
}
let _ = memory.write_u32_be(element, 0);
return PPC_NO_ERR;
}
previous = current;
current = next;
}
-1
}
#[allow(clippy::too_many_arguments)]
fn ppc_dispatch_system_compatibility(
operation: PpcSystemCompatibilityOperation,
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
launched_app_path: Option<&str>,
) -> PpcImportAction {
match operation {
PpcSystemCompatibilityOperation::Munger => {
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
PpcImportAction::Return(ppc_munger_compatibility(
cpu,
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
))
}
PpcSystemCompatibilityOperation::Enqueue => {
let _ = ppc_enqueue_compatibility(memory, cpu.gpr[3], cpu.gpr[4]);
PpcImportAction::ReturnPreserve
}
PpcSystemCompatibilityOperation::Dequeue => PpcImportAction::Return(ppc_i16_result(ppc_dequeue_compatibility(
memory, cpu.gpr[3], cpu.gpr[4],
))),
// ObscureCursor has no effect on the cursor level. It hides the cursor
// only until the user moves the mouse, which the host injects each frame.
// PROCEDURE ObscureCursor;
// Inside Macintosh Volume I, I-168.
PpcSystemCompatibilityOperation::ObscureCursor => PpcImportAction::ReturnPreserve,
PpcSystemCompatibilityOperation::UpperString => {
if let Some(bytes) = ppc_read_pstring_bytes(memory, cpu.gpr[3]) {
let upper = bytes
.into_iter()
.map(|byte| byte.to_ascii_uppercase())
.collect::<Vec<_>>();
let _ = ppc_write_pstring_bytes(memory, cpu.gpr[3], &upper);
}
PpcImportAction::ReturnPreserve
}
PpcSystemCompatibilityOperation::IuCompString => {
let lhs = ppc_read_pstring_bytes(memory, cpu.gpr[3]).unwrap_or_default();
let rhs = ppc_read_pstring_bytes(memory, cpu.gpr[4]).unwrap_or_default();
let lhs = lhs
.into_iter()
.map(|byte| byte.to_ascii_uppercase())
.collect::<Vec<_>>();
let rhs = rhs
.into_iter()
.map(|byte| byte.to_ascii_uppercase())
.collect::<Vec<_>>();
let ordering = match lhs.cmp(&rhs) {
std::cmp::Ordering::Less => -1i16,
std::cmp::Ordering::Equal => 0,
std::cmp::Ordering::Greater => 1,
};
PpcImportAction::Return(ppc_i16_result(ordering))
}
PpcSystemCompatibilityOperation::TruncText => {
let width = usize::from(cpu.gpr[3] as u16);
let text = cpu.gpr[4];
let length_ptr = cpu.gpr[5];
let Some(length) = memory.read_u16_be(length_ptr).map(usize::from) else {
return PpcImportAction::Return(ppc_i16_result(-1));
};
let capacity = width / 6;
if length <= capacity {
return PpcImportAction::Return(0);
}
if capacity < 3 || !ppc_memory_can_write_bytes(memory, text, length as u32) {
return PpcImportAction::Return(ppc_i16_result(-1));
}
let retained = capacity - 3;
if cpu.gpr[6] & 0x4000 != 0 {
let left = retained / 2;
let right = retained - left;
let tail = (0..right)
.filter_map(|index| memory.read_u8(text + (length - right + index) as u32))
.collect::<Vec<_>>();
let _ = memory.write_bytes(text + left as u32, b"...");
let _ = memory.write_bytes(text + left as u32 + 3, &tail);
} else {
let _ = memory.write_bytes(text + retained as u32, b"...");
}
let _ = memory.write_u16_be(length_ptr, capacity as u16);
PpcImportAction::Return(1)
}
PpcSystemCompatibilityOperation::StyledLineBreak => {
let text_len = cpu.gpr[4];
let text_end = cpu.gpr[6].min(text_len);
let width_ptr = cpu.gpr[8];
let offset_ptr = cpu.gpr[9];
let width = memory.read_u32_be(width_ptr).unwrap_or(0) as i32;
let available_chars = (width.max(0) as u32 / (6 << 16)).max(1);
if text_end <= available_chars {
let _ = memory.write_u32_be(offset_ptr, text_end);
let used = text_end.saturating_mul(6 << 16);
let _ = memory.write_u32_be(width_ptr, (width as u32).saturating_sub(used));
PpcImportAction::Return(2)
} else {
let break_at = available_chars.min(text_end);
let _ = memory.write_u32_be(offset_ptr, break_at);
let _ = memory.write_u32_be(width_ptr, 0);
PpcImportAction::Return(1)
}
}
PpcSystemCompatibilityOperation::GetNextProcess => {
let psn = cpu.gpr[3];
let current = ProcessSerialNumber::new(
memory.read_u32_be(psn).unwrap_or(u32::MAX),
memory.read_u32_be(psn + 4).unwrap_or(u32::MAX),
);
match current.next_single_process() {
SingleProcessEnumeration::Current(current) => {
let _ = memory.write_u32_be(psn, current.high);
let _ = memory.write_u32_be(psn + 4, current.low);
PpcImportAction::Return(0)
}
SingleProcessEnumeration::End | SingleProcessEnumeration::Invalid => {
PpcImportAction::Return(ppc_i16_result(PPC_PROC_NOT_FOUND_ERR))
}
}
}
PpcSystemCompatibilityOperation::SetFrontProcess => PpcImportAction::Return(0),
PpcSystemCompatibilityOperation::LmGetCurApName => {
let name = launched_app_path
.and_then(|path| path.rsplit('/').next())
.unwrap_or("Systemless");
let encoded = encode_mac_roman_lossy(name);
let _ = ppc_write_pstring_bytes(memory, PPC_IMPORT_CUR_AP_NAME, &encoded);
PpcImportAction::Return(PPC_IMPORT_CUR_AP_NAME)
}
PpcSystemCompatibilityOperation::LmGetSysFontFam => PpcImportAction::Return(0),
PpcSystemCompatibilityOperation::LmGetSysFontSize => PpcImportAction::Return(12),
PpcSystemCompatibilityOperation::LmGetSfSaveDisk => PpcImportAction::Return(0),
PpcSystemCompatibilityOperation::GetSysBeepVolume => {
let result = if memory.write_u32_be(cpu.gpr[3], 0x0100_0100).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
PpcImportAction::Return(ppc_i16_result(result))
}
PpcSystemCompatibilityOperation::IuDateString => {
let _ = ppc_write_pstring_bytes(memory, cpu.gpr[5], b"");
PpcImportAction::ReturnPreserve
}
PpcSystemCompatibilityOperation::SystemEdit
| PpcSystemCompatibilityOperation::DiBadMount => PpcImportAction::Return(0),
PpcSystemCompatibilityOperation::FindNextComponent
| PpcSystemCompatibilityOperation::OpenDefaultComponent => PpcImportAction::Return(0),
PpcSystemCompatibilityOperation::CtbGetCtbVersion => PpcImportAction::Return(0x0200),
PpcSystemCompatibilityOperation::GetScriptManagerVariable
| PpcSystemCompatibilityOperation::GetScriptVariable
| PpcSystemCompatibilityOperation::GetScript
| PpcSystemCompatibilityOperation::KeyTranslate
| PpcSystemCompatibilityOperation::CallComponentUpp => PpcImportAction::Return(0),
PpcSystemCompatibilityOperation::LaunchApplication => {
PpcImportAction::Return(ppc_i16_result(PPC_PROC_NOT_FOUND_ERR))
}
PpcSystemCompatibilityOperation::BuildDdPwds => PpcImportAction::ReturnPreserve,
PpcSystemCompatibilityOperation::MidiAddPort
| PpcSystemCompatibilityOperation::MidiRemovePort
| PpcSystemCompatibilityOperation::MidiSignOut
| PpcSystemCompatibilityOperation::MidiWritePacket => {
PpcImportAction::Return(ppc_i16_result(PPC_NOT_ENOUGH_HARDWARE_ERR))
}
PpcSystemCompatibilityOperation::DiLoad
| PpcSystemCompatibilityOperation::DiUnload
| PpcSystemCompatibilityOperation::Debugger
| PpcSystemCompatibilityOperation::InitCrm
| PpcSystemCompatibilityOperation::InitCtbUtilities
| PpcSystemCompatibilityOperation::NmRemove
| PpcSystemCompatibilityOperation::ResetAlertStage => PpcImportAction::ReturnPreserve,
}
}
fn ppc_dispatch_appletalk_compatibility(
operation: PpcAppleTalkCompatibilityOperation,
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
) -> PpcImportAction {
match operation {
PpcAppleTalkCompatibilityOperation::NbpSetEntity => {
let mut offset = 0u32;
for source in [cpu.gpr[4], cpu.gpr[5], cpu.gpr[6]] {
let bytes = ppc_read_pstring_bytes(memory, source).unwrap_or_default();
let bytes = &bytes[..bytes.len().min(32)];
let _ = memory.write_u8(cpu.gpr[3] + offset, bytes.len() as u8);
let _ = memory.write_bytes(cpu.gpr[3] + offset + 1, bytes);
offset = offset.saturating_add(33);
}
PpcImportAction::ReturnPreserve
}
PpcAppleTalkCompatibilityOperation::GetNodeAddress => {
let _ = memory.write_u8(cpu.gpr[3], 0);
let _ = memory.write_u16_be(cpu.gpr[4], 0);
PpcImportAction::Return(ppc_i16_result(PPC_NO_MPP_ERR))
}
PpcAppleTalkCompatibilityOperation::GetBridgeAddress => PpcImportAction::Return(0),
PpcAppleTalkCompatibilityOperation::GetZoneList
| PpcAppleTalkCompatibilityOperation::MppOpen
| PpcAppleTalkCompatibilityOperation::NbpExtract
| PpcAppleTalkCompatibilityOperation::NbpSetNte
| PpcAppleTalkCompatibilityOperation::PCloseSkt
| PpcAppleTalkCompatibilityOperation::PKillNbp
| PpcAppleTalkCompatibilityOperation::PLookupName
| PpcAppleTalkCompatibilityOperation::POpenSkt
| PpcAppleTalkCompatibilityOperation::PRegisterName
| PpcAppleTalkCompatibilityOperation::PRemoveName
| PpcAppleTalkCompatibilityOperation::PSetSelfSend
| PpcAppleTalkCompatibilityOperation::PWriteDdp
| PpcAppleTalkCompatibilityOperation::StandardNbp => {
if cpu.gpr[3] != 0 {
let _ = memory.write_u16_be(cpu.gpr[3] + 16, PPC_NO_MPP_ERR as u16);
}
PpcImportAction::Return(ppc_i16_result(PPC_NO_MPP_ERR))
}
}
}
fn ppc_dispatch_printing_compatibility(
operation: PpcPrintingCompatibilityOperation,
) -> PpcImportAction {
match operation {
PpcPrintingCompatibilityOperation::PrJobDialog
| PpcPrintingCompatibilityOperation::PrStlDialog
| PpcPrintingCompatibilityOperation::PrOpenDoc => PpcImportAction::Return(0),
PpcPrintingCompatibilityOperation::PrError
| PpcPrintingCompatibilityOperation::PrintDefault => {
PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR))
}
PpcPrintingCompatibilityOperation::PrClose
| PpcPrintingCompatibilityOperation::PrCloseDoc
| PpcPrintingCompatibilityOperation::PrClosePage
| PpcPrintingCompatibilityOperation::PrOpen
| PpcPrintingCompatibilityOperation::PrOpenPage
| PpcPrintingCompatibilityOperation::PrPicFile => PpcImportAction::ReturnPreserve,
}
}
fn ppc_dispatch_slot_compatibility(
_binding: &PpcImportBinding,
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
) -> PpcImportAction {
if cpu.gpr[3] != 0 {
let _ = memory.write_u32_be(cpu.gpr[3], 0);
}
PpcImportAction::Return(ppc_i16_result(PPC_SM_NO_MORE_SRSRCS_ERR))
}
fn ppc_dispatch_sound_input_compatibility(
operation: PpcSoundInputCompatibilityOperation,
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
) -> PpcImportAction {
if operation == PpcSoundInputCompatibilityOperation::OpenDevice && cpu.gpr[5] != 0 {
let _ = memory.write_u32_be(cpu.gpr[5], 0);
}
PpcImportAction::Return(ppc_i16_result(PPC_NOT_ENOUGH_HARDWARE_ERR))
}
fn ppc_dispatch_speech_compatibility(
operation: PpcSpeechCompatibilityOperation,
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
) -> PpcImportAction {
match operation {
PpcSpeechCompatibilityOperation::CountVoices => {
let result = if memory.write_u16_be(cpu.gpr[3], 0).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
PpcImportAction::Return(ppc_i16_result(result))
}
PpcSpeechCompatibilityOperation::SpeechBusy => PpcImportAction::Return(0),
PpcSpeechCompatibilityOperation::DisposeSpeechChannel => {
PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR))
}
PpcSpeechCompatibilityOperation::NewSpeechChannel => {
if cpu.gpr[4] != 0 {
let _ = memory.write_u32_be(cpu.gpr[4], 0);
}
PpcImportAction::Return(ppc_i16_result(PPC_NOT_ENOUGH_HARDWARE_ERR))
}
PpcSpeechCompatibilityOperation::GetIndVoice
| PpcSpeechCompatibilityOperation::GetVoiceDescription
| PpcSpeechCompatibilityOperation::SpeakString
| PpcSpeechCompatibilityOperation::SpeakText => {
PpcImportAction::Return(ppc_i16_result(PPC_NOT_ENOUGH_HARDWARE_ERR))
}
}
}
fn ppc_dispatch_input_sprocket_compatibility(
operation: PpcInputSprocketCompatibilityOperation,
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
input_sprocket: &mut PpcInputSprocketState,
virtual_elements: &mut Vec<PpcInputSprocketVirtualElementRecord>,
) -> PpcImportAction {
match operation {
PpcInputSprocketCompatibilityOperation::DevicesActivateClass => {
input_sprocket.keyboard_active = true;
input_sprocket.mouse_active = true;
PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR))
}
PpcInputSprocketCompatibilityOperation::ElementDisposeVirtual => {
virtual_elements.retain(|element| element.element != cpu.gpr[3]);
input_sprocket.virtual_element_count =
u32::try_from(virtual_elements.len()).unwrap_or(u32::MAX);
PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR))
}
PpcInputSprocketCompatibilityOperation::ElementGetNextEvent => {
if cpu.gpr[4] != 0 {
let _ = memory.write_u32_be(cpu.gpr[4], 0);
}
PpcImportAction::Return(0)
}
PpcInputSprocketCompatibilityOperation::ElementFlush
| PpcInputSprocketCompatibilityOperation::Tickle => {
PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR))
}
}
}
mod math_compatibility;
use math_compatibility::*;
fn ppc_math_ceil(cpu: &mut PpcCpu) {
// Inside Macintosh: PowerPC Numerics (1994), pp. 9-7--9-8:
// ceil rounds upward without an inexact exception and preserves signed
// zero, infinities, and quiet NaNs. A signaling NaN raises invalid and
// returns the corresponding quiet NaN.
const EXPONENT_MASK: u64 = 0x7ff0_0000_0000_0000;
const FRACTION_MASK: u64 = 0x000f_ffff_ffff_ffff;
const QUIET_NAN_BIT: u64 = 0x0008_0000_0000_0000;
let bits = cpu.fpr[1];
let signaling_nan = bits & EXPONENT_MASK == EXPONENT_MASK
&& bits & FRACTION_MASK != 0
&& bits & QUIET_NAN_BIT == 0;
if signaling_nan {
cpu.fpr[1] = bits | QUIET_NAN_BIT;
cpu.set_fpscr_bit(0, true);
cpu.set_fpscr_bit(2, true);
cpu.set_fpscr_bit(7, true);
if cpu.fpscr_bit(24) {
cpu.set_fpscr_bit(1, true);
}
} else {
cpu.fpr[1] = f64::from_bits(bits).ceil().to_bits();
}
}
fn ppc_math_fmod(cpu: &mut PpcCpu) {
// The PowerPC C ABI passes the two double arguments in f1/f2 and returns
// the remainder in f1. Rust's floating remainder has C fmod semantics:
// its magnitude is less than the divisor and its sign follows the dividend.
let dividend = f64::from_bits(cpu.fpr[1]);
let divisor = f64::from_bits(cpu.fpr[2]);
cpu.fpr[1] = (dividend % divisor).to_bits();
}
fn ppc_stdio_stream_info<'a>(
stream: u32,
stdio_streams: &'a HashMap<u32, PpcStdioStreamRecord>,
vfs_files: &[PpcVfsFileRecord],
) -> Option<(bool, Option<i16>, u32, Option<&'a str>, usize)> {
let record = stdio_streams.get(&stream)?;
if record.closed {
return None;
}
if record.standard {
return Some((true, record.ref_num, record.position, None, 0));
}
let path = record.path.as_ref()?;
let data_len = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(path))?
.data
.len();
Some((
false,
record.ref_num,
record.position,
Some(path.as_str()),
data_len,
))
}
fn ppc_stdio_set_position(
stream: u32,
position: u32,
stdio_streams: &mut HashMap<u32, PpcStdioStreamRecord>,
files: &mut [PpcFileRecord],
) {
let ref_num = stdio_streams.get_mut(&stream).and_then(|record| {
record.position = position;
record.ref_num
});
if let Some(ref_num) = ref_num {
if let Some(file) = files.iter_mut().find(|file| file.ref_num == ref_num) {
file.position = position;
}
}
}
fn ppc_stdio_set_error(stream: u32, stdio_streams: &mut HashMap<u32, PpcStdioStreamRecord>) {
if let Some(record) = stdio_streams.get_mut(&stream) {
record.error = true;
}
}
#[allow(clippy::too_many_arguments)]
#[cfg(test)]
fn ppc_dispatch_stdio_compatibility(
operation: PpcStdIoOperation,
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
files: &mut Vec<PpcFileRecord>,
vfs_files: &mut ProcessVfsFileRecords,
next_file_ref_num: &mut i16,
stdio_streams: &mut HashMap<u32, PpcStdioStreamRecord>,
) -> PpcImportAction {
let mut writable_refnums = HashSet::new();
ppc_dispatch_stdio_compatibility_with_manager(
operation,
cpu,
None,
memory,
heap_cursor,
heap_limit,
files,
&mut writable_refnums,
vfs_files,
next_file_ref_num,
stdio_streams,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_dispatch_process_stdio_compatibility(
operation: PpcStdIoOperation,
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
files: &mut Vec<PpcFileRecord>,
writable_refnums: &mut HashSet<u16>,
vfs_files: &mut ProcessVfsFileRecords,
next_file_ref_num: &mut i16,
stdio_streams: &mut HashMap<u32, PpcStdioStreamRecord>,
) -> PpcImportAction {
ppc_dispatch_stdio_compatibility_with_manager(
operation,
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
files,
writable_refnums,
vfs_files,
next_file_ref_num,
stdio_streams,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_dispatch_stdio_compatibility_with_manager(
operation: PpcStdIoOperation,
cpu: &mut PpcCpu,
mut process_memory_manager: Option<&mut ProcessNativeMemoryManager>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
files: &mut Vec<PpcFileRecord>,
writable_refnums: &mut HashSet<u16>,
vfs_files: &mut ProcessVfsFileRecords,
next_file_ref_num: &mut i16,
stdio_streams: &mut HashMap<u32, PpcStdioStreamRecord>,
) -> PpcImportAction {
let stream = cpu.gpr[3];
match operation {
PpcStdIoOperation::FileOpen => {
let mode = ppc_std_c_string(memory, cpu.gpr[4], 16);
let Some(&mode_kind @ (b'r' | b'w' | b'a')) = mode.first() else {
return PpcImportAction::Return(0);
};
let mode_flags = &mode[1..];
if !mode_flags.iter().all(|byte| matches!(byte, b'+' | b'b')) {
return PpcImportAction::Return(0);
}
let plus_mode = mode_flags.contains(&b'+');
let readable = mode_kind == b'r' || plus_mode;
let writable = mode_kind != b'r' || plus_mode;
let creates_if_missing = matches!(mode_kind, b'w' | b'a');
let append_mode = mode_kind == b'a';
let requested = decode_mac_roman(&ppc_std_c_string(memory, cpu.gpr[3], 1024));
let normalized = ppc_normalize_vfs_path(&requested);
if normalized.is_empty() {
return PpcImportAction::Return(0);
}
let existing_path = ppc_vfs_file_or_resource_path(vfs_files, &[], &normalized)
.or_else(|| ppc_vfs_file_or_resource_path_by_basename(vfs_files, &[], &normalized));
let path = existing_path.or_else(|| creates_if_missing.then(|| normalized.clone()));
let Some(path) = path else {
return PpcImportAction::Return(0);
};
let ref_num = *next_file_ref_num;
let Some(next_ref_num) = next_file_ref_num.checked_add(1) else {
return PpcImportAction::Return(0);
};
let stream_ptr = if let Some(memory_manager) = process_memory_manager.as_deref_mut() {
ppc_process_heap_alloc(
memory_manager,
memory,
heap_cursor,
PPC_STDIO_FILE_SIZE,
true,
)
} else {
ppc_heap_alloc(memory, heap_cursor, heap_limit, PPC_STDIO_FILE_SIZE, true)
};
if stream_ptr == 0 {
return PpcImportAction::Return(0);
}
if vfs_files
.iter()
.all(|file| !file.path.eq_ignore_ascii_case(&path))
{
vfs_files.push(PpcVfsFileRecord {
path: path.clone(),
data: Vec::new().into(),
creator: 0,
file_type: 0,
finder_flags: 0,
dirty: true,
});
}
if mode_kind == b'w' {
if let Some(file) = ppc_vfs_file_mut(vfs_files, &path) {
file.data.with_mut(Vec::clear);
file.dirty = true;
}
}
let position = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(&path))
.map(|file| {
if append_mode {
u32::try_from(file.data.len()).unwrap_or(u32::MAX)
} else {
0
}
})
.unwrap_or(0);
files.push(PpcFileRecord {
ref_num,
path: path.clone(),
position,
});
if writable {
writable_refnums.insert(ref_num as u16);
}
stdio_streams.insert(
stream_ptr,
PpcStdioStreamRecord {
ref_num: Some(ref_num),
path: Some(path),
position,
standard: false,
readable,
writable,
append: append_mode,
closed: false,
eof: false,
error: false,
},
);
*next_file_ref_num = next_ref_num;
PpcImportAction::Return(stream_ptr)
}
PpcStdIoOperation::FileClose => {
let Some(record) = stdio_streams.get_mut(&stream) else {
return PpcImportAction::Return(u32::MAX);
};
if record.closed {
return PpcImportAction::Return(u32::MAX);
}
record.closed = true;
if !record.standard {
if let Some(ref_num) = record.ref_num {
files.retain(|file| file.ref_num != ref_num);
writable_refnums.remove(&(ref_num as u16));
}
}
PpcImportAction::Return(0)
}
PpcStdIoOperation::FileRead | PpcStdIoOperation::FileWrite => {
let destination = cpu.gpr[3];
let element_size = cpu.gpr[4];
let element_count = cpu.gpr[5];
let stream = cpu.gpr[6];
if element_size == 0 || element_count == 0 {
return PpcImportAction::Return(0);
}
let Some(total) = element_size.checked_mul(element_count) else {
return PpcImportAction::Return(0);
};
let Some(record) = stdio_streams.get(&stream).filter(|record| !record.closed) else {
return PpcImportAction::Return(0);
};
let permitted = if operation == PpcStdIoOperation::FileRead {
record.readable
} else {
record.writable
};
if !permitted {
ppc_stdio_set_error(stream, stdio_streams);
return PpcImportAction::Return(0);
}
let Some((standard, _ref_num, position, path, data_len)) =
ppc_stdio_stream_info(stream, stdio_streams, vfs_files)
else {
return PpcImportAction::Return(0);
};
if standard {
if operation == PpcStdIoOperation::FileWrite
&& !ppc_memory_can_read_bytes(memory, destination, total)
{
ppc_stdio_set_error(stream, stdio_streams);
return PpcImportAction::Return(0);
}
return PpcImportAction::Return(if operation == PpcStdIoOperation::FileWrite {
element_count
} else {
0
});
}
if operation == PpcStdIoOperation::FileRead {
let start = usize::try_from(position)
.unwrap_or(usize::MAX)
.min(data_len);
let requested = usize::try_from(total).unwrap_or(usize::MAX);
let read_len = requested.min(data_len.saturating_sub(start));
if read_len > 0
&& !ppc_memory_can_write_bytes(
memory,
destination,
u32::try_from(read_len).unwrap_or(u32::MAX),
)
{
return PpcImportAction::Return(0);
}
let Some(data) = path.and_then(|path| {
vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(path))
.map(|record| record.data.as_slice())
}) else {
return PpcImportAction::Return(0);
};
if memory
.write_bytes(destination, &data[start..start + read_len])
.is_none()
{
return PpcImportAction::Return(0);
}
let new_position = position.saturating_add(read_len as u32);
ppc_stdio_set_position(stream, new_position, stdio_streams, files);
if read_len < requested {
if let Some(record) = stdio_streams.get_mut(&stream) {
record.eof = true;
}
}
PpcImportAction::Return(
u32::try_from(read_len / element_size as usize).unwrap_or(0),
)
} else {
if !ppc_memory_can_read_bytes(memory, destination, total) {
return PpcImportAction::Return(0);
}
let bytes = ppc_memory_read_bytes(memory, destination, total).unwrap_or_default();
let Some(path) = stdio_streams
.get(&stream)
.and_then(|record| record.path.clone())
else {
return PpcImportAction::Return(0);
};
let Some(file) = ppc_vfs_file_mut(vfs_files, &path) else {
return PpcImportAction::Return(0);
};
let position = if stdio_streams
.get(&stream)
.is_some_and(|record| record.append)
{
u32::try_from(file.data.len()).unwrap_or(u32::MAX)
} else {
position
};
let start = usize::try_from(position).unwrap_or(usize::MAX);
let end = start.saturating_add(bytes.len());
file.data.with_mut(|data| {
if start > data.len() {
data.resize(start, 0);
}
if end > data.len() {
data.resize(end, 0);
}
data[start..end].copy_from_slice(&bytes);
});
file.dirty = true;
let new_position = u32::try_from(end).unwrap_or(u32::MAX);
ppc_stdio_set_position(stream, new_position, stdio_streams, files);
PpcImportAction::Return(element_count)
}
}
PpcStdIoOperation::FileSeek => {
let offset = cpu.gpr[4] as i32 as i64;
let whence = cpu.gpr[5];
let Some((standard, _ref_num, position, _path, data_len)) =
ppc_stdio_stream_info(stream, stdio_streams, vfs_files)
else {
return PpcImportAction::Return(u32::MAX);
};
if standard {
return PpcImportAction::Return(u32::MAX);
}
let base = match whence {
0 => 0,
1 => i64::from(position),
2 => i64::try_from(data_len).unwrap_or(i64::MAX),
_ => return PpcImportAction::Return(u32::MAX),
};
let Some(new_position) = base.checked_add(offset).filter(|p| *p >= 0) else {
return PpcImportAction::Return(u32::MAX);
};
let Ok(new_position) = u32::try_from(new_position) else {
return PpcImportAction::Return(u32::MAX);
};
ppc_stdio_set_position(stream, new_position, stdio_streams, files);
if let Some(record) = stdio_streams.get_mut(&stream) {
record.eof = false;
}
PpcImportAction::Return(0)
}
PpcStdIoOperation::FileTell => {
let Some(record) = stdio_streams.get(&stream).filter(|record| !record.closed) else {
return PpcImportAction::Return(u32::MAX);
};
PpcImportAction::Return(record.position)
}
PpcStdIoOperation::FileBuffer => {
let Some(record) = stdio_streams.get(&stream).filter(|record| !record.closed) else {
return PpcImportAction::Return(u32::MAX);
};
if !record.readable {
ppc_stdio_set_error(stream, stdio_streams);
return PpcImportAction::Return(u32::MAX);
}
let Some((_standard, _ref_num, position, path, _data_len)) =
ppc_stdio_stream_info(stream, stdio_streams, vfs_files)
else {
return PpcImportAction::Return(u32::MAX);
};
let byte = path
.and_then(|path| {
vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(path))
})
.and_then(|record| record.data.get(usize::try_from(position).ok()?))
.copied();
let Some(byte) = byte else {
if let Some(record) = stdio_streams.get_mut(&stream) {
record.eof = true;
}
return PpcImportAction::Return(u32::MAX);
};
let new_position = position.saturating_add(1);
ppc_stdio_set_position(stream, new_position, stdio_streams, files);
PpcImportAction::Return(u32::from(byte))
}
PpcStdIoOperation::FilePrintf => {
const SCRATCH_SIZE: u32 = 16 * 1024;
let Some(record) = stdio_streams.get(&stream).filter(|record| !record.closed) else {
return PpcImportAction::Return(u32::MAX);
};
if !record.writable {
ppc_stdio_set_error(stream, stdio_streams);
return PpcImportAction::Return(u32::MAX);
}
let saved_heap_cursor = *heap_cursor;
let process_scratch = process_memory_manager.is_some();
let scratch = if let Some(memory_manager) = process_memory_manager.as_deref_mut() {
memory_manager.native_scratch_bytes(memory, SCRATCH_SIZE, true)
} else {
ppc_heap_alloc(memory, heap_cursor, heap_limit, SCRATCH_SIZE, true)
};
if scratch == 0 {
return PpcImportAction::Return(u32::MAX);
}
let mut sprintf_cpu = cpu.clone();
sprintf_cpu.gpr[3] = scratch;
let length = ppc_std_sprintf(&sprintf_cpu, memory);
if !process_scratch {
*heap_cursor = saved_heap_cursor;
}
if length >= SCRATCH_SIZE {
ppc_stdio_set_error(stream, stdio_streams);
return PpcImportAction::Return(u32::MAX);
}
let Some(bytes) = ppc_memory_read_bytes(memory, scratch, length) else {
ppc_stdio_set_error(stream, stdio_streams);
return PpcImportAction::Return(u32::MAX);
};
let Some((standard, _ref_num, position, _path, _data_len)) =
ppc_stdio_stream_info(stream, stdio_streams, vfs_files)
else {
return PpcImportAction::Return(u32::MAX);
};
if standard {
return PpcImportAction::Return(length);
}
let Some(path) = stdio_streams
.get(&stream)
.and_then(|record| record.path.clone())
else {
return PpcImportAction::Return(u32::MAX);
};
let Some(file) = ppc_vfs_file_mut(vfs_files, &path) else {
ppc_stdio_set_error(stream, stdio_streams);
return PpcImportAction::Return(u32::MAX);
};
let position = if stdio_streams
.get(&stream)
.is_some_and(|record| record.append)
{
u32::try_from(file.data.len()).unwrap_or(u32::MAX)
} else {
position
};
let start = usize::try_from(position).unwrap_or(usize::MAX);
let end = start.saturating_add(bytes.len());
file.data.with_mut(|data| {
if start > data.len() {
data.resize(start, 0);
}
if end > data.len() {
data.resize(end, 0);
}
data[start..end].copy_from_slice(&bytes);
});
file.dirty = true;
let new_position = u32::try_from(end).unwrap_or(u32::MAX);
ppc_stdio_set_position(stream, new_position, stdio_streams, files);
PpcImportAction::Return(length)
}
PpcStdIoOperation::FileFlush => {
if stdio_streams
.get(&stream)
.filter(|record| !record.closed)
.is_none()
{
return PpcImportAction::Return(u32::MAX);
}
PpcImportAction::Return(0)
}
PpcStdIoOperation::FileEof => {
let Some(record) = stdio_streams.get(&stream).filter(|record| !record.closed) else {
return PpcImportAction::Return(u32::MAX);
};
PpcImportAction::Return(u32::from(record.eof))
}
PpcStdIoOperation::FileError => {
let Some(record) = stdio_streams.get(&stream).filter(|record| !record.closed) else {
return PpcImportAction::Return(u32::MAX);
};
PpcImportAction::Return(u32::from(record.error))
}
PpcStdIoOperation::ClearErr => {
let Some(record) = stdio_streams
.get_mut(&stream)
.filter(|record| !record.closed)
else {
return PpcImportAction::Return(u32::MAX);
};
record.eof = false;
record.error = false;
PpcImportAction::ReturnPreserve
}
PpcStdIoOperation::IoBuffer => PpcImportAction::Return(PPC_STDIO_IOB_ADDR),
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_dispatch_object_support_compatibility(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> PpcImportAction {
let result_ptr = cpu.gpr[8];
if result_ptr == 0 || !ppc_memory_can_write_bytes(memory, result_ptr, 8) {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
let mut data = Vec::with_capacity(12);
data.extend_from_slice(&cpu.gpr[3].to_be_bytes());
data.extend_from_slice(&cpu.gpr[5].to_be_bytes());
data.extend_from_slice(&cpu.gpr[6].to_be_bytes());
let result = ppc_create_process_owned_ae_desc(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
result_ptr,
u32::from_be_bytes(*b"obj "),
&data,
);
PpcImportAction::Return(ppc_i16_result(result))
}
pub(super) fn is_quickdraw_3d_library(library_name: &str) -> bool {
library_name.starts_with("QuickDraw") && library_name.ends_with(" 3D")
}
pub(super) fn is_quickdraw_3d_accelerator_library(library_name: &str) -> bool {
library_name == "QuickDraw\u{2122} 3D Accelerator"
}
fn is_quickdraw_3d_status_success_import(_symbol_name: &str) -> bool {
false
}
fn ppc_q3_alloc_object(
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
kind: PpcQ3ObjectKind,
object_type: u32,
data_ptr: u32,
data_size: u32,
) -> u32 {
let object = *next_q3_object;
let Some(next) = next_q3_object.checked_add(PPC_Q3_OBJECT_STRIDE) else {
return 0;
};
*next_q3_object = next;
q3_objects.push(PpcQ3ObjectRecord {
object,
kind,
object_type,
source: PpcQ3ObjectSource::default(),
data_ptr,
data_size,
});
object
}
fn ppc_q3_light_group_new(
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
) -> u32 {
ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_GROUP_TYPE_LIGHT,
0,
0,
)
}
fn ppc_q3_display_group_new(
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
) -> u32 {
ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_GROUP_TYPE_DISPLAY,
0,
0,
)
}
fn ppc_q3_file_new(
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_files: &mut Vec<PpcQ3FileRecord>,
) -> u32 {
let file = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_TYPE_FILE,
0,
0,
);
if file != 0 {
let _ = ppc_q3_file_mut(q3_files, file);
}
file
}
fn ppc_q3_view_new(
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
) -> u32 {
let view = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_TYPE_VIEW,
0,
0,
);
if view != 0 {
let _ = ppc_q3_view_mut(q3_views, view);
}
view
}
fn ppc_q3_object_type(cpu: &PpcCpu, q3_objects: &[PpcQ3ObjectRecord]) -> u32 {
q3_objects
.iter()
.find(|record| record.object == cpu.gpr[3])
.map(|record| record.object_type)
.unwrap_or(PPC_Q3_TYPE_NONE)
}
fn ppc_q3_class_object_type(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
class_matches: fn(u32) -> bool,
) -> u32 {
let object_type = ppc_q3_object_type(cpu, q3_objects);
if class_matches(object_type) {
object_type
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
PPC_Q3_TYPE_NONE
}
}
fn ppc_q3_object_type_matches(actual_type: u32, requested_type: u32) -> bool {
if actual_type == PPC_Q3_TYPE_NONE || requested_type == PPC_Q3_TYPE_NONE {
return false;
}
if actual_type == requested_type {
return true;
}
match requested_type {
PPC_Q3_OBJECT_TYPE_SHARED => ppc_q3_object_type_is_shared(actual_type),
PPC_Q3_SHARED_TYPE_RENDERER => ppc_q3_object_type_is_renderer(actual_type),
PPC_Q3_SHARED_TYPE_SHAPE => ppc_q3_object_type_is_shape(actual_type),
PPC_Q3_SHAPE_TYPE_GEOMETRY => ppc_q3_object_type_is_geometry(actual_type),
PPC_Q3_SHAPE_TYPE_SHADER => ppc_q3_object_type_is_shader(actual_type),
PPC_Q3_SHADER_TYPE_SURFACE => ppc_q3_object_type_is_surface_shader(actual_type),
PPC_Q3_SHADER_TYPE_ILLUMINATION => ppc_q3_object_type_is_illumination_shader(actual_type),
PPC_Q3_SHAPE_TYPE_STYLE => ppc_q3_object_type_is_style(actual_type),
PPC_Q3_SHAPE_TYPE_TRANSFORM => ppc_q3_object_type_is_transform(actual_type),
PPC_Q3_SHAPE_TYPE_LIGHT => ppc_q3_object_type_is_light(actual_type),
PPC_Q3_SHAPE_TYPE_CAMERA => ppc_q3_object_type_is_camera(actual_type),
PPC_Q3_SHAPE_TYPE_GROUP => ppc_q3_object_type_is_group(actual_type),
PPC_Q3_GROUP_TYPE_DISPLAY => ppc_q3_object_type_is_display_group(actual_type),
PPC_Q3_SHARED_TYPE_SET => ppc_q3_object_type_is_set(actual_type),
PPC_Q3_SHARED_TYPE_DRAW_CONTEXT => ppc_q3_object_type_is_draw_context(actual_type),
PPC_Q3_SHARED_TYPE_TEXTURE => ppc_q3_object_type_is_texture(actual_type),
PPC_Q3_SHARED_TYPE_STORAGE => ppc_q3_object_type_is_storage(actual_type),
PPC_Q3_STORAGE_TYPE_MEMORY => {
actual_type == PPC_Q3_STORAGE_TYPE_MEMORY
|| actual_type == PPC_Q3_MEMORY_STORAGE_TYPE_HANDLE
}
_ => false,
}
}
fn ppc_q3_object_type_is_shared(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_SHARED_TYPE_RENDERER
| PPC_Q3_SHARED_TYPE_SHAPE
| PPC_Q3_SHARED_TYPE_SET
| PPC_Q3_SHARED_TYPE_DRAW_CONTEXT
| PPC_Q3_SHARED_TYPE_TEXTURE
| PPC_Q3_TYPE_FILE
| PPC_Q3_SHARED_TYPE_STORAGE
) || ppc_q3_object_type_is_renderer(object_type)
|| ppc_q3_object_type_is_shape(object_type)
|| ppc_q3_object_type_is_set(object_type)
|| ppc_q3_object_type_is_draw_context(object_type)
|| ppc_q3_object_type_is_texture(object_type)
|| ppc_q3_object_type_is_storage(object_type)
}
fn ppc_q3_shared_type_for_object_type(object_type: u32) -> u32 {
if ppc_q3_object_type_is_renderer(object_type) {
PPC_Q3_SHARED_TYPE_RENDERER
} else if ppc_q3_object_type_is_shape(object_type) {
PPC_Q3_SHARED_TYPE_SHAPE
} else if ppc_q3_object_type_is_set(object_type) {
PPC_Q3_SHARED_TYPE_SET
} else if ppc_q3_object_type_is_draw_context(object_type) {
PPC_Q3_SHARED_TYPE_DRAW_CONTEXT
} else if ppc_q3_object_type_is_texture(object_type) {
PPC_Q3_SHARED_TYPE_TEXTURE
} else if object_type == PPC_Q3_TYPE_FILE {
PPC_Q3_TYPE_FILE
} else if ppc_q3_object_type_is_storage(object_type) {
PPC_Q3_SHARED_TYPE_STORAGE
} else {
PPC_Q3_TYPE_NONE
}
}
fn ppc_q3_shape_type_for_object_type(object_type: u32) -> u32 {
match object_type {
PPC_Q3_SHAPE_TYPE_GEOMETRY
| PPC_Q3_SHAPE_TYPE_SHADER
| PPC_Q3_SHAPE_TYPE_STYLE
| PPC_Q3_SHAPE_TYPE_TRANSFORM
| PPC_Q3_SHAPE_TYPE_LIGHT
| PPC_Q3_SHAPE_TYPE_CAMERA
| PPC_Q3_SHAPE_TYPE_GROUP => object_type,
_ if ppc_q3_object_type_is_geometry(object_type) => PPC_Q3_SHAPE_TYPE_GEOMETRY,
_ if ppc_q3_object_type_is_shader(object_type) => PPC_Q3_SHAPE_TYPE_SHADER,
_ if ppc_q3_object_type_is_style(object_type) => PPC_Q3_SHAPE_TYPE_STYLE,
_ if ppc_q3_object_type_is_transform(object_type) => PPC_Q3_SHAPE_TYPE_TRANSFORM,
_ if ppc_q3_object_type_is_light(object_type) => PPC_Q3_SHAPE_TYPE_LIGHT,
_ if ppc_q3_object_type_is_camera(object_type) => PPC_Q3_SHAPE_TYPE_CAMERA,
_ if ppc_q3_object_type_is_group(object_type) => PPC_Q3_SHAPE_TYPE_GROUP,
_ => PPC_Q3_TYPE_NONE,
}
}
fn ppc_q3_object_type_is_renderer(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_RENDERER_TYPE_WIREFRAME
| PPC_Q3_RENDERER_TYPE_GENERIC
| PPC_Q3_RENDERER_TYPE_INTERACTIVE
| PPC_Q3_RENDERER_TYPE_INTERACTIVE_QUESA
| PPC_Q3_RENDERER_TYPE_OPENGL
| PPC_Q3_RENDERER_TYPE_CARTOON
| PPC_Q3_RENDERER_TYPE_HIDDEN_LINE
)
}
fn ppc_q3_object_type_is_shape(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_SHAPE_TYPE_GEOMETRY
| PPC_Q3_SHAPE_TYPE_SHADER
| PPC_Q3_SHADER_TYPE_SURFACE
| PPC_Q3_SHADER_TYPE_ILLUMINATION
| PPC_Q3_SHAPE_TYPE_STYLE
| PPC_Q3_SHAPE_TYPE_TRANSFORM
| PPC_Q3_SHAPE_TYPE_LIGHT
| PPC_Q3_SHAPE_TYPE_CAMERA
| PPC_Q3_SHAPE_TYPE_GROUP
) || ppc_q3_object_type_is_geometry(object_type)
|| ppc_q3_object_type_is_shader(object_type)
|| ppc_q3_object_type_is_style(object_type)
|| ppc_q3_object_type_is_transform(object_type)
|| ppc_q3_object_type_is_light(object_type)
|| ppc_q3_object_type_is_camera(object_type)
|| ppc_q3_object_type_is_group(object_type)
}
fn ppc_q3_object_type_is_geometry(object_type: u32) -> bool {
object_type == PPC_Q3_TYPE_TRIMESH
}
fn ppc_q3_object_type_is_shader(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_SHADER_TYPE_SURFACE | PPC_Q3_SHADER_TYPE_ILLUMINATION
) || ppc_q3_object_type_is_surface_shader(object_type)
|| ppc_q3_object_type_is_illumination_shader(object_type)
}
fn ppc_q3_object_type_is_surface_shader(object_type: u32) -> bool {
object_type == PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE
}
fn ppc_q3_object_type_is_illumination_shader(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_ILLUMINATION_TYPE_PHONG
| PPC_Q3_ILLUMINATION_TYPE_LAMBERT
| PPC_Q3_ILLUMINATION_TYPE_NULL
)
}
fn ppc_q3_object_type_is_style(object_type: u32) -> bool {
ppc_q3_style_kind_for_type(object_type).is_some()
}
fn ppc_q3_object_type_is_transform(object_type: u32) -> bool {
object_type == PPC_Q3_TRANSFORM_TYPE_MATRIX
}
fn ppc_q3_object_type_is_light(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_LIGHT_TYPE_AMBIENT
| PPC_Q3_LIGHT_TYPE_DIRECTIONAL
| PPC_Q3_LIGHT_TYPE_POINT
| PPC_Q3_LIGHT_TYPE_SPOT
)
}
fn ppc_q3_object_type_is_camera(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT
| PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC
| PPC_Q3_CAMERA_TYPE_VIEW_PLANE
)
}
fn ppc_q3_object_type_is_group(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_GROUP_TYPE_DISPLAY
| PPC_Q3_GROUP_TYPE_IO_PROXY_DISPLAY
| PPC_Q3_GROUP_TYPE_ORDERED_DISPLAY
| PPC_Q3_GROUP_TYPE_LIGHT
)
}
fn ppc_q3_object_type_is_display_group(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_GROUP_TYPE_DISPLAY
| PPC_Q3_GROUP_TYPE_IO_PROXY_DISPLAY
| PPC_Q3_GROUP_TYPE_ORDERED_DISPLAY
)
}
fn ppc_q3_object_type_is_set(object_type: u32) -> bool {
object_type == PPC_Q3_TYPE_ATTRIBUTE_SET
}
fn ppc_q3_object_type_is_draw_context(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP | PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH
)
}
fn ppc_q3_object_type_is_texture(object_type: u32) -> bool {
object_type == PPC_Q3_TEXTURE_TYPE_MIPMAP
}
fn ppc_q3_object_type_is_storage(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_STORAGE_TYPE_MEMORY
| PPC_Q3_STORAGE_TYPE_MACINTOSH
| PPC_Q3_MEMORY_STORAGE_TYPE_HANDLE
)
}
fn ppc_q3_object_type_is_drawable(object_type: u32) -> bool {
object_type == PPC_Q3_TYPE_CONTAINER
|| ppc_q3_object_type_is_geometry(object_type)
|| ppc_q3_object_type_is_shader(object_type)
|| ppc_q3_object_type_is_style(object_type)
|| ppc_q3_object_type_is_transform(object_type)
|| ppc_q3_object_type_is_display_group(object_type)
|| ppc_q3_object_type_is_set(object_type)
}
fn ppc_q3_object_is_type(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let object = cpu.gpr[3];
let requested_type = cpu.gpr[4];
let Some(actual_type) = ppc_q3_known_object_type_for_handle(q3_objects, object) else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
};
ppc_q3_object_type_matches(actual_type, requested_type)
}
fn ppc_q3_object_is_drawable(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let object = cpu.gpr[3];
let Some(object_type) = ppc_q3_known_object_type_for_handle(q3_objects, object) else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
};
ppc_q3_object_type_is_drawable(object_type)
}
fn ppc_q3_renderer_new_from_type(
cpu: &PpcCpu,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_error_state: &mut PpcQ3ErrorState,
next_q3_object: &mut u32,
) -> u32 {
let renderer_type = cpu.gpr[3];
if !ppc_q3_object_type_is_renderer(renderer_type) {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return 0;
}
ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
renderer_type,
0,
0,
)
}
fn ppc_q3_renderer_get_type(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> u32 {
let renderer = cpu.gpr[3];
let object_type = ppc_q3_object_type_for_handle(q3_objects, renderer);
if ppc_q3_object_type_is_renderer(object_type) {
object_type
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
PPC_Q3_TYPE_NONE
}
}
fn ppc_q3_renderer_is_valid(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
ppc_q3_validate_renderer_handle(q3_objects, q3_error_state, cpu.gpr[3])
}
fn ppc_q3_interactive_renderer_set_double_buffer_bypass(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
) -> bool {
let renderer = cpu.gpr[3];
if !ppc_q3_validate_renderer_handle(q3_objects, q3_error_state, renderer) {
return false;
}
ppc_q3_renderer_preference_record_mut(q3_renderer_preferences, renderer).double_buffer_bypass =
Some(cpu.gpr[4]);
true
}
fn ppc_q3_interactive_renderer_set_preferences(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
) -> bool {
let renderer = cpu.gpr[3];
if !ppc_q3_validate_renderer_handle(q3_objects, q3_error_state, renderer) {
return false;
}
let record = ppc_q3_renderer_preference_record_mut(q3_renderer_preferences, renderer);
record.preference_vendor = Some(cpu.gpr[4]);
record.preference_engine = Some(cpu.gpr[5]);
true
}
fn ppc_q3_interactive_renderer_set_rave_context_hints(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
) -> bool {
let renderer = cpu.gpr[3];
if !ppc_q3_validate_renderer_handle(q3_objects, q3_error_state, renderer) {
return false;
}
ppc_q3_renderer_preference_record_mut(q3_renderer_preferences, renderer).rave_context_hints =
Some(cpu.gpr[4]);
true
}
fn ppc_q3_interactive_renderer_get_rave_context_hints(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_renderer_preferences: &[PpcQ3RendererPreferenceRecord],
) -> bool {
let renderer = cpu.gpr[3];
let hints_out_ptr = cpu.gpr[4];
if hints_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, hints_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_renderer_handle(q3_objects, q3_error_state, renderer) {
return false;
}
let hints = q3_renderer_preferences
.iter()
.find(|record| record.renderer == renderer)
.and_then(|record| record.rave_context_hints)
.unwrap_or(0);
memory.write_u32_be(hints_out_ptr, hints).is_some()
}
fn ppc_seed_qa_rave_objects(memory: &mut PpcSectionMem) {
const ADDI_R3_ZERO_ZERO: u32 = 0x3860_0000;
let _ = memory.write_u32_be(
PPC_QA_METHOD_RETURN_ZERO_TVECTOR,
PPC_QA_METHOD_RETURN_ZERO_ENTRY,
);
let _ = memory.write_u32_be(PPC_QA_METHOD_RETURN_ZERO_TVECTOR + 4, 0);
let _ = memory.write_u32_be(PPC_QA_METHOD_RETURN_ZERO_ENTRY, ADDI_R3_ZERO_ZERO);
let _ = memory.write_u32_be(PPC_QA_METHOD_RETURN_ZERO_ENTRY + 4, BLR);
let _ = memory.write_u32_be(PPC_QA_DRAW_CONTEXT, PPC_QA_DRAW_CONTEXT_PRIVATE);
for slot in 0..PPC_QA_DRAW_CONTEXT_METHOD_SLOT_COUNT {
let _ = memory.write_u32_be(
PPC_QA_DRAW_CONTEXT + 4 + slot * 4,
PPC_QA_METHOD_RETURN_ZERO_TVECTOR,
);
}
}
fn ppc_q3_interactive_renderer_get_rave_draw_contexts(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let renderer = cpu.gpr[3];
let draw_contexts_out_ptr = cpu.gpr[4];
let engines_out_ptr = cpu.gpr[5];
let count_out_ptr = cpu.gpr[6];
if draw_contexts_out_ptr == 0
|| engines_out_ptr == 0
|| count_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, draw_contexts_out_ptr, 4)
|| !ppc_memory_can_write_bytes(memory, engines_out_ptr, 4)
|| !ppc_memory_can_write_bytes(memory, count_out_ptr, 4)
{
return false;
}
if !ppc_q3_validate_renderer_handle(q3_objects, q3_error_state, renderer) {
return false;
}
memory
.write_u32_be(draw_contexts_out_ptr, PPC_QA_DRAW_CONTEXT)
.is_some()
&& memory
.write_u32_be(engines_out_ptr, PPC_QA_ENGINE)
.is_some()
&& memory.write_u32_be(count_out_ptr, 1).is_some()
}
fn ppc_q3_interactive_renderer_set_rave_texture_filter(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
) -> bool {
let renderer = cpu.gpr[3];
if !ppc_q3_validate_renderer_handle(q3_objects, q3_error_state, renderer) {
return false;
}
ppc_q3_renderer_preference_record_mut(q3_renderer_preferences, renderer).rave_texture_filter =
Some(cpu.gpr[4]);
true
}
fn ppc_q3_renderer_preference_record_mut(
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
renderer: u32,
) -> &mut PpcQ3RendererPreferenceRecord {
if let Some(index) = q3_renderer_preferences
.iter()
.position(|record| record.renderer == renderer)
{
return q3_renderer_preferences
.get_mut(index)
.expect("Q3 renderer preference index should be valid");
}
q3_renderer_preferences.push(PpcQ3RendererPreferenceRecord::new(renderer));
q3_renderer_preferences
.last_mut()
.expect("just pushed Q3 renderer preference record")
}
fn ppc_q3_validate_renderer_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
renderer: u32,
) -> bool {
if ppc_q3_object_type_is_renderer(ppc_q3_object_type_for_handle(q3_objects, renderer)) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_mipmap_texture_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_error_state: &mut PpcQ3ErrorState,
next_q3_object: &mut u32,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
) -> u32 {
let mipmap_ptr = cpu.gpr[3];
if mipmap_ptr == 0 {
return 0;
}
let Some(mipmap) = ppc_q3_read_bytes(memory, mipmap_ptr, PPC_Q3_MIPMAP_COPY_SIZE) else {
return 0;
};
let image_storage = ppc_q3_mipmap_texture_image_storage(&mipmap);
if !ppc_q3_validate_mipmap_image_storage(q3_objects, q3_error_state, image_storage) {
return 0;
}
let texture = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_TEXTURE_TYPE_MIPMAP,
0,
PPC_Q3_MIPMAP_COPY_SIZE,
);
if texture != 0 {
ppc_q3_mipmap_texture_store_data(q3_mipmap_textures, texture, mipmap);
ppc_q3_retain_mipmap_image_storage(q3_objects, q3_object_refs, image_storage);
}
texture
}
fn ppc_q3_mipmap_texture_image_storage(mipmap: &[u8]) -> u32 {
ppc_q3_read_u32_from_slice(mipmap, PPC_Q3_MIPMAP_IMAGE_OFFSET).unwrap_or(0)
}
fn ppc_q3_mipmap_texture_store_data(
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
texture: u32,
mipmap: Vec<u8>,
) {
if let Some(record) = q3_mipmap_textures
.iter_mut()
.find(|record| record.texture == texture)
{
record.mipmap = mipmap;
} else {
q3_mipmap_textures.push(PpcQ3MipmapTextureRecord { texture, mipmap });
}
}
fn ppc_q3_mipmap_texture_get_mipmap(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_error_state: &mut PpcQ3ErrorState,
q3_mipmap_textures: &[PpcQ3MipmapTextureRecord],
) -> bool {
let texture = cpu.gpr[3];
let mipmap_out_ptr = cpu.gpr[4];
if mipmap_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, mipmap_out_ptr, PPC_Q3_MIPMAP_COPY_SIZE)
{
return false;
}
if !ppc_q3_validate_texture_handle(q3_objects, q3_error_state, texture) {
return false;
}
if let Some(record) = q3_mipmap_textures
.iter()
.find(|record| record.texture == texture)
{
let image_storage = ppc_q3_mipmap_texture_image_storage(&record.mipmap);
if !ppc_q3_validate_mipmap_image_storage(q3_objects, q3_error_state, image_storage) {
return false;
}
if !ppc_q3_write_bytes(memory, mipmap_out_ptr, &record.mipmap) {
return false;
}
ppc_q3_retain_mipmap_image_storage(q3_objects, q3_object_refs, image_storage);
return true;
}
let mipmap_ptr = q3_objects
.iter()
.find(|record| record.object == texture)
.map(|record| record.data_ptr)
.unwrap_or(0);
let image_storage = if mipmap_ptr == 0 {
0
} else {
memory
.read_u32_be(mipmap_ptr + PPC_Q3_MIPMAP_IMAGE_OFFSET)
.unwrap_or(0)
};
if !ppc_q3_validate_mipmap_image_storage(q3_objects, q3_error_state, image_storage) {
return false;
}
if !ppc_q3_copy_or_zero(memory, mipmap_ptr, mipmap_out_ptr, PPC_Q3_MIPMAP_COPY_SIZE) {
return false;
}
ppc_q3_retain_mipmap_image_storage(q3_objects, q3_object_refs, image_storage);
true
}
fn ppc_q3_validate_mipmap_image_storage(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
image_storage: u32,
) -> bool {
if image_storage == 0 {
return true;
}
match ppc_q3_known_object_type_for_handle(q3_objects, image_storage) {
Some(object_type) if ppc_q3_object_type_is_storage(object_type) => true,
Some(_) => {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
None => true,
}
}
fn ppc_q3_retain_mipmap_image_storage(
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
image_storage: u32,
) {
if image_storage == 0 {
return;
}
if ppc_q3_known_object_type_for_handle(q3_objects, image_storage)
.is_some_and(ppc_q3_object_type_is_storage)
{
let _ = ppc_q3_object_retain(q3_objects, q3_object_refs, image_storage);
}
}
fn ppc_q3_mipmap_image_storage_is_known_storage(
q3_objects: &[PpcQ3ObjectRecord],
image_storage: u32,
) -> bool {
ppc_q3_known_object_type_for_handle(q3_objects, image_storage)
.is_some_and(ppc_q3_object_type_is_storage)
}
fn ppc_q3_validate_texture_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
texture: u32,
) -> bool {
if ppc_q3_object_type_for_handle(q3_objects, texture) == PPC_Q3_TEXTURE_TYPE_MIPMAP {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_texture_shader_new(
cpu: &PpcCpu,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_error_state: &mut PpcQ3ErrorState,
next_q3_object: &mut u32,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
) -> u32 {
let texture = cpu.gpr[3];
if !ppc_q3_validate_texture_shader_texture(q3_objects, q3_error_state, texture) {
return 0;
}
let shader = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE,
texture,
0,
);
if shader != 0 {
ppc_q3_texture_shader_store_link(q3_texture_shaders, shader, texture);
let _ = ppc_q3_object_retain(q3_objects, q3_object_refs, texture);
}
shader
}
fn ppc_q3_illumination_shader_new(
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
illumination_type: u32,
) -> u32 {
ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
illumination_type,
0,
0,
)
}
fn ppc_q3_texture_shader_store_link(
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
shader: u32,
texture: u32,
) {
if let Some(record) = q3_texture_shaders
.iter_mut()
.find(|record| record.shader == shader)
{
record.texture = texture;
} else {
q3_texture_shaders.push(PpcQ3TextureShaderRecord { shader, texture });
}
}
fn ppc_q3_texture_shader_get_texture(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_error_state: &mut PpcQ3ErrorState,
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
) -> bool {
let shader = cpu.gpr[3];
let texture_out_ptr = cpu.gpr[4];
if texture_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, texture_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_texture_shader_handle(q3_objects, q3_error_state, shader) {
return false;
}
let texture = q3_texture_shaders
.iter()
.find(|record| record.shader == shader)
.map(|record| record.texture)
.or_else(|| {
q3_objects
.iter()
.find(|record| record.object == shader)
.map(|record| record.data_ptr)
})
.unwrap_or(0);
if !ppc_q3_validate_texture_shader_texture(q3_objects, q3_error_state, texture) {
return false;
}
if memory.write_u32_be(texture_out_ptr, texture).is_none() {
return false;
}
if texture != 0 {
let _ = ppc_q3_object_retain(q3_objects, q3_object_refs, texture);
}
true
}
fn ppc_q3_validate_texture_shader_texture(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
texture: u32,
) -> bool {
match ppc_q3_known_object_type_for_handle(q3_objects, texture) {
Some(object_type) if !ppc_q3_object_type_is_texture(object_type) => {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
_ => true,
}
}
fn ppc_q3_validate_texture_shader_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
shader: u32,
) -> bool {
if ppc_q3_object_type_for_handle(q3_objects, shader) == PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_copy_or_zero(
memory: &mut PpcSectionMem,
source_ptr: u32,
dest_ptr: u32,
byte_count: u32,
) -> bool {
if dest_ptr == 0 {
return false;
}
for offset in 0..byte_count {
let byte = if source_ptr == 0 {
0
} else {
memory.read_u8(source_ptr + offset).unwrap_or(0)
};
if memory.write_u8(dest_ptr + offset, byte).is_none() {
return false;
}
}
true
}
fn ppc_q3_draw_context_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_draw_contexts: &mut Vec<PpcQ3DrawContextRecord>,
draw_context_type: u32,
data_size: u32,
) -> u32 {
let data_ptr = cpu.gpr[3];
if data_ptr == 0 {
return 0;
}
let Some(data) = ppc_q3_read_bytes(memory, data_ptr, data_size) else {
return 0;
};
let draw_context = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
draw_context_type,
0,
data_size,
);
if draw_context != 0 {
q3_draw_contexts.push(PpcQ3DrawContextRecord {
draw_context,
draw_context_type,
data,
});
}
draw_context
}
fn ppc_q3_draw_context_get_pane(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_draw_contexts: &[PpcQ3DrawContextRecord],
gworlds: &[PpcGWorldRecord],
) -> bool {
let draw_context = cpu.gpr[3];
let pane_out_ptr = cpu.gpr[4];
if draw_context == 0
|| pane_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, pane_out_ptr, PPC_Q3_DRAW_CONTEXT_PANE_SIZE)
{
return false;
}
if !ppc_q3_validate_draw_context_handle(q3_objects, q3_error_state, draw_context) {
return false;
}
let Some(object) = q3_objects
.iter()
.find(|record| record.object == draw_context)
else {
return false;
};
let Some(record) = q3_draw_contexts
.iter()
.find(|record| record.draw_context == draw_context)
else {
return false;
};
if object.object_type != record.draw_context_type
|| record.data.len() < PPC_Q3_DRAW_CONTEXT_DATA_SIZE as usize
{
return false;
}
let pane_state =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_DRAW_CONTEXT_PANE_STATE_OFFSET)
.unwrap_or(0);
if pane_state != 0 {
let pane_start = PPC_Q3_DRAW_CONTEXT_PANE_OFFSET as usize;
let pane_end = pane_start + PPC_Q3_DRAW_CONTEXT_PANE_SIZE as usize;
return ppc_q3_write_bytes(memory, pane_out_ptr, &record.data[pane_start..pane_end]);
}
match record.draw_context_type {
PPC_Q3_DRAW_CONTEXT_TYPE_PIXMAP => {
let width =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_PIXMAP_DRAW_CONTEXT_WIDTH_OFFSET);
let height =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_PIXMAP_DRAW_CONTEXT_HEIGHT_OFFSET);
let Some((width, height)) = width.zip(height) else {
return false;
};
ppc_write_q3_area(memory, pane_out_ptr, 0.0, 0.0, width as f32, height as f32).is_some()
}
PPC_Q3_DRAW_CONTEXT_TYPE_MACINTOSH => {
let port =
ppc_q3_read_u32_from_slice(&record.data, PPC_Q3_MAC_DRAW_CONTEXT_PORT_OFFSET)
.unwrap_or(0);
let (width, height) = gworlds
.iter()
.find(|gworld| gworld.port == port)
.map(|gworld| (gworld.width, gworld.height))
.unwrap_or((PPC_MAIN_SCREEN_WIDTH, PPC_MAIN_SCREEN_HEIGHT));
ppc_write_q3_area(memory, pane_out_ptr, 0.0, 0.0, width as f32, height as f32).is_some()
}
_ => false,
}
}
fn ppc_q3_validate_draw_context_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
draw_context: u32,
) -> bool {
if ppc_q3_object_type_is_draw_context(ppc_q3_object_type_for_handle(q3_objects, draw_context)) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_trimesh_new(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
next_q3_object: &mut u32,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
) -> u32 {
let data_ptr = cpu.gpr[3];
if data_ptr == 0 {
return 0;
}
let Some(data) = ppc_q3_read_bytes(memory, data_ptr, PPC_Q3_TRIMESH_DATA_SIZE) else {
return 0;
};
let Some(data) = ppc_q3_trimesh_copy_get_data_arrays(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&data,
) else {
return 0;
};
let trimesh = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_TYPE_TRIMESH,
0,
PPC_Q3_TRIMESH_DATA_SIZE,
);
if trimesh != 0 {
let triangle_attribute_sets = ppc_q3_trimesh_retain_triangle_attribute_sets(
memory,
q3_objects,
q3_object_refs,
&data,
);
ppc_q3_trimesh_store_data(q3_trimeshes, trimesh, data, triangle_attribute_sets);
}
trimesh
}
fn ppc_q3_trimesh_get_data(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_error_state: &mut PpcQ3ErrorState,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
q3_trimeshes: &mut [PpcQ3TriMeshRecord],
) -> bool {
let trimesh = cpu.gpr[3];
let data_out_ptr = cpu.gpr[4];
if trimesh == 0
|| data_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, data_out_ptr, PPC_Q3_TRIMESH_DATA_SIZE)
{
return false;
}
if !ppc_q3_validate_trimesh_handle(q3_objects, q3_error_state, trimesh) {
return false;
}
let Some(record) = q3_objects.iter().find(|record| record.object == trimesh) else {
return false;
};
if let Some(record_index) = q3_trimeshes
.iter()
.position(|record| record.trimesh == trimesh)
{
let copy_size = PPC_Q3_TRIMESH_DATA_SIZE as usize;
if q3_trimeshes[record_index].data.len() < copy_size {
return false;
}
let source_data = q3_trimeshes[record_index].data[..copy_size].to_vec();
ppc_q3_trace_trimesh_header(
"GetData stored copy-arrays source",
cpu,
trimesh,
&source_data,
);
// Quesa's Q3TriMesh_GetData implementation copies every TriMesh array,
// and Q3TriMesh_EmptyData releases those allocations. Reusing the
// private allocation set associated with the same output structure
// models a normal allocator returning recently freed blocks without
// making API semantics depend on an application's return address.
// Source: Quesa E3GeometryTriMesh.cpp, e3geom_nakedtrimesh_copydata and
// E3TriMesh_GetData (https://github.com/jwwalker/Quesa).
let cached_copy = q3_trimeshes[record_index]
.get_data_copies
.iter()
.find(|copy| copy.data_out_ptr == data_out_ptr)
.cloned();
let data = cached_copy
.and_then(|copy| {
ppc_q3_trimesh_refresh_get_data_arrays(memory, &source_data, ©.data)
})
.or_else(|| {
ppc_q3_trimesh_copy_get_data_arrays(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&source_data,
)
});
let Some(data) = data else {
return false;
};
if let Some(copy) = q3_trimeshes[record_index]
.get_data_copies
.iter_mut()
.find(|copy| copy.data_out_ptr == data_out_ptr)
{
copy.data.clone_from(&data);
} else {
q3_trimeshes[record_index]
.get_data_copies
.push(PpcQ3TriMeshGetDataCopyRecord {
data_out_ptr,
data: data.clone(),
});
}
ppc_q3_trace_trimesh_header("GetData stored copy-arrays result", cpu, trimesh, &data);
return ppc_q3_write_trimesh_get_data(
memory,
data_out_ptr,
&data,
q3_objects,
q3_object_refs,
q3_attributes,
q3_texture_shaders,
);
}
if record.data_ptr == 0 || record.data_size < PPC_Q3_TRIMESH_DATA_SIZE {
return false;
}
let Some(data) = ppc_q3_read_bytes(memory, record.data_ptr, PPC_Q3_TRIMESH_DATA_SIZE) else {
return false;
};
ppc_q3_trace_trimesh_header("GetData object copy-arrays source", cpu, trimesh, &data);
let Some(data) = ppc_q3_trimesh_copy_get_data_arrays(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&data,
) else {
return false;
};
ppc_q3_trace_trimesh_header("GetData object copy-arrays result", cpu, trimesh, &data);
ppc_q3_write_trimesh_get_data(
memory,
data_out_ptr,
&data,
q3_objects,
q3_object_refs,
q3_attributes,
q3_texture_shaders,
)
}
fn ppc_q3_write_trimesh_get_data(
memory: &mut PpcSectionMem,
data_out_ptr: u32,
data: &[u8],
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
) -> bool {
if !ppc_q3_write_bytes(memory, data_out_ptr, data) {
return false;
}
if let Some(attribute_set) =
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_ATTRIBUTE_SET_OFFSET)
.filter(|attribute_set| *attribute_set != 0)
{
let mut copied_attributes = ppc_q3_attributes_for_set(q3_attributes, attribute_set);
let retained_shaders: Vec<u32> = copied_attributes
.iter()
.filter_map(ppc_q3_attribute_surface_shader_handle)
.collect();
q3_attributes.retain(|record| record.attribute_set != data_out_ptr);
for attribute in &mut copied_attributes {
attribute.attribute_set = data_out_ptr;
}
q3_attributes.extend(copied_attributes);
for shader in retained_shaders {
let _ = ppc_q3_object_retain(q3_objects, q3_object_refs, shader);
if let Some(texture) = q3_texture_shaders
.iter()
.find(|record| record.shader == shader)
.map(|record| record.texture)
{
let _ = ppc_q3_object_retain(q3_objects, q3_object_refs, texture);
}
}
}
let _ = ppc_q3_trimesh_retain_triangle_attribute_sets(memory, q3_objects, q3_object_refs, data);
true
}
fn ppc_q3_trimesh_set_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
q3_error_state: &mut PpcQ3ErrorState,
q3_files: &mut Vec<PpcQ3FileRecord>,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &mut Vec<PpcQ3FileGroupRecord>,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_view_state_stack: &mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_completed_frames: &mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
q3_fog_styles: &mut Vec<PpcQ3FogStyleRecord>,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_shader_uv_transforms: &mut Vec<PpcQ3ShaderUvTransformRecord>,
q3_shader_boundaries: &mut Vec<PpcQ3ShaderBoundaryRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
q3_draw_contexts: &mut Vec<PpcQ3DrawContextRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
q3_lights: &mut Vec<PpcQ3LightRecord>,
) -> bool {
let trimesh = cpu.gpr[3];
let data_ptr = cpu.gpr[4];
if trimesh == 0 || data_ptr == 0 {
return false;
}
let Some(data) = ppc_q3_read_bytes(memory, data_ptr, PPC_Q3_TRIMESH_DATA_SIZE) else {
return false;
};
ppc_q3_trace_trimesh_header("SetData input", cpu, trimesh, &data);
if !ppc_q3_validate_trimesh_handle(q3_objects, q3_error_state, trimesh) {
return false;
}
let Some(record) = q3_objects
.iter_mut()
.find(|record| record.object == trimesh)
else {
return false;
};
record.object_type = PPC_Q3_TYPE_TRIMESH;
record.data_ptr = 0;
record.data_size = PPC_Q3_TRIMESH_DATA_SIZE;
let old_triangle_attribute_sets = q3_trimeshes
.iter()
.find(|record| record.trimesh == trimesh)
.map(|record| record.triangle_attribute_sets.clone())
.unwrap_or_default();
let triangle_attribute_sets =
ppc_q3_trimesh_retain_triangle_attribute_sets(memory, q3_objects, q3_object_refs, &data);
{
let mut stores = PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
};
for attribute_set in old_triangle_attribute_sets {
let _ = ppc_q3_object_release_reference(&mut stores, attribute_set);
}
}
ppc_q3_trimesh_store_data(q3_trimeshes, trimesh, data, triangle_attribute_sets);
true
}
fn ppc_q3_validate_trimesh_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
trimesh: u32,
) -> bool {
if ppc_q3_object_type_for_handle(q3_objects, trimesh) == PPC_Q3_TYPE_TRIMESH {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_trimesh_empty_data(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> bool {
let data_ptr = cpu.gpr[3];
if data_ptr == 0 {
return false;
}
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,
] {
if memory.write_u32_be(data_ptr + offset, 0).is_none() {
return false;
}
}
true
}
fn ppc_q3_trimesh_copy_get_data_arrays(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
data: &[u8],
) -> Option<Vec<u8>> {
let mut data = data.to_vec();
ppc_q3_trimesh_copy_get_data_array(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&mut data,
PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLE_DATA_SIZE,
PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES,
)?;
ppc_q3_trimesh_copy_get_data_array(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&mut data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE,
PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES,
)?;
ppc_q3_trimesh_copy_get_data_attribute_payloads(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&mut data,
PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES,
)?;
ppc_q3_trimesh_copy_get_data_array(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&mut data,
PPC_Q3_TRIMESH_NUM_EDGES_OFFSET,
PPC_Q3_TRIMESH_EDGES_OFFSET,
PPC_Q3_TRIMESH_EDGE_DATA_SIZE,
PPC_Q3_SOFTWARE_RENDER_MAX_EDGES,
)?;
ppc_q3_trimesh_copy_get_data_array(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&mut data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE,
PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES,
)?;
ppc_q3_trimesh_copy_get_data_attribute_payloads(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&mut data,
PPC_Q3_TRIMESH_NUM_EDGES_OFFSET,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_SOFTWARE_RENDER_MAX_EDGES,
)?;
ppc_q3_trimesh_copy_get_data_array(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&mut data,
PPC_Q3_TRIMESH_NUM_POINTS_OFFSET,
PPC_Q3_TRIMESH_POINTS_OFFSET,
12,
PPC_Q3_SOFTWARE_RENDER_MAX_POINTS,
)?;
ppc_q3_trimesh_copy_get_data_array(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&mut data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE,
PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES,
)?;
ppc_q3_trimesh_copy_get_data_attribute_payloads(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
&mut data,
PPC_Q3_TRIMESH_NUM_POINTS_OFFSET,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_SOFTWARE_RENDER_MAX_POINTS,
)?;
*last_mem_error = PPC_NO_ERR;
Some(data)
}
fn ppc_q3_trimesh_refresh_get_data_arrays(
memory: &mut PpcSectionMem,
source: &[u8],
cached: &[u8],
) -> Option<Vec<u8>> {
if source.len() < PPC_Q3_TRIMESH_DATA_SIZE as usize
|| cached.len() < PPC_Q3_TRIMESH_DATA_SIZE as usize
{
return None;
}
let mut refreshed = source.to_vec();
for (count_offset, ptr_offset, element_size, max_count) in [
(
PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLE_DATA_SIZE,
PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES,
),
(
PPC_Q3_TRIMESH_NUM_EDGES_OFFSET,
PPC_Q3_TRIMESH_EDGES_OFFSET,
PPC_Q3_TRIMESH_EDGE_DATA_SIZE,
PPC_Q3_SOFTWARE_RENDER_MAX_EDGES,
),
(
PPC_Q3_TRIMESH_NUM_POINTS_OFFSET,
PPC_Q3_TRIMESH_POINTS_OFFSET,
PPC_Q3_POINT3D_SIZE,
PPC_Q3_SOFTWARE_RENDER_MAX_POINTS,
),
] {
let count = ppc_q3_trimesh_header_u32(source, count_offset)?;
if count != ppc_q3_trimesh_header_u32(cached, count_offset)? || count > max_count {
return None;
}
let source_ptr = ppc_q3_trimesh_header_u32(source, ptr_offset)?;
let cached_ptr = ppc_q3_trimesh_header_u32(cached, ptr_offset)?;
if count != 0 {
let byte_count = count.checked_mul(element_size)?;
if source_ptr == 0
|| cached_ptr == 0
|| !ppc_q3_copy_or_zero(memory, source_ptr, cached_ptr, byte_count)
{
return None;
}
}
ppc_q3_write_u32_to_slice(&mut refreshed, ptr_offset, cached_ptr)?;
}
for (element_count_offset, attr_count_offset, attr_ptr_offset, max_element_count) in [
(
PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES,
),
(
PPC_Q3_TRIMESH_NUM_EDGES_OFFSET,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_SOFTWARE_RENDER_MAX_EDGES,
),
(
PPC_Q3_TRIMESH_NUM_POINTS_OFFSET,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_SOFTWARE_RENDER_MAX_POINTS,
),
] {
let element_count = ppc_q3_trimesh_header_u32(source, element_count_offset)?;
let attr_count = ppc_q3_trimesh_header_u32(source, attr_count_offset)?;
if element_count != ppc_q3_trimesh_header_u32(cached, element_count_offset)?
|| attr_count != ppc_q3_trimesh_header_u32(cached, attr_count_offset)?
|| element_count > max_element_count
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
{
return None;
}
let source_table = ppc_q3_trimesh_header_u32(source, attr_ptr_offset)?;
let cached_table = ppc_q3_trimesh_header_u32(cached, attr_ptr_offset)?;
if attr_count != 0 && (source_table == 0 || cached_table == 0) {
return None;
}
for attr_index in 0..attr_count {
let record_offset = attr_index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?;
let source_record = source_table.checked_add(record_offset)?;
let cached_record = cached_table.checked_add(record_offset)?;
let attr_type = memory.read_u32_be(source_record)?;
if attr_type != memory.read_u32_be(cached_record)? {
return None;
}
let attr_size = ppc_q3_attribute_data_size(attr_type)?;
let source_data_ptr = memory.read_u32_be(source_record.checked_add(4)?)?;
let cached_data_ptr = memory.read_u32_be(cached_record.checked_add(4)?)?;
if element_count != 0 {
let byte_count = element_count.checked_mul(attr_size)?;
if source_data_ptr == 0
|| cached_data_ptr == 0
|| !ppc_q3_copy_or_zero(memory, source_data_ptr, cached_data_ptr, byte_count)
{
return None;
}
}
let source_use_ptr = memory.read_u32_be(source_record.checked_add(8)?)?;
let cached_use_ptr = memory.read_u32_be(cached_record.checked_add(8)?)?;
if source_use_ptr != 0
&& (cached_use_ptr == 0
|| !ppc_q3_copy_or_zero(memory, source_use_ptr, cached_use_ptr, element_count))
{
return None;
}
memory.write_u32_be(cached_record, attr_type)?;
}
ppc_q3_write_u32_to_slice(&mut refreshed, attr_ptr_offset, cached_table)?;
}
Some(refreshed)
}
fn ppc_q3_trimesh_copy_get_data_array(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
data: &mut [u8],
count_offset: u32,
ptr_offset: u32,
element_size: u32,
max_count: u32,
) -> Option<()> {
let count = ppc_q3_trimesh_header_u32(data, count_offset)?;
let source_ptr = ppc_q3_trimesh_header_u32(data, ptr_offset)?;
if count == 0 || count > max_count || source_ptr == 0 {
return Some(());
}
let byte_count = count.checked_mul(element_size)?;
if !ppc_memory_can_read_bytes(memory, source_ptr, byte_count) {
return Some(());
}
let dest_ptr = ppc_process_heap_alloc(
process_memory_manager,
memory,
heap_cursor,
byte_count,
false,
);
if dest_ptr == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return None;
}
if !ppc_q3_copy_or_zero(memory, source_ptr, dest_ptr, byte_count) {
return None;
}
ppc_q3_write_u32_to_slice(data, ptr_offset, dest_ptr)
}
fn ppc_q3_trimesh_copy_get_data_attribute_payloads(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
data: &mut [u8],
element_count_offset: u32,
attr_count_offset: u32,
attr_ptr_offset: u32,
max_element_count: u32,
) -> Option<()> {
let element_count = ppc_q3_trimesh_header_u32(data, element_count_offset)?;
let attr_count = ppc_q3_trimesh_header_u32(data, attr_count_offset)?;
let attr_ptr = ppc_q3_trimesh_header_u32(data, attr_ptr_offset)?;
if element_count == 0
|| element_count > max_element_count
|| attr_count == 0
|| attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| attr_ptr == 0
{
return Some(());
}
for attr_index in 0..attr_count {
let entry_ptr =
attr_ptr.checked_add(attr_index.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
let Some(attr_type) = memory.read_u32_be(entry_ptr) else {
continue;
};
let Some(attr_data_size) = ppc_q3_attribute_data_size(attr_type) else {
continue;
};
let Some(source_data_ptr) = memory.read_u32_be(entry_ptr.checked_add(4)?) else {
continue;
};
let data_byte_count = element_count.checked_mul(attr_data_size)?;
if source_data_ptr != 0
&& ppc_memory_can_read_bytes(memory, source_data_ptr, data_byte_count)
{
let dest_data_ptr = ppc_process_heap_alloc(
process_memory_manager,
memory,
heap_cursor,
data_byte_count,
false,
);
if dest_data_ptr == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return None;
}
if !ppc_q3_copy_or_zero(memory, source_data_ptr, dest_data_ptr, data_byte_count) {
return None;
}
memory.write_u32_be(entry_ptr.checked_add(4)?, dest_data_ptr)?;
}
let Some(source_use_ptr) = memory.read_u32_be(entry_ptr.checked_add(8)?) else {
continue;
};
if source_use_ptr != 0 && ppc_memory_can_read_bytes(memory, source_use_ptr, element_count) {
let dest_use_ptr = ppc_process_heap_alloc(
process_memory_manager,
memory,
heap_cursor,
element_count,
false,
);
if dest_use_ptr == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return None;
}
if !ppc_q3_copy_or_zero(memory, source_use_ptr, dest_use_ptr, element_count) {
return None;
}
memory.write_u32_be(entry_ptr.checked_add(8)?, dest_use_ptr)?;
}
}
Some(())
}
fn ppc_q3_write_u32_to_slice(data: &mut [u8], offset: u32, value: u32) -> Option<()> {
let offset = usize::try_from(offset).ok()?;
data.get_mut(offset..offset.checked_add(4)?)?
.copy_from_slice(&value.to_be_bytes());
Some(())
}
fn ppc_q3_trimesh_store_data(
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
trimesh: u32,
data: Vec<u8>,
triangle_attribute_sets: Vec<u32>,
) {
if let Some(record) = q3_trimeshes
.iter_mut()
.find(|record| record.trimesh == trimesh)
{
record.data = data;
record.triangle_attribute_sets = triangle_attribute_sets;
} else {
q3_trimeshes.push(PpcQ3TriMeshRecord {
trimesh,
data,
triangle_attribute_sets,
get_data_copies: Vec::new(),
});
}
}
fn ppc_q3_trimesh_retain_triangle_attribute_sets(
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
data: &[u8],
) -> Vec<u32> {
let mut attribute_sets = Vec::new();
if let Some(attribute_set) =
ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_ATTRIBUTE_SET_OFFSET)
{
if attribute_set != 0
&& ppc_q3_object_type_for_handle(q3_objects, attribute_set) == PPC_Q3_TYPE_ATTRIBUTE_SET
&& ppc_q3_object_retain(q3_objects, q3_object_refs, attribute_set)
{
attribute_sets.push(attribute_set);
}
}
let Some(num_triangles) = ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)
else {
return attribute_sets;
};
let Some(triangles_ptr) = ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_TRIANGLES_OFFSET)
else {
return attribute_sets;
};
if num_triangles == 0
|| num_triangles > PPC_Q3_SOFTWARE_RENDER_MAX_TRIANGLES
|| triangles_ptr == 0
{
return attribute_sets;
}
ppc_q3_trimesh_retain_attribute_set_values_from_array(
memory,
q3_objects,
q3_object_refs,
data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
num_triangles,
&mut attribute_sets,
);
let num_edges = ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET).unwrap_or(0);
ppc_q3_trimesh_retain_attribute_set_values_from_array(
memory,
q3_objects,
q3_object_refs,
data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
num_edges,
&mut attribute_sets,
);
let num_points = ppc_q3_trimesh_header_u32(data, PPC_Q3_TRIMESH_NUM_POINTS_OFFSET).unwrap_or(0);
ppc_q3_trimesh_retain_attribute_set_values_from_array(
memory,
q3_objects,
q3_object_refs,
data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
num_points,
&mut attribute_sets,
);
attribute_sets
}
fn ppc_q3_trimesh_retain_attribute_set_values_from_array(
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
data: &[u8],
count_offset: u32,
table_offset: u32,
element_count: u32,
attribute_sets: &mut Vec<u32>,
) {
if element_count == 0 || element_count > PPC_Q3_SOFTWARE_RENDER_MAX_EDGES {
return;
}
let attr_count = ppc_q3_trimesh_header_u32(data, count_offset).unwrap_or(0);
let attr_ptr = ppc_q3_trimesh_header_u32(data, table_offset).unwrap_or(0);
if attr_count == 0 || attr_count > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES || attr_ptr == 0 {
return;
}
for attr_index in 0..attr_count {
let Some(entry_ptr) =
attr_ptr.checked_add(attr_index.saturating_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE))
else {
return;
};
let Some(attr_type) = memory.read_u32_be(entry_ptr) else {
continue;
};
let Some(attr_data_size) = ppc_q3_attribute_data_size(attr_type) else {
continue;
};
if attr_data_size != 4 {
continue;
}
let Some(data_ptr) = memory.read_u32_be(entry_ptr.saturating_add(4)) else {
continue;
};
if data_ptr == 0 {
continue;
}
for element_index in 0..element_count {
let Some(value_ptr) =
data_ptr.checked_add(element_index.saturating_mul(attr_data_size))
else {
return;
};
let Some(attribute_set) = memory.read_u32_be(value_ptr) else {
continue;
};
if attribute_set == 0
|| attribute_sets.contains(&attribute_set)
|| ppc_q3_object_type_for_handle(q3_objects, attribute_set)
!= PPC_Q3_TYPE_ATTRIBUTE_SET
{
continue;
}
if ppc_q3_object_retain(q3_objects, q3_object_refs, attribute_set) {
attribute_sets.push(attribute_set);
}
}
}
}
fn ppc_q3_view_angle_aspect_camera_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
) -> u32 {
ppc_q3_camera_new(
cpu,
memory,
q3_objects,
next_q3_object,
q3_cameras,
PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
)
}
fn ppc_q3_orthographic_camera_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
) -> u32 {
ppc_q3_camera_new(
cpu,
memory,
q3_objects,
next_q3_object,
q3_cameras,
PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC,
)
}
fn ppc_q3_view_plane_camera_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
) -> u32 {
ppc_q3_camera_new(
cpu,
memory,
q3_objects,
next_q3_object,
q3_cameras,
PPC_Q3_CAMERA_TYPE_VIEW_PLANE,
)
}
fn ppc_q3_camera_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
camera_type: u32,
) -> u32 {
let data_ptr = cpu.gpr[3];
if data_ptr == 0 {
return 0;
}
let Some(data_size) = ppc_q3_camera_data_size(camera_type) else {
return 0;
};
let Some(mut record) = ppc_read_q3_camera(memory, data_ptr, camera_type) else {
return 0;
};
if !ppc_q3_camera_record_valid(&record) {
return 0;
}
let camera = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
camera_type,
0,
data_size,
);
if camera != 0 {
record.camera = camera;
q3_cameras.push(record);
}
camera
}
fn ppc_q3_camera_get_placement(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_cameras: &[PpcQ3CameraRecord],
) -> bool {
let camera = cpu.gpr[3];
let placement_out_ptr = cpu.gpr[4];
if placement_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, placement_out_ptr, PPC_Q3_CAMERA_PLACEMENT_SIZE)
{
return false;
}
if !ppc_q3_validate_camera_handle(q3_objects, q3_error_state, camera) {
return false;
}
let Some(record) = q3_cameras.iter().find(|record| record.camera == camera) else {
return false;
};
ppc_write_q3_camera_placement(memory, placement_out_ptr, record.placement).is_some()
}
fn ppc_q3_camera_set_placement(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_cameras: &mut [PpcQ3CameraRecord],
) -> bool {
let camera = cpu.gpr[3];
let placement_ptr = cpu.gpr[4];
if placement_ptr == 0 {
return false;
}
let Some(placement) = ppc_read_q3_camera_placement(memory, placement_ptr) else {
return false;
};
if !ppc_q3_camera_placement_valid(placement) {
return false;
}
if !ppc_q3_validate_camera_handle(q3_objects, q3_error_state, camera) {
return false;
}
let Some(record) = q3_cameras.iter_mut().find(|record| record.camera == camera) else {
return false;
};
record.placement = placement;
true
}
fn ppc_q3_camera_get_range(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_cameras: &[PpcQ3CameraRecord],
) -> bool {
let camera = cpu.gpr[3];
let range_out_ptr = cpu.gpr[4];
if range_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, range_out_ptr, PPC_Q3_CAMERA_RANGE_SIZE)
{
return false;
}
if !ppc_q3_validate_camera_handle(q3_objects, q3_error_state, camera) {
return false;
}
let Some(record) = q3_cameras.iter().find(|record| record.camera == camera) else {
return false;
};
ppc_write_q3_camera_range(memory, range_out_ptr, record.range_hither, record.range_yon)
.is_some()
}
fn ppc_q3_camera_set_range(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_cameras: &mut [PpcQ3CameraRecord],
) -> bool {
let camera = cpu.gpr[3];
let range_ptr = cpu.gpr[4];
if range_ptr == 0 {
return false;
}
let Some((hither, yon)) = ppc_read_q3_camera_range(memory, range_ptr) else {
return false;
};
if !ppc_q3_camera_range_valid(hither, yon) {
return false;
}
if !ppc_q3_validate_camera_handle(q3_objects, q3_error_state, camera) {
return false;
}
let Some(record) = q3_cameras.iter_mut().find(|record| record.camera == camera) else {
return false;
};
record.range_hither = hither;
record.range_yon = yon;
true
}
fn ppc_q3_camera_get_viewport(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_cameras: &[PpcQ3CameraRecord],
) -> bool {
let camera = cpu.gpr[3];
let viewport_out_ptr = cpu.gpr[4];
if viewport_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, viewport_out_ptr, PPC_Q3_CAMERA_VIEWPORT_SIZE)
{
return false;
}
if !ppc_q3_validate_camera_handle(q3_objects, q3_error_state, camera) {
return false;
}
let Some(record) = q3_cameras.iter().find(|record| record.camera == camera) else {
return false;
};
ppc_write_q3_camera_viewport(
memory,
viewport_out_ptr,
record.viewport_origin,
record.viewport_width,
record.viewport_height,
)
.is_some()
}
fn ppc_q3_camera_set_viewport(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_cameras: &mut [PpcQ3CameraRecord],
) -> bool {
let camera = cpu.gpr[3];
let viewport_ptr = cpu.gpr[4];
if viewport_ptr == 0 {
return false;
}
let Some((origin, width, height)) = ppc_read_q3_camera_viewport(memory, viewport_ptr) else {
return false;
};
if !ppc_q3_camera_viewport_valid(origin, width, height) {
return false;
}
if !ppc_q3_validate_camera_handle(q3_objects, q3_error_state, camera) {
return false;
}
let Some(record) = q3_cameras.iter_mut().find(|record| record.camera == camera) else {
return false;
};
record.viewport_origin = origin;
record.viewport_width = width;
record.viewport_height = height;
true
}
fn ppc_q3_camera_get_world_to_view(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_cameras: &[PpcQ3CameraRecord],
) -> bool {
let camera = cpu.gpr[3];
let matrix_out_ptr = cpu.gpr[4];
if matrix_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, matrix_out_ptr, PPC_Q3_MATRIX4X4_SIZE)
{
return false;
}
if !ppc_q3_validate_camera_handle(q3_objects, q3_error_state, camera) {
return false;
}
let Some(record) = q3_cameras.iter().find(|record| record.camera == camera) else {
return false;
};
let Some(matrix) = ppc_q3_camera_world_to_view_matrix(record.placement) else {
return false;
};
ppc_write_q3_matrix4x4(memory, matrix_out_ptr, &matrix).is_some()
}
fn ppc_q3_camera_get_view_to_frustum(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_cameras: &[PpcQ3CameraRecord],
) -> bool {
let camera = cpu.gpr[3];
let matrix_out_ptr = cpu.gpr[4];
if matrix_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, matrix_out_ptr, PPC_Q3_MATRIX4X4_SIZE)
{
return false;
}
if !ppc_q3_validate_camera_handle(q3_objects, q3_error_state, camera) {
return false;
}
let Some(record) = q3_cameras.iter().find(|record| record.camera == camera) else {
return false;
};
let Some(matrix) = ppc_q3_camera_view_to_frustum_matrix(record) else {
return false;
};
ppc_write_q3_matrix4x4(memory, matrix_out_ptr, &matrix).is_some()
}
fn ppc_q3_validate_camera_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
camera: u32,
) -> bool {
if ppc_q3_object_type_is_camera(ppc_q3_object_type_for_handle(q3_objects, camera)) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_read_q3_camera(
memory: &mut PpcSectionMem,
data_ptr: u32,
camera_type: u32,
) -> Option<PpcQ3CameraRecord> {
let common = ppc_read_q3_camera_common_data(memory, data_ptr)?;
let projection = match camera_type {
PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT => PpcQ3CameraProjection::ViewAngleAspect {
fov: ppc_read_f32_be(memory, data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE)?)?,
aspect_ratio_x_to_y: ppc_read_f32_be(
memory,
data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE + 4)?,
)?,
},
PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC => PpcQ3CameraProjection::Orthographic {
left: ppc_read_f32_be(memory, data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE)?)?,
top: ppc_read_f32_be(memory, data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE + 4)?)?,
right: ppc_read_f32_be(memory, data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE + 8)?)?,
bottom: ppc_read_f32_be(memory, data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE + 12)?)?,
},
PPC_Q3_CAMERA_TYPE_VIEW_PLANE => PpcQ3CameraProjection::ViewPlane {
view_plane: ppc_read_f32_be(memory, data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE)?)?,
half_width_at_view_plane: ppc_read_f32_be(
memory,
data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE + 4)?,
)?,
half_height_at_view_plane: ppc_read_f32_be(
memory,
data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE + 8)?,
)?,
center_x_on_view_plane: ppc_read_f32_be(
memory,
data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE + 12)?,
)?,
center_y_on_view_plane: ppc_read_f32_be(
memory,
data_ptr.checked_add(PPC_Q3_CAMERA_DATA_SIZE + 16)?,
)?,
},
_ => return None,
};
Some(PpcQ3CameraRecord {
camera: 0,
camera_type,
placement: common.placement,
range_hither: common.range_hither,
range_yon: common.range_yon,
viewport_origin: common.viewport_origin,
viewport_width: common.viewport_width,
viewport_height: common.viewport_height,
projection,
})
}
fn ppc_read_q3_camera_common_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
) -> Option<PpcQ3CameraCommonData> {
Some(PpcQ3CameraCommonData {
placement: ppc_read_q3_camera_placement(
memory,
data_ptr.checked_add(PPC_Q3_CAMERA_PLACEMENT_OFFSET)?,
)?,
range_hither: ppc_read_f32_be(memory, data_ptr.checked_add(PPC_Q3_CAMERA_RANGE_OFFSET)?)?,
range_yon: ppc_read_f32_be(
memory,
data_ptr.checked_add(PPC_Q3_CAMERA_RANGE_OFFSET + 4)?,
)?,
viewport_origin: ppc_read_q3_vector2d(
memory,
data_ptr.checked_add(PPC_Q3_CAMERA_VIEWPORT_OFFSET)?,
)?,
viewport_width: ppc_read_f32_be(
memory,
data_ptr
.checked_add(PPC_Q3_CAMERA_VIEWPORT_OFFSET)?
.checked_add(PPC_Q3_CAMERA_VIEWPORT_WIDTH_OFFSET)?,
)?,
viewport_height: ppc_read_f32_be(
memory,
data_ptr
.checked_add(PPC_Q3_CAMERA_VIEWPORT_OFFSET)?
.checked_add(PPC_Q3_CAMERA_VIEWPORT_HEIGHT_OFFSET)?,
)?,
})
}
fn ppc_q3_camera_data_size(camera_type: u32) -> Option<u32> {
match camera_type {
PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT => Some(PPC_Q3_VIEW_ANGLE_ASPECT_CAMERA_DATA_SIZE),
PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC => Some(PPC_Q3_ORTHOGRAPHIC_CAMERA_DATA_SIZE),
PPC_Q3_CAMERA_TYPE_VIEW_PLANE => Some(PPC_Q3_VIEW_PLANE_CAMERA_DATA_SIZE),
_ => None,
}
}
fn ppc_read_q3_camera_placement(
memory: &mut PpcSectionMem,
placement_ptr: u32,
) -> Option<PpcQ3CameraPlacement> {
Some(PpcQ3CameraPlacement {
camera_location: ppc_read_q3_vector3d(memory, placement_ptr)?,
point_of_interest: ppc_read_q3_vector3d(memory, placement_ptr.checked_add(12)?)?,
up_vector: ppc_read_q3_vector3d(memory, placement_ptr.checked_add(24)?)?,
})
}
fn ppc_write_q3_camera_placement(
memory: &mut PpcSectionMem,
placement_ptr: u32,
placement: PpcQ3CameraPlacement,
) -> Option<()> {
ppc_write_q3_vector3d(memory, placement_ptr, placement.camera_location)?;
ppc_write_q3_vector3d(
memory,
placement_ptr.checked_add(12)?,
placement.point_of_interest,
)?;
ppc_write_q3_vector3d(memory, placement_ptr.checked_add(24)?, placement.up_vector)?;
Some(())
}
fn ppc_read_q3_camera_range(memory: &mut PpcSectionMem, range_ptr: u32) -> Option<(f32, f32)> {
Some((
ppc_read_f32_be(memory, range_ptr)?,
ppc_read_f32_be(memory, range_ptr.checked_add(4)?)?,
))
}
fn ppc_write_q3_camera_range(
memory: &mut PpcSectionMem,
range_ptr: u32,
hither: f32,
yon: f32,
) -> Option<()> {
ppc_write_f32_be(memory, range_ptr, hither)?;
ppc_write_f32_be(memory, range_ptr.checked_add(4)?, yon)?;
Some(())
}
fn ppc_read_q3_camera_viewport(
memory: &mut PpcSectionMem,
viewport_ptr: u32,
) -> Option<((f32, f32), f32, f32)> {
Some((
ppc_read_q3_vector2d(memory, viewport_ptr)?,
ppc_read_f32_be(
memory,
viewport_ptr.checked_add(PPC_Q3_CAMERA_VIEWPORT_WIDTH_OFFSET)?,
)?,
ppc_read_f32_be(
memory,
viewport_ptr.checked_add(PPC_Q3_CAMERA_VIEWPORT_HEIGHT_OFFSET)?,
)?,
))
}
fn ppc_write_q3_camera_viewport(
memory: &mut PpcSectionMem,
viewport_ptr: u32,
origin: (f32, f32),
width: f32,
height: f32,
) -> Option<()> {
ppc_write_q3_vector2d(memory, viewport_ptr, origin)?;
ppc_write_f32_be(
memory,
viewport_ptr.checked_add(PPC_Q3_CAMERA_VIEWPORT_WIDTH_OFFSET)?,
width,
)?;
ppc_write_f32_be(
memory,
viewport_ptr.checked_add(PPC_Q3_CAMERA_VIEWPORT_HEIGHT_OFFSET)?,
height,
)?;
Some(())
}
fn ppc_q3_camera_record_valid(record: &PpcQ3CameraRecord) -> bool {
ppc_q3_camera_projection_matches_type(record.projection, record.camera_type)
&& ppc_q3_camera_placement_valid(record.placement)
&& ppc_q3_camera_range_valid(record.range_hither, record.range_yon)
&& ppc_q3_camera_viewport_valid(
record.viewport_origin,
record.viewport_width,
record.viewport_height,
)
&& ppc_q3_camera_projection_valid(record.projection)
}
fn ppc_q3_camera_range_valid(hither: f32, yon: f32) -> bool {
hither.is_finite() && yon.is_finite() && hither > 0.0 && yon > hither
}
fn ppc_q3_camera_viewport_valid(origin: (f32, f32), width: f32, height: f32) -> bool {
origin.0.is_finite()
&& origin.1.is_finite()
&& width.is_finite()
&& height.is_finite()
&& width > 0.0
&& height > 0.0
}
fn ppc_q3_camera_projection_matches_type(
projection: PpcQ3CameraProjection,
camera_type: u32,
) -> bool {
matches!(
(camera_type, projection),
(
PPC_Q3_CAMERA_TYPE_VIEW_ANGLE_ASPECT,
PpcQ3CameraProjection::ViewAngleAspect { .. }
) | (
PPC_Q3_CAMERA_TYPE_ORTHOGRAPHIC,
PpcQ3CameraProjection::Orthographic { .. }
) | (
PPC_Q3_CAMERA_TYPE_VIEW_PLANE,
PpcQ3CameraProjection::ViewPlane { .. }
)
)
}
fn ppc_q3_camera_projection_valid(projection: PpcQ3CameraProjection) -> bool {
match projection {
PpcQ3CameraProjection::ViewAngleAspect {
fov,
aspect_ratio_x_to_y,
} => {
fov.is_finite()
&& fov > 0.0
&& aspect_ratio_x_to_y.is_finite()
&& aspect_ratio_x_to_y > 0.0
}
PpcQ3CameraProjection::Orthographic {
left,
top,
right,
bottom,
} => {
left.is_finite()
&& top.is_finite()
&& right.is_finite()
&& bottom.is_finite()
&& left < right
&& bottom < top
}
PpcQ3CameraProjection::ViewPlane {
view_plane,
half_width_at_view_plane,
half_height_at_view_plane,
center_x_on_view_plane,
center_y_on_view_plane,
} => {
view_plane.is_finite()
&& view_plane > 0.0
&& half_width_at_view_plane.is_finite()
&& half_width_at_view_plane > 0.0
&& half_height_at_view_plane.is_finite()
&& half_height_at_view_plane > 0.0
&& center_x_on_view_plane.is_finite()
&& center_y_on_view_plane.is_finite()
}
}
}
fn ppc_q3_camera_placement_valid(placement: PpcQ3CameraPlacement) -> bool {
let direction = ppc_q3_vector3d_sub(placement.point_of_interest, placement.camera_location);
let Some(forward) = ppc_q3_vector3d_normalized_value(direction) else {
return false;
};
let Some(up) = ppc_q3_vector3d_normalized_value(placement.up_vector) else {
return false;
};
ppc_q3_vector3d_normalized_value(ppc_q3_vector3d_cross_values(forward, up)).is_some()
}
fn ppc_q3_camera_world_to_view_matrix(placement: PpcQ3CameraPlacement) -> Option<[[f32; 4]; 4]> {
let eye = placement.camera_location;
let forward =
ppc_q3_vector3d_normalized_value(ppc_q3_vector3d_sub(placement.point_of_interest, eye))?;
let up = ppc_q3_vector3d_normalized_value(placement.up_vector)?;
let right = ppc_q3_vector3d_normalized_value(ppc_q3_vector3d_cross_values(forward, up))?;
let true_up = ppc_q3_vector3d_cross_values(right, forward);
Some([
[right.0, true_up.0, -forward.0, 0.0],
[right.1, true_up.1, -forward.1, 0.0],
[right.2, true_up.2, -forward.2, 0.0],
[
-ppc_q3_vector3d_dot(eye, right),
-ppc_q3_vector3d_dot(eye, true_up),
ppc_q3_vector3d_dot(eye, forward),
1.0,
],
])
}
fn ppc_q3_camera_view_to_frustum_matrix(record: &PpcQ3CameraRecord) -> Option<[[f32; 4]; 4]> {
if !ppc_q3_camera_record_valid(record) {
return None;
}
let hither = record.range_hither;
let yon = record.range_yon;
let depth = hither - yon;
match record.projection {
PpcQ3CameraProjection::ViewAngleAspect {
fov,
aspect_ratio_x_to_y,
} => {
let half_fov_tan = (fov * 0.5).tan();
if !half_fov_tan.is_finite() || half_fov_tan <= 0.0 {
return None;
}
let max_axis_scale = 1.0 / half_fov_tan;
let (x_scale, y_scale) = if aspect_ratio_x_to_y >= 1.0 {
(max_axis_scale / aspect_ratio_x_to_y, max_axis_scale)
} else {
(max_axis_scale, max_axis_scale * aspect_ratio_x_to_y)
};
Some(ppc_q3_perspective_frustum_matrix(
x_scale, y_scale, 0.0, 0.0, hither, yon, depth,
))
}
PpcQ3CameraProjection::Orthographic {
left,
top,
right,
bottom,
} => Some([
[2.0 / (right - left), 0.0, 0.0, 0.0],
[0.0, 2.0 / (top - bottom), 0.0, 0.0],
[0.0, 0.0, -1.0 / depth, 0.0],
[
-(right + left) / (right - left),
-(top + bottom) / (top - bottom),
-hither / depth,
1.0,
],
]),
PpcQ3CameraProjection::ViewPlane {
view_plane,
half_width_at_view_plane,
half_height_at_view_plane,
center_x_on_view_plane,
center_y_on_view_plane,
} => Some(ppc_q3_perspective_frustum_matrix(
view_plane / half_width_at_view_plane,
view_plane / half_height_at_view_plane,
center_x_on_view_plane / half_width_at_view_plane,
center_y_on_view_plane / half_height_at_view_plane,
hither,
yon,
depth,
)),
}
}
fn ppc_q3_perspective_frustum_matrix(
x_scale: f32,
y_scale: f32,
x_offset: f32,
y_offset: f32,
hither: f32,
yon: f32,
_depth: f32,
) -> [[f32; 4]; 4] {
let q = yon / (yon - hither);
[
[x_scale, 0.0, 0.0, 0.0],
[0.0, y_scale, 0.0, 0.0],
[x_offset, y_offset, q, -1.0],
[0.0, 0.0, q * hither, 0.0],
]
}
fn ppc_q3_ambient_light_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_lights: &mut Vec<PpcQ3LightRecord>,
) -> u32 {
let data_ptr = cpu.gpr[3];
if data_ptr == 0 {
return 0;
}
let Some(data) = ppc_read_q3_light_data(memory, data_ptr) else {
return 0;
};
if !ppc_q3_light_data_valid(data) {
return 0;
}
let light = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_LIGHT_TYPE_AMBIENT,
0,
PPC_Q3_LIGHT_DATA_SIZE,
);
if light != 0 {
q3_lights.push(PpcQ3LightRecord {
light,
light_type: PPC_Q3_LIGHT_TYPE_AMBIENT,
data,
kind: PpcQ3LightKind::Ambient,
});
}
light
}
fn ppc_q3_directional_light_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_lights: &mut Vec<PpcQ3LightRecord>,
) -> u32 {
let data_ptr = cpu.gpr[3];
if data_ptr == 0 {
return 0;
}
let Some((data, casts_shadows, direction)) =
ppc_read_q3_directional_light_data(memory, data_ptr)
else {
return 0;
};
if !ppc_q3_light_data_valid(data)
|| !ppc_q3_boolean_valid(casts_shadows)
|| ppc_q3_vector3d_normalized_value(direction).is_none()
{
return 0;
}
let light = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
0,
PPC_Q3_DIRECTIONAL_LIGHT_DATA_SIZE,
);
if light != 0 {
q3_lights.push(PpcQ3LightRecord {
light,
light_type: PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
data,
kind: PpcQ3LightKind::Directional {
casts_shadows,
direction,
},
});
}
light
}
fn ppc_q3_light_get_type(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
_q3_lights: &[PpcQ3LightRecord],
) -> u32 {
let light = cpu.gpr[3];
let light_type = ppc_q3_object_type_for_handle(q3_objects, light);
if ppc_q3_object_type_is_light(light_type) {
light_type
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
PPC_Q3_TYPE_NONE
}
}
fn ppc_q3_light_get_state(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let state_out_ptr = cpu.gpr[4];
if state_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, state_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_light_handle(q3_objects, q3_error_state, light) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
memory
.write_u32_be(state_out_ptr, record.data.is_on)
.is_some()
}
fn ppc_q3_light_set_state(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let is_on = cpu.gpr[4];
if !ppc_q3_boolean_valid(is_on) {
return false;
}
if !ppc_q3_validate_light_handle(q3_objects, q3_error_state, light) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
record.data.is_on = is_on;
true
}
fn ppc_q3_light_get_brightness(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let brightness_out_ptr = cpu.gpr[4];
if brightness_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, brightness_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_light_handle(q3_objects, q3_error_state, light) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
ppc_write_f32_be(memory, brightness_out_ptr, record.data.brightness).is_some()
}
fn ppc_q3_light_set_brightness(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
brightness: f32,
) -> bool {
if !brightness.is_finite() {
return false;
}
let light = cpu.gpr[3];
if !ppc_q3_validate_light_handle(q3_objects, q3_error_state, light) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
record.data.brightness = brightness;
true
}
fn ppc_q3_light_get_color(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let color_out_ptr = cpu.gpr[4];
if color_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, color_out_ptr, PPC_Q3_VECTOR3D_SIZE)
{
return false;
}
if !ppc_q3_validate_light_handle(q3_objects, q3_error_state, light) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
ppc_write_q3_color_rgb(memory, color_out_ptr, record.data.color).is_some()
}
fn ppc_q3_light_set_color(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let color_ptr = cpu.gpr[4];
if color_ptr == 0 {
return false;
}
let Some(color) = ppc_read_q3_color_rgb(memory, color_ptr) else {
return false;
};
if !ppc_q3_color_rgb_valid(color) {
return false;
}
if !ppc_q3_validate_light_handle(q3_objects, q3_error_state, light) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
record.data.color = color;
true
}
fn ppc_q3_light_get_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let data_out_ptr = cpu.gpr[4];
if data_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, data_out_ptr, PPC_Q3_LIGHT_DATA_SIZE)
{
return false;
}
if !ppc_q3_validate_light_handle(q3_objects, q3_error_state, light) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
ppc_write_q3_light_data(memory, data_out_ptr, record.data).is_some()
}
fn ppc_q3_light_set_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let data_ptr = cpu.gpr[4];
if data_ptr == 0 {
return false;
}
let Some(data) = ppc_read_q3_light_data(memory, data_ptr) else {
return false;
};
if !ppc_q3_light_data_valid(data) {
return false;
}
if !ppc_q3_validate_light_handle(q3_objects, q3_error_state, light) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
record.data = data;
true
}
fn ppc_q3_validate_light_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
light: u32,
) -> bool {
if ppc_q3_object_type_is_light(ppc_q3_object_type_for_handle(q3_objects, light)) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_validate_typed_light_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
light: u32,
light_type: u32,
) -> bool {
if ppc_q3_object_type_for_handle(q3_objects, light) == light_type {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_ambient_light_get_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
ppc_q3_typed_light_get_data(
cpu,
memory,
q3_objects,
q3_error_state,
q3_lights,
PPC_Q3_LIGHT_TYPE_AMBIENT,
PPC_Q3_LIGHT_DATA_SIZE,
)
}
fn ppc_q3_ambient_light_set_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let data_ptr = cpu.gpr[4];
if data_ptr == 0 {
return false;
}
let Some(data) = ppc_read_q3_light_data(memory, data_ptr) else {
return false;
};
if !ppc_q3_light_data_valid(data) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_AMBIENT,
) {
return false;
}
let Some(record) = q3_lights
.iter_mut()
.find(|record| record.light == light && record.light_type == PPC_Q3_LIGHT_TYPE_AMBIENT)
else {
return false;
};
record.data = data;
true
}
fn ppc_q3_directional_light_get_cast_shadows_state(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let casts_out_ptr = cpu.gpr[4];
if casts_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, casts_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Directional { casts_shadows, .. } = record.kind else {
return false;
};
memory.write_u32_be(casts_out_ptr, casts_shadows).is_some()
}
fn ppc_q3_directional_light_set_cast_shadows_state(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let casts_shadows = cpu.gpr[4];
if !ppc_q3_boolean_valid(casts_shadows) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Directional {
casts_shadows: record_casts_shadows,
..
} = &mut record.kind
else {
return false;
};
*record_casts_shadows = casts_shadows;
true
}
fn ppc_q3_directional_light_get_direction(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let direction_out_ptr = cpu.gpr[4];
if direction_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, direction_out_ptr, PPC_Q3_VECTOR3D_SIZE)
{
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Directional { direction, .. } = record.kind else {
return false;
};
ppc_write_q3_vector3d(memory, direction_out_ptr, direction).is_some()
}
fn ppc_q3_directional_light_set_direction(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let direction_ptr = cpu.gpr[4];
if direction_ptr == 0 {
return false;
}
let Some(direction) = ppc_read_q3_vector3d(memory, direction_ptr) else {
return false;
};
if ppc_q3_vector3d_normalized_value(direction).is_none() {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Directional {
direction: record_direction,
..
} = &mut record.kind
else {
return false;
};
*record_direction = direction;
true
}
fn ppc_q3_directional_light_get_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
ppc_q3_typed_light_get_data(
cpu,
memory,
q3_objects,
q3_error_state,
q3_lights,
PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
PPC_Q3_DIRECTIONAL_LIGHT_DATA_SIZE,
)
}
fn ppc_q3_directional_light_set_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let data_ptr = cpu.gpr[4];
if data_ptr == 0 {
return false;
}
let Some((data, casts_shadows, direction)) =
ppc_read_q3_directional_light_data(memory, data_ptr)
else {
return false;
};
if !ppc_q3_light_data_valid(data)
|| !ppc_q3_boolean_valid(casts_shadows)
|| ppc_q3_vector3d_normalized_value(direction).is_none()
{
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_DIRECTIONAL,
) {
return false;
}
let Some(record) = q3_lights
.iter_mut()
.find(|record| record.light == light && record.light_type == PPC_Q3_LIGHT_TYPE_DIRECTIONAL)
else {
return false;
};
record.data = data;
record.kind = PpcQ3LightKind::Directional {
casts_shadows,
direction,
};
true
}
fn ppc_q3_point_light_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_lights: &mut Vec<PpcQ3LightRecord>,
) -> u32 {
let data_ptr = cpu.gpr[3];
if data_ptr == 0 {
return 0;
}
let Some((data, casts_shadows, attenuation, location)) =
ppc_read_q3_point_light_data(memory, data_ptr)
else {
return 0;
};
if !ppc_q3_point_light_data_valid(data, casts_shadows, attenuation, location) {
return 0;
}
let light = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_LIGHT_TYPE_POINT,
0,
PPC_Q3_POINT_LIGHT_DATA_SIZE,
);
if light != 0 {
q3_lights.push(PpcQ3LightRecord {
light,
light_type: PPC_Q3_LIGHT_TYPE_POINT,
data,
kind: PpcQ3LightKind::Point {
casts_shadows,
attenuation,
location,
},
});
}
light
}
fn ppc_q3_point_light_get_cast_shadows_state(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let casts_out_ptr = cpu.gpr[4];
if casts_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, casts_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_POINT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Point { casts_shadows, .. } = record.kind else {
return false;
};
memory.write_u32_be(casts_out_ptr, casts_shadows).is_some()
}
fn ppc_q3_point_light_set_cast_shadows_state(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let casts_shadows = cpu.gpr[4];
if !ppc_q3_boolean_valid(casts_shadows) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_POINT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Point {
casts_shadows: record_casts_shadows,
..
} = &mut record.kind
else {
return false;
};
*record_casts_shadows = casts_shadows;
true
}
fn ppc_q3_point_light_get_attenuation(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let attenuation_out_ptr = cpu.gpr[4];
if attenuation_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, attenuation_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_POINT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Point { attenuation, .. } = record.kind else {
return false;
};
memory
.write_u32_be(attenuation_out_ptr, attenuation)
.is_some()
}
fn ppc_q3_point_light_set_attenuation(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let attenuation = cpu.gpr[4];
if !ppc_q3_attenuation_type_valid(attenuation) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_POINT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Point {
attenuation: record_attenuation,
..
} = &mut record.kind
else {
return false;
};
*record_attenuation = attenuation;
true
}
fn ppc_q3_point_light_get_location(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let location_out_ptr = cpu.gpr[4];
if location_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, location_out_ptr, PPC_Q3_VECTOR3D_SIZE)
{
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_POINT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Point { location, .. } = record.kind else {
return false;
};
ppc_write_q3_vector3d(memory, location_out_ptr, location).is_some()
}
fn ppc_q3_point_light_set_location(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let location_ptr = cpu.gpr[4];
if location_ptr == 0 {
return false;
}
let Some(location) = ppc_read_q3_vector3d(memory, location_ptr) else {
return false;
};
if !ppc_q3_triplet_valid(location) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_POINT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Point {
location: record_location,
..
} = &mut record.kind
else {
return false;
};
*record_location = location;
true
}
fn ppc_q3_point_light_get_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
ppc_q3_typed_light_get_data(
cpu,
memory,
q3_objects,
q3_error_state,
q3_lights,
PPC_Q3_LIGHT_TYPE_POINT,
PPC_Q3_POINT_LIGHT_DATA_SIZE,
)
}
fn ppc_q3_point_light_set_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let data_ptr = cpu.gpr[4];
if data_ptr == 0 {
return false;
}
let Some((data, casts_shadows, attenuation, location)) =
ppc_read_q3_point_light_data(memory, data_ptr)
else {
return false;
};
if !ppc_q3_point_light_data_valid(data, casts_shadows, attenuation, location) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_POINT,
) {
return false;
}
let Some(record) = q3_lights
.iter_mut()
.find(|record| record.light == light && record.light_type == PPC_Q3_LIGHT_TYPE_POINT)
else {
return false;
};
record.data = data;
record.kind = PpcQ3LightKind::Point {
casts_shadows,
attenuation,
location,
};
true
}
fn ppc_q3_spot_light_new(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_lights: &mut Vec<PpcQ3LightRecord>,
) -> u32 {
let data_ptr = cpu.gpr[3];
if data_ptr == 0 {
return 0;
}
let Some((
data,
casts_shadows,
attenuation,
location,
direction,
hot_angle,
outer_angle,
fall_off,
)) = ppc_read_q3_spot_light_data(memory, data_ptr)
else {
return 0;
};
if !ppc_q3_spot_light_data_valid(
data,
casts_shadows,
attenuation,
location,
direction,
hot_angle,
outer_angle,
fall_off,
) {
return 0;
}
let light = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_LIGHT_TYPE_SPOT,
0,
PPC_Q3_SPOT_LIGHT_DATA_SIZE,
);
if light != 0 {
q3_lights.push(PpcQ3LightRecord {
light,
light_type: PPC_Q3_LIGHT_TYPE_SPOT,
data,
kind: PpcQ3LightKind::Spot {
casts_shadows,
attenuation,
location,
direction,
hot_angle,
outer_angle,
fall_off,
},
});
}
light
}
fn ppc_q3_spot_light_get_cast_shadows_state(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let casts_out_ptr = cpu.gpr[4];
if casts_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, casts_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot { casts_shadows, .. } = record.kind else {
return false;
};
memory.write_u32_be(casts_out_ptr, casts_shadows).is_some()
}
fn ppc_q3_spot_light_set_cast_shadows_state(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let casts_shadows = cpu.gpr[4];
if !ppc_q3_boolean_valid(casts_shadows) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot {
casts_shadows: record_casts_shadows,
..
} = &mut record.kind
else {
return false;
};
*record_casts_shadows = casts_shadows;
true
}
fn ppc_q3_spot_light_get_attenuation(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let attenuation_out_ptr = cpu.gpr[4];
if attenuation_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, attenuation_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot { attenuation, .. } = record.kind else {
return false;
};
memory
.write_u32_be(attenuation_out_ptr, attenuation)
.is_some()
}
fn ppc_q3_spot_light_set_attenuation(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let attenuation = cpu.gpr[4];
if !ppc_q3_attenuation_type_valid(attenuation) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot {
attenuation: record_attenuation,
..
} = &mut record.kind
else {
return false;
};
*record_attenuation = attenuation;
true
}
fn ppc_q3_spot_light_get_location(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let location_out_ptr = cpu.gpr[4];
if location_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, location_out_ptr, PPC_Q3_VECTOR3D_SIZE)
{
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot { location, .. } = record.kind else {
return false;
};
ppc_write_q3_vector3d(memory, location_out_ptr, location).is_some()
}
fn ppc_q3_spot_light_set_location(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let location_ptr = cpu.gpr[4];
if location_ptr == 0 {
return false;
}
let Some(location) = ppc_read_q3_vector3d(memory, location_ptr) else {
return false;
};
if !ppc_q3_triplet_valid(location) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot {
location: record_location,
..
} = &mut record.kind
else {
return false;
};
*record_location = location;
true
}
fn ppc_q3_spot_light_get_direction(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let direction_out_ptr = cpu.gpr[4];
if direction_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, direction_out_ptr, PPC_Q3_VECTOR3D_SIZE)
{
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot { direction, .. } = record.kind else {
return false;
};
ppc_write_q3_vector3d(memory, direction_out_ptr, direction).is_some()
}
fn ppc_q3_spot_light_set_direction(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let direction_ptr = cpu.gpr[4];
if direction_ptr == 0 {
return false;
}
let Some(direction) = ppc_read_q3_vector3d(memory, direction_ptr) else {
return false;
};
if ppc_q3_vector3d_normalized_value(direction).is_none() {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot {
direction: record_direction,
..
} = &mut record.kind
else {
return false;
};
*record_direction = direction;
true
}
fn ppc_q3_spot_light_get_hot_angle(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let angle_out_ptr = cpu.gpr[4];
if angle_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, angle_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot { hot_angle, .. } = record.kind else {
return false;
};
ppc_write_f32_be(memory, angle_out_ptr, hot_angle).is_some()
}
fn ppc_q3_spot_light_set_hot_angle(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
hot_angle: f32,
) -> bool {
if !ppc_q3_light_angle_valid(hot_angle) {
return false;
}
let light = cpu.gpr[3];
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot {
hot_angle: record_hot_angle,
outer_angle,
..
} = &mut record.kind
else {
return false;
};
if hot_angle > *outer_angle {
return false;
}
*record_hot_angle = hot_angle;
true
}
fn ppc_q3_spot_light_get_outer_angle(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let angle_out_ptr = cpu.gpr[4];
if angle_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, angle_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot { outer_angle, .. } = record.kind else {
return false;
};
ppc_write_f32_be(memory, angle_out_ptr, outer_angle).is_some()
}
fn ppc_q3_spot_light_set_outer_angle(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
outer_angle: f32,
) -> bool {
if !ppc_q3_light_angle_valid(outer_angle) {
return false;
}
let light = cpu.gpr[3];
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot {
hot_angle,
outer_angle: record_outer_angle,
..
} = &mut record.kind
else {
return false;
};
if outer_angle < *hot_angle {
return false;
}
*record_outer_angle = outer_angle;
true
}
fn ppc_q3_spot_light_get_fall_off(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let fall_off_out_ptr = cpu.gpr[4];
if fall_off_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, fall_off_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot { fall_off, .. } = record.kind else {
return false;
};
memory.write_u32_be(fall_off_out_ptr, fall_off).is_some()
}
fn ppc_q3_spot_light_set_fall_off(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let fall_off = cpu.gpr[4];
if !ppc_q3_fall_off_type_valid(fall_off) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights.iter_mut().find(|record| record.light == light) else {
return false;
};
let PpcQ3LightKind::Spot {
fall_off: record_fall_off,
..
} = &mut record.kind
else {
return false;
};
*record_fall_off = fall_off;
true
}
fn ppc_q3_spot_light_get_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
) -> bool {
ppc_q3_typed_light_get_data(
cpu,
memory,
q3_objects,
q3_error_state,
q3_lights,
PPC_Q3_LIGHT_TYPE_SPOT,
PPC_Q3_SPOT_LIGHT_DATA_SIZE,
)
}
fn ppc_q3_spot_light_set_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &mut [PpcQ3LightRecord],
) -> bool {
let light = cpu.gpr[3];
let data_ptr = cpu.gpr[4];
if data_ptr == 0 {
return false;
}
let Some((
data,
casts_shadows,
attenuation,
location,
direction,
hot_angle,
outer_angle,
fall_off,
)) = ppc_read_q3_spot_light_data(memory, data_ptr)
else {
return false;
};
if !ppc_q3_spot_light_data_valid(
data,
casts_shadows,
attenuation,
location,
direction,
hot_angle,
outer_angle,
fall_off,
) {
return false;
}
if !ppc_q3_validate_typed_light_handle(
q3_objects,
q3_error_state,
light,
PPC_Q3_LIGHT_TYPE_SPOT,
) {
return false;
}
let Some(record) = q3_lights
.iter_mut()
.find(|record| record.light == light && record.light_type == PPC_Q3_LIGHT_TYPE_SPOT)
else {
return false;
};
record.data = data;
record.kind = PpcQ3LightKind::Spot {
casts_shadows,
attenuation,
location,
direction,
hot_angle,
outer_angle,
fall_off,
};
true
}
fn ppc_q3_typed_light_get_data(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_lights: &[PpcQ3LightRecord],
light_type: u32,
data_size: u32,
) -> bool {
let light = cpu.gpr[3];
let data_out_ptr = cpu.gpr[4];
if data_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, data_out_ptr, data_size) {
return false;
}
if !ppc_q3_validate_typed_light_handle(q3_objects, q3_error_state, light, light_type) {
return false;
}
let Some(record) = q3_lights
.iter()
.find(|record| record.light == light && record.light_type == light_type)
else {
return false;
};
match data_size {
PPC_Q3_DIRECTIONAL_LIGHT_DATA_SIZE => {
ppc_write_q3_directional_light_data(memory, data_out_ptr, record).is_some()
}
PPC_Q3_POINT_LIGHT_DATA_SIZE => {
ppc_write_q3_point_light_data(memory, data_out_ptr, record).is_some()
}
PPC_Q3_SPOT_LIGHT_DATA_SIZE => {
ppc_write_q3_spot_light_data(memory, data_out_ptr, record).is_some()
}
_ => ppc_write_q3_light_data(memory, data_out_ptr, record.data).is_some(),
}
}
fn ppc_read_q3_light_data(memory: &mut PpcSectionMem, data_ptr: u32) -> Option<PpcQ3LightData> {
Some(PpcQ3LightData {
is_on: memory.read_u32_be(data_ptr)?,
brightness: ppc_read_f32_be(memory, data_ptr.checked_add(4)?)?,
color: ppc_read_q3_color_rgb(memory, data_ptr.checked_add(8)?)?,
})
}
fn ppc_write_q3_light_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
data: PpcQ3LightData,
) -> Option<()> {
memory.write_u32_be(data_ptr, data.is_on)?;
ppc_write_f32_be(memory, data_ptr.checked_add(4)?, data.brightness)?;
ppc_write_q3_color_rgb(memory, data_ptr.checked_add(8)?, data.color)?;
Some(())
}
fn ppc_read_q3_directional_light_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
) -> Option<(PpcQ3LightData, u32, (f32, f32, f32))> {
Some((
ppc_read_q3_light_data(memory, data_ptr)?,
memory.read_u32_be(data_ptr.checked_add(20)?)?,
ppc_read_q3_vector3d(memory, data_ptr.checked_add(24)?)?,
))
}
fn ppc_write_q3_directional_light_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
record: &PpcQ3LightRecord,
) -> Option<()> {
let PpcQ3LightKind::Directional {
casts_shadows,
direction,
} = record.kind
else {
return None;
};
ppc_write_q3_light_data(memory, data_ptr, record.data)?;
memory.write_u32_be(data_ptr.checked_add(20)?, casts_shadows)?;
ppc_write_q3_vector3d(memory, data_ptr.checked_add(24)?, direction)?;
Some(())
}
fn ppc_read_q3_point_light_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
) -> Option<(PpcQ3LightData, u32, u32, (f32, f32, f32))> {
Some((
ppc_read_q3_light_data(memory, data_ptr)?,
memory.read_u32_be(data_ptr.checked_add(20)?)?,
memory.read_u32_be(data_ptr.checked_add(24)?)?,
ppc_read_q3_vector3d(memory, data_ptr.checked_add(28)?)?,
))
}
fn ppc_write_q3_point_light_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
record: &PpcQ3LightRecord,
) -> Option<()> {
let PpcQ3LightKind::Point {
casts_shadows,
attenuation,
location,
} = record.kind
else {
return None;
};
ppc_write_q3_light_data(memory, data_ptr, record.data)?;
memory.write_u32_be(data_ptr.checked_add(20)?, casts_shadows)?;
memory.write_u32_be(data_ptr.checked_add(24)?, attenuation)?;
ppc_write_q3_vector3d(memory, data_ptr.checked_add(28)?, location)?;
Some(())
}
#[allow(clippy::type_complexity)]
fn ppc_read_q3_spot_light_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
) -> Option<(
PpcQ3LightData,
u32,
u32,
(f32, f32, f32),
(f32, f32, f32),
f32,
f32,
u32,
)> {
Some((
ppc_read_q3_light_data(memory, data_ptr)?,
memory.read_u32_be(data_ptr.checked_add(20)?)?,
memory.read_u32_be(data_ptr.checked_add(24)?)?,
ppc_read_q3_vector3d(memory, data_ptr.checked_add(28)?)?,
ppc_read_q3_vector3d(memory, data_ptr.checked_add(40)?)?,
ppc_read_f32_be(memory, data_ptr.checked_add(52)?)?,
ppc_read_f32_be(memory, data_ptr.checked_add(56)?)?,
memory.read_u32_be(data_ptr.checked_add(60)?)?,
))
}
fn ppc_write_q3_spot_light_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
record: &PpcQ3LightRecord,
) -> Option<()> {
let PpcQ3LightKind::Spot {
casts_shadows,
attenuation,
location,
direction,
hot_angle,
outer_angle,
fall_off,
} = record.kind
else {
return None;
};
ppc_write_q3_light_data(memory, data_ptr, record.data)?;
memory.write_u32_be(data_ptr.checked_add(20)?, casts_shadows)?;
memory.write_u32_be(data_ptr.checked_add(24)?, attenuation)?;
ppc_write_q3_vector3d(memory, data_ptr.checked_add(28)?, location)?;
ppc_write_q3_vector3d(memory, data_ptr.checked_add(40)?, direction)?;
ppc_write_f32_be(memory, data_ptr.checked_add(52)?, hot_angle)?;
ppc_write_f32_be(memory, data_ptr.checked_add(56)?, outer_angle)?;
memory.write_u32_be(data_ptr.checked_add(60)?, fall_off)?;
Some(())
}
fn ppc_q3_light_data_valid(data: PpcQ3LightData) -> bool {
ppc_q3_boolean_valid(data.is_on)
&& data.brightness.is_finite()
&& ppc_q3_color_rgb_valid(data.color)
}
fn ppc_q3_point_light_data_valid(
data: PpcQ3LightData,
casts_shadows: u32,
attenuation: u32,
location: (f32, f32, f32),
) -> bool {
ppc_q3_light_data_valid(data)
&& ppc_q3_boolean_valid(casts_shadows)
&& ppc_q3_attenuation_type_valid(attenuation)
&& ppc_q3_triplet_valid(location)
}
fn ppc_q3_spot_light_data_valid(
data: PpcQ3LightData,
casts_shadows: u32,
attenuation: u32,
location: (f32, f32, f32),
direction: (f32, f32, f32),
hot_angle: f32,
outer_angle: f32,
fall_off: u32,
) -> bool {
ppc_q3_light_data_valid(data)
&& ppc_q3_boolean_valid(casts_shadows)
&& ppc_q3_attenuation_type_valid(attenuation)
&& ppc_q3_triplet_valid(location)
&& ppc_q3_vector3d_normalized_value(direction).is_some()
&& ppc_q3_light_angle_valid(hot_angle)
&& ppc_q3_light_angle_valid(outer_angle)
&& hot_angle <= outer_angle
&& ppc_q3_fall_off_type_valid(fall_off)
}
fn ppc_q3_boolean_valid(value: u32) -> bool {
value <= 1
}
fn ppc_q3_color_rgb_valid((red, green, blue): (f32, f32, f32)) -> bool {
red.is_finite() && green.is_finite() && blue.is_finite()
}
fn ppc_q3_triplet_valid((x, y, z): (f32, f32, f32)) -> bool {
x.is_finite() && y.is_finite() && z.is_finite()
}
fn ppc_q3_attenuation_type_valid(value: u32) -> bool {
value <= PPC_Q3_ATTENUATION_TYPE_INVERSE_DISTANCE_SQUARED
}
fn ppc_q3_light_angle_valid(value: f32) -> bool {
value.is_finite() && value >= 0.0 && value <= std::f32::consts::FRAC_PI_2
}
fn ppc_q3_fall_off_type_valid(value: u32) -> bool {
value <= PPC_Q3_FALL_OFF_TYPE_COSINE
}
fn ppc_q3_shader_set_uv_transform(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_shader_uv_transforms: &mut Vec<PpcQ3ShaderUvTransformRecord>,
) -> bool {
let shader = cpu.gpr[3];
let matrix_ptr = cpu.gpr[4];
if matrix_ptr == 0 {
return false;
}
if !ppc_q3_validate_shader_handle(q3_objects, q3_error_state, shader) {
return false;
}
let Some(matrix) = ppc_read_q3_matrix3x3(memory, matrix_ptr) else {
return false;
};
if let Some(record) = q3_shader_uv_transforms
.iter_mut()
.find(|record| record.shader == shader)
{
record.matrix = matrix;
} else {
q3_shader_uv_transforms.push(PpcQ3ShaderUvTransformRecord { shader, matrix });
}
true
}
fn ppc_q3_shader_get_uv_transform(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_shader_uv_transforms: &[PpcQ3ShaderUvTransformRecord],
) -> bool {
let shader = cpu.gpr[3];
let matrix_out_ptr = cpu.gpr[4];
if matrix_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, matrix_out_ptr, PPC_Q3_MATRIX3X3_SIZE)
{
return false;
}
if !ppc_q3_validate_shader_handle(q3_objects, q3_error_state, shader) {
return false;
}
let matrix = q3_shader_uv_transforms
.iter()
.find(|record| record.shader == shader)
.map(|record| record.matrix)
.unwrap_or_else(ppc_q3_matrix3x3_identity);
ppc_write_q3_matrix3x3(memory, matrix_out_ptr, &matrix).is_some()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PpcQ3ShaderBoundaryAxis {
U,
V,
}
fn ppc_q3_shader_set_boundary(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_shader_boundaries: &mut Vec<PpcQ3ShaderBoundaryRecord>,
axis: PpcQ3ShaderBoundaryAxis,
) -> bool {
let shader = cpu.gpr[3];
let boundary = cpu.gpr[4];
if !ppc_q3_shader_boundary_valid(boundary) {
return false;
}
if !ppc_q3_validate_shader_handle(q3_objects, q3_error_state, shader) {
return false;
}
let record = ppc_q3_shader_boundary_record_mut(q3_shader_boundaries, shader);
match axis {
PpcQ3ShaderBoundaryAxis::U => record.u_boundary = boundary,
PpcQ3ShaderBoundaryAxis::V => record.v_boundary = boundary,
}
true
}
fn ppc_q3_shader_get_boundary(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_shader_boundaries: &[PpcQ3ShaderBoundaryRecord],
axis: PpcQ3ShaderBoundaryAxis,
) -> bool {
let shader = cpu.gpr[3];
let boundary_out_ptr = cpu.gpr[4];
if boundary_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, boundary_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_shader_handle(q3_objects, q3_error_state, shader) {
return false;
}
let record = q3_shader_boundaries
.iter()
.find(|record| record.shader == shader)
.copied()
.unwrap_or_else(|| PpcQ3ShaderBoundaryRecord::new(shader));
let boundary = match axis {
PpcQ3ShaderBoundaryAxis::U => record.u_boundary,
PpcQ3ShaderBoundaryAxis::V => record.v_boundary,
};
memory.write_u32_be(boundary_out_ptr, boundary).is_some()
}
fn ppc_q3_shader_boundary_record_mut(
q3_shader_boundaries: &mut Vec<PpcQ3ShaderBoundaryRecord>,
shader: u32,
) -> &mut PpcQ3ShaderBoundaryRecord {
if let Some(index) = q3_shader_boundaries
.iter()
.position(|record| record.shader == shader)
{
return &mut q3_shader_boundaries[index];
}
q3_shader_boundaries.push(PpcQ3ShaderBoundaryRecord::new(shader));
q3_shader_boundaries
.last_mut()
.expect("just pushed Q3 shader boundary record")
}
fn ppc_q3_shader_boundary_valid(boundary: u32) -> bool {
matches!(
boundary,
PPC_Q3_SHADER_UV_BOUNDARY_WRAP | PPC_Q3_SHADER_UV_BOUNDARY_CLAMP
)
}
fn ppc_q3_validate_shader_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
shader: u32,
) -> bool {
if ppc_q3_object_type_is_shader(ppc_q3_object_type_for_handle(q3_objects, shader)) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_style_kind_for_type(object_type: u32) -> Option<PpcQ3StyleKind> {
match object_type {
PPC_Q3_STYLE_TYPE_BACKFACING => Some(PpcQ3StyleKind::Backfacing),
PPC_Q3_STYLE_TYPE_INTERPOLATION => Some(PpcQ3StyleKind::Interpolation),
PPC_Q3_STYLE_TYPE_FILL => Some(PpcQ3StyleKind::Fill),
PPC_Q3_STYLE_TYPE_ORIENTATION => Some(PpcQ3StyleKind::Orientation),
_ => None,
}
}
fn ppc_q3_style_new(
cpu: &PpcCpu,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
kind: PpcQ3StyleKind,
object_type: u32,
) -> u32 {
let value = cpu.gpr[3];
if !ppc_q3_style_value_valid(kind, value) {
return 0;
}
let style = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
object_type,
0,
0,
);
if style != 0 {
ppc_q3_style_store_data(q3_styles, style, kind, value);
}
style
}
fn ppc_q3_style_store_data(
q3_styles: &mut Vec<PpcQ3StyleRecord>,
style: u32,
kind: PpcQ3StyleKind,
value: u32,
) {
if style == 0 || !ppc_q3_style_value_valid(kind, value) {
return;
}
if let Some(record) = q3_styles
.iter_mut()
.find(|record| record.style == style && record.kind == kind)
{
record.value = value;
} else {
q3_styles.push(PpcQ3StyleRecord { style, kind, value });
}
}
fn ppc_q3_style_get(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_styles: &[PpcQ3StyleRecord],
kind: PpcQ3StyleKind,
) -> bool {
let style = cpu.gpr[3];
let value_out_ptr = cpu.gpr[4];
if value_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, value_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_style_handle(q3_objects, q3_error_state, style, kind) {
return false;
}
let Some(record) = q3_styles
.iter()
.find(|record| record.style == style && record.kind == kind)
else {
return false;
};
memory.write_u32_be(value_out_ptr, record.value).is_some()
}
fn ppc_q3_style_set(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_styles: &mut [PpcQ3StyleRecord],
kind: PpcQ3StyleKind,
) -> bool {
let style = cpu.gpr[3];
let value = cpu.gpr[4];
if !ppc_q3_style_value_valid(kind, value) {
return false;
}
if !ppc_q3_validate_style_handle(q3_objects, q3_error_state, style, kind) {
return false;
}
let Some(record) = q3_styles
.iter_mut()
.find(|record| record.style == style && record.kind == kind)
else {
return false;
};
record.value = value;
true
}
fn ppc_q3_validate_style_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
style: u32,
kind: PpcQ3StyleKind,
) -> bool {
if ppc_q3_style_kind_for_type(ppc_q3_object_type_for_handle(q3_objects, style)) == Some(kind) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_style_value_valid(kind: PpcQ3StyleKind, value: u32) -> bool {
match kind {
PpcQ3StyleKind::Backfacing => value <= PPC_Q3_BACKFACING_STYLE_FLIP,
PpcQ3StyleKind::Interpolation => value <= PPC_Q3_INTERPOLATION_STYLE_PIXEL,
PpcQ3StyleKind::Fill => value <= PPC_Q3_FILL_STYLE_POINTS,
PpcQ3StyleKind::Orientation => value <= PPC_Q3_ORIENTATION_STYLE_CLOCKWISE,
}
}
fn ppc_q3_attribute_set_add(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
q3_error_state: &mut PpcQ3ErrorState,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_files: &mut Vec<PpcQ3FileRecord>,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &mut Vec<PpcQ3FileGroupRecord>,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_view_state_stack: &mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_completed_frames: &mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
q3_fog_styles: &mut Vec<PpcQ3FogStyleRecord>,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_shader_uv_transforms: &mut Vec<PpcQ3ShaderUvTransformRecord>,
q3_shader_boundaries: &mut Vec<PpcQ3ShaderBoundaryRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
q3_draw_contexts: &mut Vec<PpcQ3DrawContextRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
q3_lights: &mut Vec<PpcQ3LightRecord>,
) -> bool {
let attribute_set = cpu.gpr[3];
let attribute_type = cpu.gpr[4];
let data_ptr = cpu.gpr[5];
if data_ptr == 0 {
return false;
}
let Some(data_size) = ppc_q3_attribute_data_size(attribute_type) else {
return false;
};
let Some(data) = ppc_q3_read_bytes(memory, data_ptr, data_size) else {
return false;
};
if !ppc_q3_validate_attribute_set_handle(q3_objects, q3_error_state, attribute_set) {
return false;
}
let Some(surface_shader) =
ppc_q3_attribute_surface_shader_handle_for_data(attribute_type, &data)
else {
ppc_q3_attribute_store_data(q3_attributes, attribute_set, attribute_type, data);
return true;
};
if !ppc_q3_attribute_surface_shader_accepts_object(q3_objects, q3_error_state, surface_shader) {
return false;
}
let old_surface_shader = q3_attributes
.iter()
.find(|record| {
record.attribute_set == attribute_set && record.attribute_type == attribute_type
})
.and_then(ppc_q3_attribute_surface_shader_handle)
.unwrap_or(0);
if old_surface_shader == surface_shader {
ppc_q3_attribute_store_data(q3_attributes, attribute_set, attribute_type, data);
return true;
}
let surface_shader_exists = ppc_q3_object_exists(q3_objects, surface_shader);
let retained = ppc_q3_object_retain(q3_objects, q3_object_refs, surface_shader);
ppc_q3_attribute_store_data(q3_attributes, attribute_set, attribute_type, data);
if old_surface_shader != 0 && old_surface_shader != surface_shader {
let mut stores = PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
};
let _ = ppc_q3_object_release_reference(&mut stores, old_surface_shader);
}
retained || !surface_shader_exists
}
fn ppc_q3_attribute_store_data(
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
attribute_set: u32,
attribute_type: u32,
data: Vec<u8>,
) {
if let Some(record) = q3_attributes.iter_mut().find(|record| {
record.attribute_set == attribute_set && record.attribute_type == attribute_type
}) {
record.data = data;
} else {
q3_attributes.push(PpcQ3AttributeRecord {
attribute_set,
attribute_type,
data,
});
}
}
fn ppc_q3_attribute_set_get(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_error_state: &mut PpcQ3ErrorState,
q3_attributes: &[PpcQ3AttributeRecord],
) -> bool {
let attribute_set = cpu.gpr[3];
let attribute_type = cpu.gpr[4];
let data_out_ptr = cpu.gpr[5];
let Some(data_size) = ppc_q3_attribute_data_size(attribute_type) else {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3AttributeSet_Get failed reason=unknown-size set=${:08X} type={} out=${:08X}",
attribute_set, attribute_type, data_out_ptr
);
}
return false;
};
if data_out_ptr != 0 && !ppc_memory_can_write_bytes(memory, data_out_ptr, data_size) {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3AttributeSet_Get failed reason=bad-out set=${:08X} type={} out=${:08X} size={}",
attribute_set, attribute_type, data_out_ptr, data_size
);
}
return false;
}
if !ppc_q3_validate_attribute_set_handle(q3_objects, q3_error_state, attribute_set) {
if ppc_hle_trace_enabled() {
let actual_type = ppc_q3_object_type_for_handle(q3_objects, attribute_set);
eprintln!(
"[PPC-TRACE] Q3AttributeSet_Get failed reason=bad-set set=${:08X} set_type='{}' type={} out=${:08X}",
attribute_set,
format_ppc_fourcc(actual_type),
attribute_type,
data_out_ptr
);
}
return false;
}
let Some(record) = q3_attributes.iter().find(|record| {
record.attribute_set == attribute_set && record.attribute_type == attribute_type
}) else {
if ppc_hle_trace_enabled() {
let known_types: Vec<u32> = q3_attributes
.iter()
.filter(|record| record.attribute_set == attribute_set)
.map(|record| record.attribute_type)
.collect();
eprintln!(
"[PPC-TRACE] Q3AttributeSet_Get failed reason=missing-record set=${:08X} type={} out=${:08X} known_types={:?}",
attribute_set, attribute_type, data_out_ptr, known_types
);
}
return false;
};
if data_out_ptr == 0 {
return true;
}
if record.data.len() != data_size as usize {
return false;
}
let surface_shader = ppc_q3_attribute_surface_shader_handle(record);
if let Some(surface_shader) = surface_shader {
if !ppc_q3_attribute_surface_shader_accepts_object(
q3_objects,
q3_error_state,
surface_shader,
) {
return false;
}
}
if !ppc_q3_write_bytes(memory, data_out_ptr, &record.data) {
return false;
}
if let Some(surface_shader) = surface_shader {
let _ = ppc_q3_object_retain(q3_objects, q3_object_refs, surface_shader);
}
true
}
fn ppc_q3_attribute_set_clear(
cpu: &PpcCpu,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
q3_error_state: &mut PpcQ3ErrorState,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_files: &mut Vec<PpcQ3FileRecord>,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &mut Vec<PpcQ3FileGroupRecord>,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_view_state_stack: &mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_completed_frames: &mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
q3_fog_styles: &mut Vec<PpcQ3FogStyleRecord>,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_shader_uv_transforms: &mut Vec<PpcQ3ShaderUvTransformRecord>,
q3_shader_boundaries: &mut Vec<PpcQ3ShaderBoundaryRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
q3_draw_contexts: &mut Vec<PpcQ3DrawContextRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
q3_lights: &mut Vec<PpcQ3LightRecord>,
) -> bool {
let attribute_set = cpu.gpr[3];
let attribute_type = cpu.gpr[4];
if attribute_type == PPC_Q3_ATTRIBUTE_TYPE_NONE {
return false;
}
if !ppc_q3_validate_attribute_set_handle(q3_objects, q3_error_state, attribute_set) {
return false;
}
let released_surface_shaders: Vec<u32> = q3_attributes
.iter()
.filter(|record| {
record.attribute_set == attribute_set && record.attribute_type == attribute_type
})
.filter_map(ppc_q3_attribute_surface_shader_handle)
.collect();
q3_attributes.retain(|record| {
!(record.attribute_set == attribute_set && record.attribute_type == attribute_type)
});
if !released_surface_shaders.is_empty() {
let mut stores = PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
};
for surface_shader in released_surface_shaders {
let _ = ppc_q3_object_release_reference(&mut stores, surface_shader);
}
}
true
}
fn ppc_q3_attribute_set_contains(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_attributes: &[PpcQ3AttributeRecord],
) -> bool {
let attribute_set = cpu.gpr[3];
let attribute_type = cpu.gpr[4];
if attribute_type == PPC_Q3_ATTRIBUTE_TYPE_NONE {
return false;
}
if !ppc_q3_validate_attribute_set_handle(q3_objects, q3_error_state, attribute_set) {
return false;
}
q3_attributes.iter().any(|record| {
record.attribute_set == attribute_set && record.attribute_type == attribute_type
})
}
fn ppc_q3_attribute_set_get_next_attribute_type(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_attributes: &[PpcQ3AttributeRecord],
) -> bool {
let attribute_set = cpu.gpr[3];
let type_ptr = cpu.gpr[4];
if type_ptr == 0 || !ppc_memory_can_write_bytes(memory, type_ptr, 4) {
return false;
}
if !ppc_q3_validate_attribute_set_handle(q3_objects, q3_error_state, attribute_set) {
return false;
}
let Some(current_type) = memory.read_u32_be(type_ptr) else {
return false;
};
let next_type = q3_attributes
.iter()
.filter(|record| {
record.attribute_set == attribute_set && record.attribute_type > current_type
})
.map(|record| record.attribute_type)
.min()
.unwrap_or(PPC_Q3_ATTRIBUTE_TYPE_NONE);
memory.write_u32_be(type_ptr, next_type).is_some()
}
fn ppc_q3_validate_attribute_set_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
attribute_set: u32,
) -> bool {
if ppc_q3_object_type_for_handle(q3_objects, attribute_set) == PPC_Q3_TYPE_ATTRIBUTE_SET {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_attribute_data_size(attribute_type: u32) -> Option<u32> {
match attribute_type {
PPC_Q3_ATTRIBUTE_TYPE_SURFACE_UV | PPC_Q3_ATTRIBUTE_TYPE_SHADING_UV => Some(8),
PPC_Q3_ATTRIBUTE_TYPE_NORMAL
| PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR
| PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR
| PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR => Some(12),
PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT
| PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL
| PPC_Q3_ATTRIBUTE_TYPE_HIGHLIGHT_STATE
| PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER => Some(4),
PPC_Q3_ATTRIBUTE_TYPE_SURFACE_TANGENT => Some(24),
_ => None,
}
}
fn ppc_q3_object_exists(q3_objects: &[PpcQ3ObjectRecord], object: u32) -> bool {
object != 0 && q3_objects.iter().any(|record| record.object == object)
}
struct PpcQ3ObjectStores<'a> {
q3_objects: &'a mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &'a mut Vec<PpcQ3ObjectReferenceRecord>,
q3_renderer_preferences: &'a mut Vec<PpcQ3RendererPreferenceRecord>,
q3_files: &'a mut Vec<PpcQ3FileRecord>,
q3_group_memberships: &'a mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &'a mut Vec<PpcQ3FileGroupRecord>,
q3_views: &'a mut Vec<PpcQ3ViewStateRecord>,
q3_submissions: &'a mut Vec<PpcQ3SubmissionRecord>,
q3_view_transforms: &'a mut Vec<PpcQ3ViewTransformRecord>,
q3_submission_transforms: &'a mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &'a mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &'a mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &'a mut Vec<PpcQ3SubmissionLightRecord>,
q3_view_state_stack: &'a mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_completed_frames: &'a mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &'a mut Vec<PpcQ3RetainedFrameRecord>,
q3_fog_styles: &'a mut Vec<PpcQ3FogStyleRecord>,
q3_memory_storages: &'a mut Vec<PpcQ3MemoryStorageRecord>,
q3_attributes: &'a mut Vec<PpcQ3AttributeRecord>,
q3_shader_uv_transforms: &'a mut Vec<PpcQ3ShaderUvTransformRecord>,
q3_shader_boundaries: &'a mut Vec<PpcQ3ShaderBoundaryRecord>,
q3_mipmap_textures: &'a mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &'a mut Vec<PpcQ3TextureShaderRecord>,
q3_draw_contexts: &'a mut Vec<PpcQ3DrawContextRecord>,
q3_trimeshes: &'a mut Vec<PpcQ3TriMeshRecord>,
q3_styles: &'a mut Vec<PpcQ3StyleRecord>,
q3_cameras: &'a mut Vec<PpcQ3CameraRecord>,
q3_lights: &'a mut Vec<PpcQ3LightRecord>,
}
fn ppc_q3_object_reference_count(
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &[PpcQ3ObjectReferenceRecord],
object: u32,
) -> Option<u32> {
if !ppc_q3_object_exists(q3_objects, object) {
return None;
}
Some(
q3_object_refs
.iter()
.find(|record| record.object == object)
.map(|record| record.ref_count)
.unwrap_or(1),
)
}
fn ppc_q3_object_set_reference_count(
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
object: u32,
ref_count: u32,
) {
if ref_count <= 1 {
q3_object_refs.retain(|record| record.object != object);
return;
}
if let Some(record) = q3_object_refs
.iter_mut()
.find(|record| record.object == object)
{
record.ref_count = ref_count;
} else {
q3_object_refs.push(PpcQ3ObjectReferenceRecord { object, ref_count });
}
}
fn ppc_q3_object_retain(
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
object: u32,
) -> bool {
let Some(ref_count) = ppc_q3_object_reference_count(q3_objects, q3_object_refs, object) else {
return false;
};
ppc_q3_object_set_reference_count(q3_object_refs, object, ref_count.saturating_add(1));
true
}
fn ppc_q3_object_release_reference(stores: &mut PpcQ3ObjectStores<'_>, object: u32) -> bool {
let Some(ref_count) =
ppc_q3_object_reference_count(stores.q3_objects, stores.q3_object_refs, object)
else {
stores
.q3_object_refs
.retain(|record| record.object != object);
return false;
};
if ref_count > 1 {
ppc_q3_object_set_reference_count(stores.q3_object_refs, object, ref_count - 1);
return true;
}
ppc_q3_object_dispose_unreferenced(stores, object);
true
}
fn ppc_q3_object_dispose_unreferenced(stores: &mut PpcQ3ObjectStores<'_>, object: u32) {
let released_group_members: Vec<u32> = stores
.q3_group_memberships
.iter()
.filter(|record| record.group == object)
.map(|record| record.object)
.collect();
let released_view_slots: Vec<u32> = stores
.q3_views
.iter()
.filter(|record| record.view == object)
.flat_map(|record| {
[
record.renderer,
record.light_group,
record.draw_context,
record.camera,
]
})
.filter(|referenced_object| *referenced_object != 0)
.collect();
let released_texture_shader_textures: Vec<u32> = stores
.q3_texture_shaders
.iter()
.filter(|record| record.shader == object && record.texture != object)
.map(|record| record.texture)
.collect();
let released_mipmap_texture_storages: Vec<u32> = stores
.q3_mipmap_textures
.iter()
.filter(|record| record.texture == object)
.map(|record| ppc_q3_mipmap_texture_image_storage(&record.mipmap))
.filter(|storage| {
*storage != 0
&& *storage != object
&& ppc_q3_mipmap_image_storage_is_known_storage(stores.q3_objects, *storage)
})
.collect();
let released_file_storages: Vec<u32> = stores
.q3_files
.iter()
.filter(|record| record.file == object && record.storage != object)
.map(|record| record.storage)
.collect();
let released_attribute_surface_shaders: Vec<u32> = stores
.q3_attributes
.iter()
.filter(|record| record.attribute_set == object)
.filter_map(ppc_q3_attribute_surface_shader_handle)
.collect();
let released_trimesh_attribute_sets: Vec<u32> = stores
.q3_trimeshes
.iter()
.filter(|record| record.trimesh == object)
.flat_map(|record| record.triangle_attribute_sets.iter().copied())
.collect();
stores.q3_objects.retain(|record| record.object != object);
stores
.q3_object_refs
.retain(|record| record.object != object);
stores
.q3_renderer_preferences
.retain(|record| record.renderer != object);
stores
.q3_files
.retain(|record| record.file != object && record.storage != object);
for file_record in stores.q3_files.iter_mut() {
if file_record.read_object == object {
file_record.read_object = 0;
}
}
stores
.q3_group_memberships
.retain(|record| record.group != object && record.object != object);
// Objects read from a metafile retain their group hierarchy after the file object closes.
// Drop group metadata only when the group itself (or its parent) is disposed.
stores
.q3_file_groups
.retain(|record| record.group != object && record.parent_group != object);
for view in stores.q3_views.iter_mut() {
if view.renderer == object {
view.renderer = 0;
}
if view.light_group == object {
view.light_group = 0;
}
if view.draw_context == object {
view.draw_context = 0;
}
if view.camera == object {
view.camera = 0;
}
}
stores.q3_views.retain(|record| record.view != object);
stores.q3_submissions.retain(|record| {
record.view != object && record.primary != object && record.secondary != object
});
stores
.q3_view_transforms
.retain(|record| record.view != object);
stores.q3_submission_transforms.retain(|record| {
record.view != object && record.primary != object && record.secondary != object
});
stores
.q3_view_materials
.retain(|record| record.view != object);
for record in stores.q3_view_materials.iter_mut() {
if record.shader == object {
record.shader = 0;
}
record.styles.retain(|style| style.style != object);
record
.attributes
.retain(|attribute| attribute.attribute_set != object);
}
stores.q3_submission_materials.retain(|record| {
record.view != object
&& record.primary != object
&& record.secondary != object
&& record.shader != object
&& !record.styles.iter().any(|style| style.style == object)
&& !record
.shader_uv_transform
.map(|transform| transform.shader == object)
.unwrap_or(false)
&& !record
.shader_boundary
.map(|boundary| boundary.shader == object)
.unwrap_or(false)
&& !record
.texture_shader
.map(|shader| shader.shader == object || shader.texture == object)
.unwrap_or(false)
&& !record
.mipmap_texture
.as_ref()
.map(|texture| texture.texture == object)
.unwrap_or(false)
&& !record
.attributes
.iter()
.any(|attribute| attribute.attribute_set == object)
});
stores.q3_submission_lights.retain(|record| {
record.view != object
&& record.primary != object
&& record.secondary != object
&& record.light_group != object
&& !record.lights.iter().any(|light| light.light == object)
});
stores
.q3_view_state_stack
.retain(|record| !ppc_q3_view_state_snapshot_references_object(record, object));
stores
.q3_completed_frames
.retain(|frame| !ppc_q3_completed_frame_references_object(frame, object));
stores
.q3_retained_frames
.retain(|record| !ppc_q3_completed_frame_references_object(&record.frame, object));
stores.q3_fog_styles.retain(|record| record.view != object);
stores
.q3_memory_storages
.retain(|record| record.storage != object);
stores.q3_attributes.retain(|record| {
record.attribute_set != object
&& ppc_q3_attribute_surface_shader_handle(record) != Some(object)
});
stores
.q3_shader_uv_transforms
.retain(|record| record.shader != object);
stores
.q3_shader_boundaries
.retain(|record| record.shader != object);
stores
.q3_mipmap_textures
.retain(|record| record.texture != object);
stores
.q3_texture_shaders
.retain(|record| record.shader != object);
stores
.q3_draw_contexts
.retain(|record| record.draw_context != object);
stores
.q3_trimeshes
.retain(|record| record.trimesh != object);
stores.q3_styles.retain(|record| record.style != object);
stores.q3_cameras.retain(|record| record.camera != object);
stores.q3_lights.retain(|record| record.light != object);
for referenced_object in released_group_members
.into_iter()
.chain(released_view_slots)
.chain(released_texture_shader_textures)
.chain(released_mipmap_texture_storages)
.chain(released_file_storages)
.chain(released_attribute_surface_shaders)
.chain(released_trimesh_attribute_sets)
.filter(|referenced_object| *referenced_object != object)
{
let _ = ppc_q3_object_release_reference(stores, referenced_object);
}
}
fn ppc_q3_read_bytes(
memory: &mut PpcSectionMem,
source_ptr: u32,
byte_count: u32,
) -> Option<Vec<u8>> {
let mut data = Vec::with_capacity(byte_count as usize);
for offset in 0..byte_count {
data.push(memory.read_u8(source_ptr.checked_add(offset)?)?);
}
Some(data)
}
fn ppc_q3_write_bytes(memory: &mut PpcSectionMem, dest_ptr: u32, data: &[u8]) -> bool {
for (offset, byte) in data.iter().copied().enumerate() {
let Ok(offset) = u32::try_from(offset) else {
return false;
};
let Some(addr) = dest_ptr.checked_add(offset) else {
return false;
};
if memory.write_u8(addr, byte).is_none() {
return false;
}
}
true
}
fn ppc_q3_memory_storage_new(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
) -> u32 {
let source_ptr = cpu.gpr[3];
let requested_size = cpu.gpr[4];
let buffer_size = if source_ptr == 0 {
requested_size.max(PPC_Q3_MEMORY_STORAGE_DEFAULT_BUFFER_SIZE)
} else {
requested_size
};
let valid_size = if source_ptr == 0 { 0 } else { requested_size };
let Some(buffer_ptr) = ppc_q3_allocate_owned_storage_buffer(
process_memory_manager,
memory,
heap_cursor,
buffer_size,
last_mem_error,
) else {
return 0;
};
if source_ptr != 0
&& valid_size != 0
&& !ppc_q3_copy_or_zero(memory, source_ptr, buffer_ptr, valid_size)
{
return 0;
}
ppc_q3_memory_storage_create(
q3_objects,
next_q3_object,
q3_memory_storages,
buffer_ptr,
valid_size,
buffer_size,
true,
)
}
fn ppc_q3_memory_storage_new_buffer(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
) -> u32 {
let buffer_ptr = cpu.gpr[3];
let valid_size = cpu.gpr[4];
let buffer_size = cpu.gpr[5];
if buffer_ptr == 0 {
let allocated_size = buffer_size
.max(valid_size)
.max(PPC_Q3_MEMORY_STORAGE_DEFAULT_BUFFER_SIZE);
let Some(allocated_ptr) = ppc_q3_allocate_owned_storage_buffer(
process_memory_manager,
memory,
heap_cursor,
allocated_size,
last_mem_error,
) else {
return 0;
};
return ppc_q3_memory_storage_create(
q3_objects,
next_q3_object,
q3_memory_storages,
allocated_ptr,
0,
allocated_size,
true,
);
}
if valid_size > buffer_size {
return 0;
}
*last_mem_error = PPC_NO_ERR;
ppc_q3_memory_storage_create(
q3_objects,
next_q3_object,
q3_memory_storages,
buffer_ptr,
valid_size,
buffer_size,
false,
)
}
fn ppc_q3_fsspec_storage_new(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
heap_cursor: &mut u32,
last_mem_error: &mut i16,
) -> u32 {
let spec_ptr = cpu.gpr[3];
let Ok(path) = ppc_existing_path_for_fsspec(memory, vfs_directories, vfs_files, &[], spec_ptr)
else {
*last_mem_error = PPC_NO_ERR;
return 0;
};
let Some(file) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&path))
else {
*last_mem_error = PPC_NO_ERR;
return 0;
};
let Ok(data_size) = u32::try_from(file.data.len()) else {
*last_mem_error = PPC_MEM_FULL_ERR;
return 0;
};
let Some(buffer_ptr) = ppc_q3_allocate_owned_storage_buffer(
process_memory_manager,
memory,
heap_cursor,
data_size,
last_mem_error,
) else {
return 0;
};
if data_size != 0 && !ppc_q3_write_bytes(memory, buffer_ptr, &file.data) {
return 0;
}
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3FSSpecStorage_New path=\"{}\" data_size={}",
file.path,
file.data.len()
);
}
ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_STORAGE_TYPE_MACINTOSH,
buffer_ptr,
data_size,
)
}
fn ppc_q3_memory_storage_create(
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
buffer_ptr: u32,
valid_size: u32,
buffer_size: u32,
owns_buffer: bool,
) -> u32 {
let storage = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::MemoryStorage,
PPC_Q3_STORAGE_TYPE_MEMORY,
buffer_ptr,
valid_size,
);
if storage != 0 {
q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage,
buffer_ptr,
valid_size,
buffer_size,
owns_buffer,
});
}
storage
}
fn ppc_q3_memory_storage_set(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut [PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_files: &[PpcQ3FileRecord],
heap_cursor: &mut u32,
last_mem_error: &mut i16,
) -> bool {
let storage = cpu.gpr[3];
let source_ptr = cpu.gpr[4];
let requested_size = cpu.gpr[5];
if !ppc_q3_validate_memory_storage_handle(
q3_objects,
q3_error_state,
q3_memory_storages,
storage,
) {
return false;
}
if ppc_q3_storage_is_open(q3_files, storage) {
return false;
}
let buffer_size = if source_ptr == 0 {
requested_size.max(PPC_Q3_MEMORY_STORAGE_DEFAULT_BUFFER_SIZE)
} else {
requested_size
};
let valid_size = if source_ptr == 0 { 0 } else { requested_size };
let Some(buffer_ptr) = ppc_q3_allocate_owned_storage_buffer(
process_memory_manager,
memory,
heap_cursor,
buffer_size,
last_mem_error,
) else {
return false;
};
if source_ptr != 0
&& valid_size != 0
&& !ppc_q3_copy_or_zero(memory, source_ptr, buffer_ptr, valid_size)
{
return false;
}
ppc_q3_memory_storage_update(
q3_objects,
q3_memory_storages,
PpcQ3MemoryStorageRecord {
storage,
buffer_ptr,
valid_size,
buffer_size,
owns_buffer: true,
},
)
}
fn ppc_q3_memory_storage_get_buffer(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
) -> bool {
let storage = cpu.gpr[3];
let buffer_out_ptr = cpu.gpr[4];
let valid_size_out_ptr = cpu.gpr[5];
let buffer_size_out_ptr = cpu.gpr[6];
if buffer_out_ptr == 0
|| valid_size_out_ptr == 0
|| buffer_size_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, buffer_out_ptr, 4)
|| !ppc_memory_can_write_bytes(memory, valid_size_out_ptr, 4)
|| !ppc_memory_can_write_bytes(memory, buffer_size_out_ptr, 4)
{
return false;
}
if !ppc_q3_validate_memory_storage_handle(
q3_objects,
q3_error_state,
q3_memory_storages,
storage,
) {
return false;
}
let Some(record) = q3_memory_storages
.iter()
.find(|record| record.storage == storage)
else {
return false;
};
memory
.write_u32_be(buffer_out_ptr, record.buffer_ptr)
.is_some()
&& memory
.write_u32_be(valid_size_out_ptr, record.valid_size)
.is_some()
&& memory
.write_u32_be(buffer_size_out_ptr, record.buffer_size)
.is_some()
}
fn ppc_q3_memory_storage_set_buffer(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut [PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_files: &[PpcQ3FileRecord],
heap_cursor: &mut u32,
last_mem_error: &mut i16,
) -> bool {
let storage = cpu.gpr[3];
let buffer_ptr = cpu.gpr[4];
let valid_size = cpu.gpr[5];
let buffer_size = cpu.gpr[6];
if !ppc_q3_validate_memory_storage_handle(
q3_objects,
q3_error_state,
q3_memory_storages,
storage,
) {
return false;
}
if ppc_q3_storage_is_open(q3_files, storage) {
return false;
}
if buffer_ptr == 0 {
let allocated_size = buffer_size
.max(valid_size)
.max(PPC_Q3_MEMORY_STORAGE_DEFAULT_BUFFER_SIZE);
let Some(allocated_ptr) = ppc_q3_allocate_owned_storage_buffer(
process_memory_manager,
memory,
heap_cursor,
allocated_size,
last_mem_error,
) else {
return false;
};
return ppc_q3_memory_storage_update(
q3_objects,
q3_memory_storages,
PpcQ3MemoryStorageRecord {
storage,
buffer_ptr: allocated_ptr,
valid_size: 0,
buffer_size: allocated_size,
owns_buffer: true,
},
);
}
if valid_size > buffer_size {
return false;
}
*last_mem_error = PPC_NO_ERR;
ppc_q3_memory_storage_update(
q3_objects,
q3_memory_storages,
PpcQ3MemoryStorageRecord {
storage,
buffer_ptr,
valid_size,
buffer_size,
owns_buffer: false,
},
)
}
fn ppc_q3_memory_storage_get_type(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
) -> u32 {
if ppc_q3_validate_memory_storage_handle(
q3_objects,
q3_error_state,
q3_memory_storages,
cpu.gpr[3],
) {
PPC_Q3_MEMORY_STORAGE_TYPE_HANDLE
} else {
PPC_Q3_TYPE_NONE
}
}
fn ppc_q3_validate_memory_storage_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
storage: u32,
) -> bool {
let object_type = ppc_q3_object_type_for_handle(q3_objects, storage);
if matches!(
object_type,
PPC_Q3_STORAGE_TYPE_MEMORY | PPC_Q3_MEMORY_STORAGE_TYPE_HANDLE
) && ppc_q3_memory_storage_exists(q3_memory_storages, storage)
{
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_storage_get_type(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> u32 {
let storage = cpu.gpr[3];
let object_type = ppc_q3_object_type_for_handle(q3_objects, storage);
if ppc_q3_object_type_is_storage(object_type) {
object_type
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
PPC_Q3_TYPE_NONE
}
}
fn ppc_q3_validate_storage_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
storage: u32,
) -> bool {
if ppc_q3_object_type_is_storage(ppc_q3_object_type_for_handle(q3_objects, storage)) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_storage_get_size(
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
storage: u32,
size_out_ptr: u32,
) -> bool {
if size_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, size_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_storage_handle(q3_objects, q3_error_state, storage) {
return false;
}
let size = q3_memory_storages
.iter()
.find(|record| record.storage == storage)
.map(|record| record.valid_size)
.or_else(|| {
q3_objects
.iter()
.find(|record| record.object == storage)
.map(|record| record.data_size)
})
.unwrap_or(0);
memory.write_u32_be(size_out_ptr, size).is_some()
}
fn ppc_q3_storage_get_data(
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
storage: u32,
offset: u32,
requested_size: u32,
dest_ptr: u32,
size_read_ptr: u32,
) -> bool {
if size_read_ptr == 0 || !ppc_memory_can_write_bytes(memory, size_read_ptr, 4) {
return false;
}
let side_record = q3_memory_storages
.iter()
.find(|record| record.storage == storage);
let (source_ptr, available_size) = side_record
.map(|record| (record.buffer_ptr, record.valid_size))
.or_else(|| {
q3_objects
.iter()
.find(|record| record.object == storage)
.map(|record| (record.data_ptr, record.data_size))
})
.unwrap_or((0, 0));
let readable_size = available_size.saturating_sub(offset).min(requested_size);
if readable_size != 0 && !ppc_memory_can_write_bytes(memory, dest_ptr, readable_size) {
return false;
}
if !ppc_q3_validate_storage_handle(q3_objects, q3_error_state, storage) {
return false;
}
let slice_source_ptr = if readable_size == 0 {
0
} else {
let Some(slice_source_ptr) = source_ptr.checked_add(offset) else {
return false;
};
slice_source_ptr
};
if memory.write_u32_be(size_read_ptr, readable_size).is_none() {
return false;
}
readable_size == 0 || ppc_q3_copy_or_zero(memory, slice_source_ptr, dest_ptr, readable_size)
}
fn ppc_q3_storage_set_data(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut [PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
storage: u32,
offset: u32,
requested_size: u32,
source_ptr: u32,
size_written_ptr: u32,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
) -> bool {
if size_written_ptr == 0 || !ppc_memory_can_write_bytes(memory, size_written_ptr, 4) {
return false;
}
if !ppc_q3_validate_storage_handle(q3_objects, q3_error_state, storage) {
return false;
}
if memory
.write_u32_be(size_written_ptr, requested_size)
.is_none()
{
return false;
}
if let Some(side_index) = q3_memory_storages
.iter()
.position(|record| record.storage == storage)
{
let Some(end_offset) = offset.checked_add(requested_size) else {
return false;
};
if end_offset > q3_memory_storages[side_index].buffer_size
&& !ppc_q3_memory_storage_grow_for_write(
process_memory_manager,
memory,
q3_objects,
q3_memory_storages,
side_index,
end_offset,
heap_cursor,
last_mem_error,
)
{
return false;
}
let Some(dest_ptr) = q3_memory_storages[side_index]
.buffer_ptr
.checked_add(offset)
else {
return false;
};
for byte_offset in 0..requested_size {
let byte = if source_ptr == 0 {
0
} else {
memory.read_u8(source_ptr + byte_offset).unwrap_or(0)
};
if memory.write_u8(dest_ptr + byte_offset, byte).is_none() {
return false;
}
}
q3_memory_storages[side_index].valid_size =
q3_memory_storages[side_index].valid_size.max(end_offset);
ppc_q3_sync_memory_storage_object(q3_objects, q3_memory_storages[side_index]);
return true;
}
let Some(record) = q3_objects
.iter_mut()
.find(|record| record.object == storage)
else {
return false;
};
let Some(dest_ptr) = record.data_ptr.checked_add(offset) else {
return false;
};
for byte_offset in 0..requested_size {
let byte = if source_ptr == 0 {
0
} else {
memory.read_u8(source_ptr + byte_offset).unwrap_or(0)
};
if memory.write_u8(dest_ptr + byte_offset, byte).is_none() {
return false;
}
}
record.data_size = record.data_size.max(offset.saturating_add(requested_size));
true
}
fn ppc_q3_allocate_owned_storage_buffer(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
buffer_size: u32,
last_mem_error: &mut i16,
) -> Option<u32> {
if buffer_size == 0 {
*last_mem_error = PPC_NO_ERR;
return Some(0);
}
let ptr = ppc_process_heap_alloc(
process_memory_manager,
memory,
heap_cursor,
buffer_size,
true,
);
if ptr == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
None
} else {
*last_mem_error = PPC_NO_ERR;
Some(ptr)
}
}
fn ppc_q3_memory_storage_update(
q3_objects: &mut [PpcQ3ObjectRecord],
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
new_record: PpcQ3MemoryStorageRecord,
) -> bool {
let Some(index) = q3_memory_storages
.iter()
.position(|record| record.storage == new_record.storage)
else {
return false;
};
q3_memory_storages[index] = new_record;
ppc_q3_sync_memory_storage_object(q3_objects, new_record)
}
fn ppc_q3_sync_memory_storage_object(
q3_objects: &mut [PpcQ3ObjectRecord],
storage_record: PpcQ3MemoryStorageRecord,
) -> bool {
let Some(object_record) = q3_objects
.iter_mut()
.find(|record| record.object == storage_record.storage)
else {
return false;
};
object_record.kind = PpcQ3ObjectKind::MemoryStorage;
object_record.object_type = PPC_Q3_STORAGE_TYPE_MEMORY;
object_record.data_ptr = storage_record.buffer_ptr;
object_record.data_size = storage_record.valid_size;
true
}
fn ppc_q3_memory_storage_exists(
q3_memory_storages: &[PpcQ3MemoryStorageRecord],
storage: u32,
) -> bool {
storage != 0
&& q3_memory_storages
.iter()
.any(|record| record.storage == storage)
}
fn ppc_q3_storage_is_open(q3_files: &[PpcQ3FileRecord], storage: u32) -> bool {
storage != 0
&& q3_files
.iter()
.any(|record| record.storage == storage && record.is_open)
}
fn ppc_q3_memory_storage_grow_for_write(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut [PpcQ3ObjectRecord],
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
side_index: usize,
required_size: u32,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
) -> bool {
let old_record = q3_memory_storages[side_index];
let grown_size = required_size
.max(old_record.buffer_size.saturating_mul(2))
.max(PPC_Q3_MEMORY_STORAGE_DEFAULT_BUFFER_SIZE);
let Some(new_ptr) = ppc_q3_allocate_owned_storage_buffer(
process_memory_manager,
memory,
heap_cursor,
grown_size,
last_mem_error,
) else {
return false;
};
if old_record.valid_size != 0
&& !ppc_q3_copy_or_zero(
memory,
old_record.buffer_ptr,
new_ptr,
old_record.valid_size,
)
{
return false;
}
q3_memory_storages[side_index].buffer_ptr = new_ptr;
q3_memory_storages[side_index].buffer_size = grown_size;
q3_memory_storages[side_index].owns_buffer = true;
ppc_q3_sync_memory_storage_object(q3_objects, q3_memory_storages[side_index])
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PpcQ3ViewSlot {
Renderer,
LightGroup,
DrawContext,
Camera,
}
fn ppc_q3_file_mut(q3_files: &mut Vec<PpcQ3FileRecord>, file: u32) -> Option<&mut PpcQ3FileRecord> {
if file == 0 {
return None;
}
if let Some(index) = q3_files.iter().position(|record| record.file == file) {
return q3_files.get_mut(index);
}
q3_files.push(PpcQ3FileRecord {
file,
storage: 0,
is_open: false,
object_type: 0,
read_offset: 0,
read_object: 0,
});
q3_files.last_mut()
}
fn ppc_q3_validate_file_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
file: u32,
) -> bool {
if q3_objects
.iter()
.any(|record| record.object == file && record.object_type == PPC_Q3_TYPE_FILE)
{
return true;
}
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
fn ppc_q3_file_set_storage(
cpu: &PpcCpu,
q3_files: &mut Vec<PpcQ3FileRecord>,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_error_state: &mut PpcQ3ErrorState,
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &mut Vec<PpcQ3FileGroupRecord>,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_view_state_stack: &mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_completed_frames: &mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
q3_fog_styles: &mut Vec<PpcQ3FogStyleRecord>,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_shader_uv_transforms: &mut Vec<PpcQ3ShaderUvTransformRecord>,
q3_shader_boundaries: &mut Vec<PpcQ3ShaderBoundaryRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
q3_draw_contexts: &mut Vec<PpcQ3DrawContextRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
q3_lights: &mut Vec<PpcQ3LightRecord>,
) -> bool {
let file = cpu.gpr[3];
let storage = cpu.gpr[4];
if !ppc_q3_validate_file_handle(q3_objects, q3_error_state, file)
|| !ppc_q3_validate_storage_handle(q3_objects, q3_error_state, storage)
{
return false;
}
let old_storage = q3_files
.iter()
.find(|record| record.file == file)
.map(|record| record.storage)
.unwrap_or(0);
if old_storage == storage {
return true;
}
let retained = ppc_q3_object_retain(q3_objects, q3_object_refs, storage);
let Some(record) = ppc_q3_file_mut(q3_files, file) else {
if retained {
let mut stores = PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
};
let _ = ppc_q3_object_release_reference(&mut stores, storage);
}
return false;
};
record.storage = storage;
if old_storage != 0 {
let mut stores = PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
};
let _ = ppc_q3_object_release_reference(&mut stores, old_storage);
}
retained
}
fn ppc_q3_file_open_read(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_files: &mut Vec<PpcQ3FileRecord>,
) -> bool {
let file = cpu.gpr[3];
let object_type_out_ptr = cpu.gpr[4];
if object_type_out_ptr != 0 && !ppc_memory_can_write_bytes(memory, object_type_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_file_handle(q3_objects, q3_error_state, file) {
return false;
}
let Some(record) = ppc_q3_file_mut(q3_files, file) else {
return false;
};
record.is_open = true;
record.object_type = 0;
record.read_offset = 0;
record.read_object = 0;
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3File_OpenRead file=${:08X} storage=${:08X}",
record.file, record.storage
);
}
object_type_out_ptr == 0
|| memory
.write_u32_be(object_type_out_ptr, record.object_type)
.is_some()
}
fn ppc_q3_file_read_object(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
q3_error_state: &mut PpcQ3ErrorState,
q3_files: &mut [PpcQ3FileRecord],
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &mut Vec<PpcQ3FileGroupRecord>,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
) -> u32 {
let file = cpu.gpr[3];
if !ppc_q3_validate_file_handle(q3_objects, q3_error_state, file) {
return 0;
}
let Some(file_index) = q3_files.iter().position(|record| record.file == file) else {
return 0;
};
let file_record = q3_files[file_index];
if !file_record.is_open || file_record.storage == 0 {
return 0;
}
if !ppc_q3_validate_storage_handle(q3_objects, q3_error_state, file_record.storage) {
return 0;
}
let Some(storage_record) = q3_objects
.iter()
.find(|record| record.object == file_record.storage)
.copied()
else {
return 0;
};
let Some(chunk) =
ppc_q3_file_next_object_chunk(memory, storage_record, file_record.read_offset)
else {
q3_files[file_index].read_offset = storage_record.data_size;
return 0;
};
let Some(data_ptr) = storage_record.data_ptr.checked_add(chunk.offset) else {
q3_files[file_index].read_offset = storage_record.data_size;
return 0;
};
let object = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
chunk.object_type,
data_ptr,
chunk.total_size,
);
if object != 0 {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3File_ReadObject file=${:08X} object=${:08X} type='{}' offset={} body_size={} total_size={} parent='{}' depth={}",
file,
object,
ppc_res_type_text(chunk.object_type),
chunk.offset,
chunk.body_size,
chunk.total_size,
ppc_res_type_text(chunk.parent_group_type),
chunk.group_depth
);
}
if let Some(record) = q3_objects.iter_mut().find(|record| record.object == object) {
record.source = PpcQ3ObjectSource {
file,
offset: chunk.offset,
parent_group_type: chunk.parent_group_type,
group_depth: chunk.group_depth,
};
}
let parent_group = ppc_q3_file_ensure_group_stack(
q3_objects,
next_q3_object,
q3_group_memberships,
q3_file_groups,
file,
storage_record,
&chunk.group_stack,
);
if let Some(parent_group) = parent_group {
ppc_q3_group_add_membership_once(q3_group_memberships, parent_group, object);
}
ppc_q3_file_record_object_body(
process_memory_manager,
memory,
q3_objects,
next_q3_object,
object,
chunk.object_type,
data_ptr,
chunk.body_size,
heap_cursor,
heap_limit,
last_mem_error,
q3_memory_storages,
q3_trimeshes,
q3_mipmap_textures,
q3_styles,
);
if chunk.object_type == PPC_Q3_TYPE_CONTAINER {
let container_state = ppc_q3_file_record_container_children(
process_memory_manager,
memory,
q3_objects,
next_q3_object,
q3_memory_storages,
q3_group_memberships,
q3_attributes,
q3_trimeshes,
q3_mipmap_textures,
q3_texture_shaders,
q3_styles,
heap_cursor,
heap_limit,
last_mem_error,
file,
storage_record,
object,
chunk.object_type,
chunk.offset,
chunk.body_size,
chunk.group_depth,
);
if chunk.parent_group_type == PPC_Q3_TYPE_NONE && chunk.group_depth == 0 {
if let Some(root_child) = container_state.root_child {
ppc_q3_file_promote_container_root_object(
q3_objects,
q3_attributes,
q3_trimeshes,
q3_mipmap_textures,
q3_texture_shaders,
q3_styles,
object,
root_child,
);
}
}
if let Some(parent_group) = parent_group {
ppc_q3_file_mirror_container_geometry_into_group(
q3_group_memberships,
q3_objects,
parent_group,
object,
);
}
}
q3_files[file_index].read_offset = chunk.next_offset;
q3_files[file_index].read_object = object;
}
object
}
fn ppc_q3_file_record_object_body(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
object: u32,
object_type: u32,
data_ptr: u32,
body_size: u32,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
) {
let Some(body_ptr) = data_ptr.checked_add(8) else {
return;
};
if object_type == PPC_Q3_TYPE_TRIMESH {
if let Some(data) = ppc_q3_file_decode_trimesh_3dmf_body(
process_memory_manager,
memory,
body_ptr,
body_size,
heap_cursor,
heap_limit,
last_mem_error,
)
.or_else(|| {
(body_size >= PPC_Q3_TRIMESH_DATA_SIZE)
.then(|| ppc_q3_read_bytes(memory, body_ptr, PPC_Q3_TRIMESH_DATA_SIZE))
.flatten()
}) {
if ppc_hle_trace_enabled() {
let point_count =
ppc_q3_trimesh_header_u32(&data, PPC_Q3_TRIMESH_NUM_POINTS_OFFSET).unwrap_or(0);
let triangle_count =
ppc_q3_trimesh_header_u32(&data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)
.unwrap_or(0);
eprintln!(
"[PPC-TRACE] Q3File body TriMesh object=${:08X} points={} triangles={} data_ptr=${:08X}",
object, point_count, triangle_count, body_ptr
);
}
ppc_q3_trimesh_store_data(q3_trimeshes, object, data, Vec::new());
}
} else if object_type == PPC_Q3_TEXTURE_TYPE_MIPMAP && body_size > 0 {
if let Some(data) = ppc_q3_file_decode_mipmap_3dmf_body(
process_memory_manager,
memory,
q3_objects,
next_q3_object,
q3_memory_storages,
body_ptr,
body_size,
heap_cursor,
last_mem_error,
)
.or_else(|| ppc_q3_read_bytes(memory, body_ptr, body_size))
{
ppc_q3_mipmap_texture_store_data(q3_mipmap_textures, object, data);
}
} else if let Some(kind) = ppc_q3_style_kind_for_type(object_type) {
if body_size >= 4 {
if let Some(value) = memory.read_u32_be(body_ptr) {
ppc_q3_style_store_data(q3_styles, object, kind, value);
}
}
}
}
fn ppc_q3_file_decode_mipmap_3dmf_body(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
body_ptr: u32,
body_size: u32,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
) -> Option<Vec<u8>> {
const HEADER_SIZE: u32 = 32;
if body_size < HEADER_SIZE {
return None;
}
let use_mipmapping = memory.read_u32_be(body_ptr)?;
let pixel_type = memory.read_u32_be(body_ptr.checked_add(4)?)?;
let bit_order = memory.read_u32_be(body_ptr.checked_add(8)?)?;
let byte_order = memory.read_u32_be(body_ptr.checked_add(12)?)?;
let width = memory.read_u32_be(body_ptr.checked_add(16)?)?;
let height = memory.read_u32_be(body_ptr.checked_add(20)?)?;
let row_bytes = memory.read_u32_be(body_ptr.checked_add(24)?)?;
let image_offset = memory.read_u32_be(body_ptr.checked_add(28)?)?;
if use_mipmapping != 0
|| width == 0
|| height == 0
|| row_bytes == 0
|| ppc_q3_software_texture_pixel_bytes(pixel_type).is_none()
{
return None;
}
let image_size = height.checked_mul(row_bytes)?;
if HEADER_SIZE.checked_add(image_size)? > body_size {
return None;
}
let image = ppc_q3_read_bytes(memory, body_ptr.checked_add(HEADER_SIZE)?, image_size)?;
let image_ptr =
ppc_q3_file_alloc_and_write_bytes(process_memory_manager, memory, heap_cursor, &image)?;
let image_storage = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::MemoryStorage,
PPC_Q3_STORAGE_TYPE_MEMORY,
image_ptr,
image_size,
);
if image_storage == 0 {
return None;
}
q3_memory_storages.push(PpcQ3MemoryStorageRecord {
storage: image_storage,
buffer_ptr: image_ptr,
valid_size: image_size,
buffer_size: image_size,
owns_buffer: true,
});
let mut mipmap = vec![0; PPC_Q3_MIPMAP_COPY_SIZE as usize];
ppc_q3_write_u32_to_slice(&mut mipmap, PPC_Q3_MIPMAP_IMAGE_OFFSET, image_storage)?;
ppc_q3_write_u32_to_slice(
&mut mipmap,
PPC_Q3_MIPMAP_USE_MIPMAPPING_OFFSET,
use_mipmapping,
)?;
ppc_q3_write_u32_to_slice(&mut mipmap, PPC_Q3_MIPMAP_PIXEL_TYPE_OFFSET, pixel_type)?;
ppc_q3_write_u32_to_slice(&mut mipmap, PPC_Q3_MIPMAP_BIT_ORDER_OFFSET, bit_order)?;
ppc_q3_write_u32_to_slice(&mut mipmap, PPC_Q3_MIPMAP_BYTE_ORDER_OFFSET, byte_order)?;
ppc_q3_write_u32_to_slice(&mut mipmap, PPC_Q3_MIPMAP_RESERVED_OFFSET, 0)?;
ppc_q3_write_u32_to_slice(&mut mipmap, PPC_Q3_MIPMAP_BASE_WIDTH_OFFSET, width)?;
ppc_q3_write_u32_to_slice(&mut mipmap, PPC_Q3_MIPMAP_BASE_HEIGHT_OFFSET, height)?;
ppc_q3_write_u32_to_slice(&mut mipmap, PPC_Q3_MIPMAP_BASE_ROW_BYTES_OFFSET, row_bytes)?;
ppc_q3_write_u32_to_slice(
&mut mipmap,
PPC_Q3_MIPMAP_BASE_IMAGE_OFFSET_OFFSET,
image_offset,
)?;
*last_mem_error = PPC_NO_ERR;
Some(mipmap)
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct PpcQ3Decoded3dmfTriMeshAttribute {
which_array: u32,
which_attr: u32,
attribute_type: u32,
data: Vec<u8>,
use_array: Vec<u8>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct PpcQ3Decoded3dmfTriMesh {
num_triangles: u32,
num_triangle_attribute_types: u32,
num_edges: u32,
num_edge_attribute_types: u32,
num_points: u32,
num_vertex_attribute_types: u32,
triangles: Vec<u8>,
edges: Vec<u8>,
points: Vec<u8>,
bbox: Vec<u8>,
attributes: Vec<PpcQ3Decoded3dmfTriMeshAttribute>,
}
fn ppc_q3_file_decode_trimesh_3dmf_body(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
body_ptr: u32,
body_size: u32,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
) -> Option<Vec<u8>> {
let decoded = ppc_q3_file_parse_trimesh_3dmf_body(memory, body_ptr, body_size)?;
let triangle_size = u32::try_from(decoded.triangles.len()).ok()?;
let edge_size = u32::try_from(decoded.edges.len()).ok()?;
let point_size = u32::try_from(decoded.points.len()).ok()?;
let triangle_attribute_types_size = decoded
.num_triangle_attribute_types
.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?;
let edge_attribute_types_size = decoded
.num_edge_attribute_types
.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?;
let vertex_attribute_types_size = decoded
.num_vertex_attribute_types
.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?;
let mut allocation_sizes = vec![triangle_size, point_size];
if edge_size != 0 {
allocation_sizes.push(edge_size);
}
if triangle_attribute_types_size != 0 {
allocation_sizes.push(triangle_attribute_types_size);
}
if edge_attribute_types_size != 0 {
allocation_sizes.push(edge_attribute_types_size);
}
if vertex_attribute_types_size != 0 {
allocation_sizes.push(vertex_attribute_types_size);
}
for attribute in &decoded.attributes {
allocation_sizes.push(u32::try_from(attribute.data.len()).ok()?);
if !attribute.use_array.is_empty() {
allocation_sizes.push(u32::try_from(attribute.use_array.len()).ok()?);
}
}
if !ppc_heap_can_alloc_sequence(memory, *heap_cursor, heap_limit, &allocation_sizes) {
*last_mem_error = PPC_MEM_FULL_ERR;
return None;
}
let triangles_ptr = ppc_q3_file_alloc_and_write_bytes(
process_memory_manager,
memory,
heap_cursor,
&decoded.triangles,
)?;
let points_ptr = ppc_q3_file_alloc_and_write_bytes(
process_memory_manager,
memory,
heap_cursor,
&decoded.points,
)?;
let edges_ptr = if decoded.edges.is_empty() {
0
} else {
ppc_q3_file_alloc_and_write_bytes(
process_memory_manager,
memory,
heap_cursor,
&decoded.edges,
)?
};
let triangle_attribute_types_ptr = ppc_q3_file_alloc_and_write_zeroes(
process_memory_manager,
memory,
heap_cursor,
triangle_attribute_types_size,
)?;
let edge_attribute_types_ptr = ppc_q3_file_alloc_and_write_zeroes(
process_memory_manager,
memory,
heap_cursor,
edge_attribute_types_size,
)?;
let vertex_attribute_types_ptr = ppc_q3_file_alloc_and_write_zeroes(
process_memory_manager,
memory,
heap_cursor,
vertex_attribute_types_size,
)?;
for attribute in &decoded.attributes {
let data_ptr = ppc_q3_file_alloc_and_write_bytes(
process_memory_manager,
memory,
heap_cursor,
&attribute.data,
)?;
let use_array_ptr = if attribute.use_array.is_empty() {
0
} else {
ppc_q3_file_alloc_and_write_bytes(
process_memory_manager,
memory,
heap_cursor,
&attribute.use_array,
)?
};
let attribute_types_ptr = match attribute.which_array {
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_TRIANGLE => triangle_attribute_types_ptr,
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_EDGE => edge_attribute_types_ptr,
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_VERTEX => vertex_attribute_types_ptr,
_ => 0,
};
ppc_q3_file_write_trimesh_attribute_record(
memory,
attribute_types_ptr,
attribute.which_attr,
attribute.attribute_type,
data_ptr,
use_array_ptr,
)?;
}
let mut data = vec![0; PPC_Q3_TRIMESH_DATA_SIZE as usize];
ppc_q3_trimesh_header_put_u32(
&mut data,
PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET,
decoded.num_triangles,
)?;
ppc_q3_trimesh_header_put_u32(&mut data, PPC_Q3_TRIMESH_TRIANGLES_OFFSET, triangles_ptr)?;
ppc_q3_trimesh_header_put_u32(
&mut data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
decoded.num_triangle_attribute_types,
)?;
ppc_q3_trimesh_header_put_u32(
&mut data,
PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
triangle_attribute_types_ptr,
)?;
ppc_q3_trimesh_header_put_u32(
&mut data,
PPC_Q3_TRIMESH_NUM_EDGES_OFFSET,
decoded.num_edges,
)?;
ppc_q3_trimesh_header_put_u32(&mut data, PPC_Q3_TRIMESH_EDGES_OFFSET, edges_ptr)?;
ppc_q3_trimesh_header_put_u32(
&mut data,
PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET,
decoded.num_edge_attribute_types,
)?;
ppc_q3_trimesh_header_put_u32(
&mut data,
PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET,
edge_attribute_types_ptr,
)?;
ppc_q3_trimesh_header_put_u32(
&mut data,
PPC_Q3_TRIMESH_NUM_POINTS_OFFSET,
decoded.num_points,
)?;
ppc_q3_trimesh_header_put_u32(&mut data, PPC_Q3_TRIMESH_POINTS_OFFSET, points_ptr)?;
ppc_q3_trimesh_header_put_u32(
&mut data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
decoded.num_vertex_attribute_types,
)?;
ppc_q3_trimesh_header_put_u32(
&mut data,
PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET,
vertex_attribute_types_ptr,
)?;
if !decoded.bbox.is_empty() {
let bbox_offset = (PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET + 4) as usize;
let bbox_copy_size = data
.len()
.saturating_sub(bbox_offset)
.min(decoded.bbox.len());
if bbox_copy_size != 0 {
data[bbox_offset..bbox_offset + bbox_copy_size]
.copy_from_slice(&decoded.bbox[..bbox_copy_size]);
}
}
*last_mem_error = PPC_NO_ERR;
Some(data)
}
fn ppc_q3_file_parse_trimesh_3dmf_body(
memory: &mut PpcSectionMem,
body_ptr: u32,
body_size: u32,
) -> Option<PpcQ3Decoded3dmfTriMesh> {
if body_size < 24 {
return None;
}
let body_end = body_ptr.checked_add(body_size)?;
let num_triangles = memory.read_u32_be(body_ptr)?;
let num_triangle_attribute_types = memory.read_u32_be(body_ptr.checked_add(4)?)?;
let num_edges = memory.read_u32_be(body_ptr.checked_add(8)?)?;
let num_edge_attribute_types = memory.read_u32_be(body_ptr.checked_add(12)?)?;
let num_points = memory.read_u32_be(body_ptr.checked_add(16)?)?;
let num_vertex_attribute_types = memory.read_u32_be(body_ptr.checked_add(20)?)?;
if num_triangles == 0
|| num_points == 0
|| num_triangles > body_size / 3
|| num_edges > body_size / 4
|| num_points > body_size / PPC_Q3_POINT3D_SIZE
|| num_triangle_attribute_types > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| num_edge_attribute_types > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
|| num_vertex_attribute_types > PPC_Q3_SOFTWARE_RENDER_MAX_ATTRIBUTE_TYPES
{
return None;
}
let point_index_size = ppc_q3_3dmf_index_size(num_points);
let triangle_index_size = ppc_q3_3dmf_index_size(num_triangles);
let mut cursor = body_ptr.checked_add(24)?;
let triangle_output_size = num_triangles.checked_mul(PPC_Q3_TRIMESH_TRIANGLE_DATA_SIZE)?;
let mut triangles = Vec::with_capacity(usize::try_from(triangle_output_size).ok()?);
for _ in 0..num_triangles {
for _ in 0..3 {
let index = ppc_q3_read_3dmf_index(memory, &mut cursor, body_end, point_index_size)?;
if index >= num_points {
return None;
}
triangles.extend_from_slice(&index.to_be_bytes());
}
}
let edge_output_size = num_edges.checked_mul(PPC_Q3_TRIMESH_EDGE_DATA_SIZE)?;
let mut edges = Vec::with_capacity(usize::try_from(edge_output_size).ok()?);
for _ in 0..num_edges {
let point_a = ppc_q3_read_3dmf_index(memory, &mut cursor, body_end, point_index_size)?;
let point_b = ppc_q3_read_3dmf_index(memory, &mut cursor, body_end, point_index_size)?;
if point_a >= num_points || point_b >= num_points {
return None;
}
let _triangle_a =
ppc_q3_read_3dmf_index(memory, &mut cursor, body_end, triangle_index_size)?;
let _triangle_b =
ppc_q3_read_3dmf_index(memory, &mut cursor, body_end, triangle_index_size)?;
edges.extend_from_slice(&point_a.to_be_bytes());
edges.extend_from_slice(&point_b.to_be_bytes());
}
let point_data_size = num_points.checked_mul(PPC_Q3_POINT3D_SIZE)?;
let points = ppc_q3_read_3dmf_bytes(memory, &mut cursor, body_end, point_data_size)?;
let bbox = ppc_q3_read_3dmf_bytes(memory, &mut cursor, body_end, PPC_Q3_BOUNDING_BOX_SIZE)?;
let mut attributes = Vec::new();
while cursor < body_end {
let child_type = memory.read_u32_be(cursor)?;
let child_body_size = memory.read_u32_be(cursor.checked_add(4)?)?;
let child_body_start = cursor.checked_add(8)?;
let child_end = child_body_start.checked_add(child_body_size)?;
if child_end > body_end {
return None;
}
if child_type == PPC_Q3_TYPE_ATTRIBUTE_ARRAY {
if let Some(attribute) = ppc_q3_file_parse_trimesh_attribute_array(
memory,
child_body_start,
child_body_size,
num_triangles,
num_triangle_attribute_types,
num_edges,
num_edge_attribute_types,
num_points,
num_vertex_attribute_types,
) {
attributes.push(attribute);
}
}
cursor = child_end;
}
Some(PpcQ3Decoded3dmfTriMesh {
num_triangles,
num_triangle_attribute_types,
num_edges,
num_edge_attribute_types,
num_points,
num_vertex_attribute_types,
triangles,
edges,
points,
bbox,
attributes,
})
}
fn ppc_q3_file_parse_trimesh_attribute_array(
memory: &mut PpcSectionMem,
body_ptr: u32,
body_size: u32,
num_triangles: u32,
num_triangle_attribute_types: u32,
num_edges: u32,
num_edge_attribute_types: u32,
num_points: u32,
num_vertex_attribute_types: u32,
) -> Option<PpcQ3Decoded3dmfTriMeshAttribute> {
if body_size < 20 {
return None;
}
let body_end = body_ptr.checked_add(body_size)?;
let attribute_type = memory.read_u32_be(body_ptr)?;
let which_array = memory.read_u32_be(body_ptr.checked_add(8)?)?;
let which_attr = memory.read_u32_be(body_ptr.checked_add(12)?)?;
let use_array_flag = memory.read_u32_be(body_ptr.checked_add(16)?)?;
let (num_elems, num_attributes) = match which_array {
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_TRIANGLE => (num_triangles, num_triangle_attribute_types),
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_EDGE => (num_edges, num_edge_attribute_types),
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_VERTEX => (num_points, num_vertex_attribute_types),
_ => return None,
};
if which_attr >= num_attributes {
return None;
}
let attribute_data_size = ppc_q3_attribute_data_size(attribute_type)?;
let mut cursor = body_ptr.checked_add(20)?;
let use_array = if use_array_flag == 0 {
Vec::new()
} else {
ppc_q3_read_3dmf_bytes(memory, &mut cursor, body_end, num_elems)?
};
let attribute_byte_count = num_elems.checked_mul(attribute_data_size)?;
let data = ppc_q3_read_3dmf_bytes(memory, &mut cursor, body_end, attribute_byte_count)?;
Some(PpcQ3Decoded3dmfTriMeshAttribute {
which_array,
which_attr,
attribute_type,
data,
use_array,
})
}
fn ppc_q3_file_alloc_and_write_bytes(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
data: &[u8],
) -> Option<u32> {
if data.is_empty() {
return Some(0);
}
let size = u32::try_from(data.len()).ok()?;
let ptr = ppc_process_heap_alloc(process_memory_manager, memory, heap_cursor, size, true);
if ptr == 0 || !ppc_q3_write_bytes(memory, ptr, data) {
return None;
}
Some(ptr)
}
fn ppc_q3_file_alloc_and_write_zeroes(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
size: u32,
) -> Option<u32> {
if size == 0 {
return Some(0);
}
let data = vec![0; usize::try_from(size).ok()?];
ppc_q3_file_alloc_and_write_bytes(process_memory_manager, memory, heap_cursor, &data)
}
fn ppc_q3_file_write_trimesh_attribute_record(
memory: &mut PpcSectionMem,
attribute_types_ptr: u32,
which_attr: u32,
attribute_type: u32,
data_ptr: u32,
use_array_ptr: u32,
) -> Option<()> {
if attribute_types_ptr == 0 {
return None;
}
let record_ptr = attribute_types_ptr
.checked_add(which_attr.checked_mul(PPC_Q3_TRIMESH_ATTRIBUTE_DATA_SIZE)?)?;
memory.write_u32_be(record_ptr, attribute_type)?;
memory.write_u32_be(record_ptr.checked_add(4)?, data_ptr)?;
memory.write_u32_be(record_ptr.checked_add(8)?, use_array_ptr)?;
Some(())
}
fn ppc_q3_file_attach_trimesh_attribute_array(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
target_trimesh: u32,
body_ptr: u32,
body_size: u32,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
q3_trimeshes: &[PpcQ3TriMeshRecord],
) -> bool {
let Some(record) = q3_trimeshes
.iter()
.find(|record| record.trimesh == target_trimesh)
else {
return false;
};
let Some(num_triangles) =
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)
else {
return false;
};
let Some(num_triangle_attribute_types) = ppc_q3_trimesh_header_u32(
&record.data,
PPC_Q3_TRIMESH_NUM_TRIANGLE_ATTRIBUTE_TYPES_OFFSET,
) else {
return false;
};
let Some(num_edges) = ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_NUM_EDGES_OFFSET)
else {
return false;
};
let Some(num_edge_attribute_types) =
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_NUM_EDGE_ATTRIBUTE_TYPES_OFFSET)
else {
return false;
};
let Some(num_points) =
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_NUM_POINTS_OFFSET)
else {
return false;
};
let Some(num_vertex_attribute_types) = ppc_q3_trimesh_header_u32(
&record.data,
PPC_Q3_TRIMESH_NUM_VERTEX_ATTRIBUTE_TYPES_OFFSET,
) else {
return false;
};
let Some(attribute) = ppc_q3_file_parse_trimesh_attribute_array(
memory,
body_ptr,
body_size,
num_triangles,
num_triangle_attribute_types,
num_edges,
num_edge_attribute_types,
num_points,
num_vertex_attribute_types,
) else {
return false;
};
let attribute_types_ptr = match attribute.which_array {
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_TRIANGLE => {
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_TRIANGLE_ATTRIBUTE_TYPES_OFFSET)
}
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_EDGE => {
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_EDGE_ATTRIBUTE_TYPES_OFFSET)
}
PPC_Q3_TRIMESH_ATTRIBUTE_ARRAY_VERTEX => {
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_VERTEX_ATTRIBUTE_TYPES_OFFSET)
}
_ => None,
}
.unwrap_or(0);
if attribute_types_ptr == 0 {
return false;
}
let mut allocation_sizes = vec![u32::try_from(attribute.data.len()).unwrap_or(u32::MAX)];
if !attribute.use_array.is_empty() {
allocation_sizes.push(u32::try_from(attribute.use_array.len()).unwrap_or(u32::MAX));
}
if !ppc_heap_can_alloc_sequence(memory, *heap_cursor, heap_limit, &allocation_sizes) {
*last_mem_error = PPC_MEM_FULL_ERR;
return false;
}
let Some(data_ptr) = ppc_q3_file_alloc_and_write_bytes(
process_memory_manager,
memory,
heap_cursor,
&attribute.data,
) else {
return false;
};
let use_array_ptr = if attribute.use_array.is_empty() {
0
} else {
let Some(ptr) = ppc_q3_file_alloc_and_write_bytes(
process_memory_manager,
memory,
heap_cursor,
&attribute.use_array,
) else {
return false;
};
ptr
};
if ppc_q3_file_write_trimesh_attribute_record(
memory,
attribute_types_ptr,
attribute.which_attr,
attribute.attribute_type,
data_ptr,
use_array_ptr,
)
.is_none()
{
return false;
}
*last_mem_error = PPC_NO_ERR;
true
}
fn ppc_q3_3dmf_index_size(count: u32) -> u32 {
if count <= 0xFF {
1
} else if count <= 0xFFFF {
2
} else {
4
}
}
fn ppc_q3_read_3dmf_index(
memory: &mut PpcSectionMem,
cursor: &mut u32,
body_end: u32,
byte_count: u32,
) -> Option<u32> {
let start = *cursor;
let next = start.checked_add(byte_count)?;
if next > body_end {
return None;
}
let value = match byte_count {
1 => u32::from(memory.read_u8(start)?),
2 => u32::from(memory.read_u16_be(start)?),
4 => memory.read_u32_be(start)?,
_ => return None,
};
*cursor = next;
Some(value)
}
fn ppc_q3_read_3dmf_bytes(
memory: &mut PpcSectionMem,
cursor: &mut u32,
body_end: u32,
byte_count: u32,
) -> Option<Vec<u8>> {
let start = *cursor;
let next = start.checked_add(byte_count)?;
if next > body_end {
return None;
}
let bytes = ppc_q3_read_bytes(memory, start, byte_count)?;
*cursor = next;
Some(bytes)
}
fn ppc_q3_trimesh_header_put_u32(data: &mut [u8], offset: u32, value: u32) -> Option<()> {
let offset = usize::try_from(offset).ok()?;
data.get_mut(offset..offset.checked_add(4)?)?
.copy_from_slice(&value.to_be_bytes());
Some(())
}
fn ppc_q3_file_attribute_type_for_chunk(object_type: u32) -> Option<u32> {
match object_type {
PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT_3DMF => {
Some(PPC_Q3_ATTRIBUTE_TYPE_AMBIENT_COEFFICIENT)
}
PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR_3DMF => Some(PPC_Q3_ATTRIBUTE_TYPE_DIFFUSE_COLOR),
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR_3DMF => Some(PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_COLOR),
PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL_3DMF => Some(PPC_Q3_ATTRIBUTE_TYPE_SPECULAR_CONTROL),
PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR_3DMF => {
Some(PPC_Q3_ATTRIBUTE_TYPE_TRANSPARENCY_COLOR)
}
_ => None,
}
}
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
struct PpcQ3ParsedContainerState {
root_child: Option<u32>,
attribute_set: Option<u32>,
surface_shader: Option<u32>,
}
fn ppc_q3_file_attach_trimesh_attribute_set(
q3_trimeshes: &mut [PpcQ3TriMeshRecord],
trimesh: u32,
attribute_set: u32,
) -> bool {
let Some(record) = q3_trimeshes
.iter_mut()
.find(|record| record.trimesh == trimesh)
else {
return false;
};
ppc_q3_write_u32_to_slice(
&mut record.data,
PPC_Q3_TRIMESH_ATTRIBUTE_SET_OFFSET,
attribute_set,
)
.is_some()
}
fn ppc_q3_file_reference_target_offset(
memory: &mut PpcSectionMem,
storage: PpcQ3ObjectRecord,
reference_id: u32,
) -> Option<u32> {
let mut offset = 0u32;
while offset.checked_add(8)? <= storage.data_size {
let header_ptr = storage.data_ptr.checked_add(offset)?;
let object_type = memory.read_u32_be(header_ptr)?;
let body_size = memory.read_u32_be(header_ptr.checked_add(4)?)?;
let total_size = body_size.checked_add(8)?;
let next_offset = offset.checked_add(total_size)?;
if next_offset > storage.data_size {
return None;
}
if object_type == PPC_Q3_TYPE_TOC && body_size >= 28 {
let body_ptr = header_ptr.checked_add(8)?;
let entry_type = memory.read_u32_be(body_ptr.checked_add(16)?)?;
let entry_size = memory.read_u32_be(body_ptr.checked_add(20)?)?;
let entry_count = memory.read_u32_be(body_ptr.checked_add(24)?)?;
if !matches!((entry_type, entry_size), (0, 12) | (1, 16)) {
return None;
}
let entries_size = entry_size.checked_mul(entry_count)?;
if 28u32.checked_add(entries_size)? > body_size {
return None;
}
for entry_index in 0..entry_count {
let entry_offset = entry_size.checked_mul(entry_index)?;
let entry_ptr = body_ptr.checked_add(28)?.checked_add(entry_offset)?;
if memory.read_u32_be(entry_ptr)? != reference_id {
continue;
}
let location_high = memory.read_u32_be(entry_ptr.checked_add(4)?)?;
let location_low = memory.read_u32_be(entry_ptr.checked_add(8)?)?;
return (location_high == 0 && location_low < storage.data_size)
.then_some(location_low);
}
}
offset = next_offset;
}
None
}
fn ppc_q3_file_reference_target_object(
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
file: u32,
storage: PpcQ3ObjectRecord,
reference_id: u32,
) -> Option<u32> {
let target_offset = ppc_q3_file_reference_target_offset(memory, storage, reference_id)?;
let mut target = q3_objects
.iter()
.find(|record| record.source.file == file && record.source.offset == target_offset)
.map(|record| record.object)?;
// A binary 3DMF TOC points at the on-disk object header. References to
// container objects resolve to the first object inside the container,
// rather than to a separately visible container wrapper.
for _ in 0..32 {
if ppc_q3_object_type_for_handle(q3_objects, target) != PPC_Q3_TYPE_CONTAINER {
return Some(target);
}
target = q3_group_memberships
.iter()
.find(|record| record.group == target)
.map(|record| record.object)?;
}
None
}
fn ppc_q3_file_promote_container_root_object(
q3_objects: &mut [PpcQ3ObjectRecord],
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
container: u32,
root_child: u32,
) {
let Some(root_record) = q3_objects
.iter()
.find(|record| record.object == root_child)
.copied()
else {
return;
};
if let Some(container_record) = q3_objects
.iter_mut()
.find(|record| record.object == container)
{
container_record.object_type = root_record.object_type;
container_record.data_ptr = root_record.data_ptr;
container_record.data_size = root_record.data_size;
}
if let Some(record) = q3_trimeshes
.iter()
.find(|record| record.trimesh == root_child)
.cloned()
{
ppc_q3_trimesh_store_data(
q3_trimeshes,
container,
record.data,
record.triangle_attribute_sets,
);
}
if let Some(record) = q3_mipmap_textures
.iter()
.find(|record| record.texture == root_child)
.cloned()
{
ppc_q3_mipmap_texture_store_data(q3_mipmap_textures, container, record.mipmap);
}
if let Some(record) = q3_texture_shaders
.iter()
.find(|record| record.shader == root_child)
.copied()
{
ppc_q3_texture_shader_store_link(q3_texture_shaders, container, record.texture);
}
let root_styles: Vec<PpcQ3StyleRecord> = q3_styles
.iter()
.filter(|record| record.style == root_child)
.copied()
.collect();
for style in root_styles {
ppc_q3_style_store_data(q3_styles, container, style.kind, style.value);
}
let root_attributes: Vec<PpcQ3AttributeRecord> = q3_attributes
.iter()
.filter(|record| record.attribute_set == root_child)
.cloned()
.collect();
for attribute in root_attributes {
ppc_q3_attribute_store_data(
q3_attributes,
container,
attribute.attribute_type,
attribute.data,
);
}
}
fn ppc_q3_file_record_container_children(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
file: u32,
storage: PpcQ3ObjectRecord,
parent_object: u32,
parent_type: u32,
parent_offset: u32,
parent_body_size: u32,
parent_group_depth: u32,
) -> PpcQ3ParsedContainerState {
let mut state = PpcQ3ParsedContainerState::default();
let Some(body_start_offset) = parent_offset.checked_add(8) else {
return state;
};
let mut relative_offset = 0u32;
let mut current_attribute_set = None;
let mut current_trimesh = None;
let mut pending_texture_shader = None;
while relative_offset
.checked_add(8)
.is_some_and(|end| end <= parent_body_size)
{
let Some(child_offset) = body_start_offset.checked_add(relative_offset) else {
return state;
};
let Some(header_ptr) = storage.data_ptr.checked_add(child_offset) else {
return state;
};
let Some(object_type) = memory.read_u32_be(header_ptr) else {
return state;
};
let Some(body_size_ptr) = header_ptr.checked_add(4) else {
return state;
};
let Some(body_size) = memory.read_u32_be(body_size_ptr) else {
return state;
};
let Some(total_size) = body_size.checked_add(8) else {
return state;
};
let Some(next_relative_offset) = relative_offset.checked_add(total_size) else {
return state;
};
if next_relative_offset > parent_body_size {
return state;
}
if object_type == PPC_Q3_TYPE_REFERENCE {
let reference_id = header_ptr
.checked_add(8)
.filter(|_| body_size >= 4)
.and_then(|body_ptr| memory.read_u32_be(body_ptr));
let referenced_object = reference_id.and_then(|reference_id| {
ppc_q3_file_reference_target_object(
memory,
q3_objects,
q3_group_memberships,
file,
storage,
reference_id,
)
});
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3File reference id={:?} parent=${:08X} target={:?}",
reference_id,
parent_object,
referenced_object.map(|object| format!("${object:08X}")),
);
}
if let Some(referenced_object) = referenced_object {
state.root_child.get_or_insert(referenced_object);
ppc_q3_group_add_membership_once(
q3_group_memberships,
parent_object,
referenced_object,
);
match ppc_q3_object_type_for_handle(q3_objects, referenced_object) {
PPC_Q3_TYPE_ATTRIBUTE_SET => {
current_attribute_set = Some(referenced_object);
state.attribute_set.get_or_insert(referenced_object);
if let Some(trimesh) = current_trimesh {
let _ = ppc_q3_file_attach_trimesh_attribute_set(
q3_trimeshes,
trimesh,
referenced_object,
);
}
}
PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE => {
state.surface_shader.get_or_insert(referenced_object);
}
PPC_Q3_TYPE_TRIMESH => current_trimesh = Some(referenced_object),
_ => {}
}
}
} else if !ppc_q3_file_control_type(object_type) {
let child = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
object_type,
header_ptr,
total_size,
);
if child == 0 {
return state;
}
state.root_child.get_or_insert(child);
if let Some(record) = q3_objects.iter_mut().find(|record| record.object == child) {
record.source = PpcQ3ObjectSource {
file,
offset: child_offset,
parent_group_type: parent_type,
group_depth: parent_group_depth.saturating_add(1),
};
}
ppc_q3_group_add_membership_once(q3_group_memberships, parent_object, child);
if object_type == PPC_Q3_TYPE_ATTRIBUTE_SET {
current_attribute_set = Some(child);
state.attribute_set.get_or_insert(child);
}
if let (Some(attribute_set), Some(attribute_type)) = (
current_attribute_set,
ppc_q3_file_attribute_type_for_chunk(object_type),
) {
if let Some(data_size) = ppc_q3_attribute_data_size(attribute_type) {
if body_size >= data_size {
if let Some(body_ptr) = header_ptr.checked_add(8) {
if let Some(data) = ppc_q3_read_bytes(memory, body_ptr, data_size) {
ppc_q3_attribute_store_data(
q3_attributes,
attribute_set,
attribute_type,
data,
);
}
}
}
}
}
ppc_q3_file_record_object_body(
process_memory_manager,
memory,
q3_objects,
next_q3_object,
child,
object_type,
header_ptr,
body_size,
heap_cursor,
heap_limit,
last_mem_error,
q3_memory_storages,
q3_trimeshes,
q3_mipmap_textures,
q3_styles,
);
if object_type == PPC_Q3_TYPE_TRIMESH {
current_trimesh = Some(child);
} else if object_type == PPC_Q3_TYPE_ATTRIBUTE_ARRAY {
if let Some(target_trimesh) = current_trimesh {
if let Some(body_ptr) = header_ptr.checked_add(8) {
let _ = ppc_q3_file_attach_trimesh_attribute_array(
process_memory_manager,
memory,
target_trimesh,
body_ptr,
body_size,
heap_cursor,
heap_limit,
last_mem_error,
q3_trimeshes,
);
}
}
}
if object_type == PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE {
pending_texture_shader = Some(child);
} else if object_type == PPC_Q3_TEXTURE_TYPE_MIPMAP {
if let Some(shader) = pending_texture_shader.take() {
ppc_q3_texture_shader_store_link(q3_texture_shaders, shader, child);
state.surface_shader.get_or_insert(shader);
if let Some(attribute_set) = current_attribute_set {
ppc_q3_attribute_store_data(
q3_attributes,
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER,
shader.to_be_bytes().to_vec(),
);
}
}
}
if object_type == PPC_Q3_TYPE_CONTAINER {
let child_state = ppc_q3_file_record_container_children(
process_memory_manager,
memory,
q3_objects,
next_q3_object,
q3_memory_storages,
q3_group_memberships,
q3_attributes,
q3_trimeshes,
q3_mipmap_textures,
q3_texture_shaders,
q3_styles,
heap_cursor,
heap_limit,
last_mem_error,
file,
storage,
child,
object_type,
child_offset,
body_size,
parent_group_depth.saturating_add(1),
);
if let Some(shader) = child_state.surface_shader {
state.surface_shader.get_or_insert(shader);
if let Some(attribute_set) = current_attribute_set {
ppc_q3_attribute_store_data(
q3_attributes,
attribute_set,
PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER,
shader.to_be_bytes().to_vec(),
);
}
}
if let (Some(trimesh), Some(attribute_set)) =
(current_trimesh, child_state.attribute_set)
{
let _ = ppc_q3_file_attach_trimesh_attribute_set(
q3_trimeshes,
trimesh,
attribute_set,
);
}
}
}
relative_offset = next_relative_offset;
}
if let (Some(trimesh), Some(attribute_set)) = (current_trimesh, current_attribute_set) {
let _ = ppc_q3_file_attach_trimesh_attribute_set(q3_trimeshes, trimesh, attribute_set);
}
state
}
fn ppc_q3_file_mirror_container_geometry_into_group(
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_objects: &[PpcQ3ObjectRecord],
group: u32,
container: u32,
) {
let child_objects: Vec<u32> = q3_group_memberships
.iter()
.filter(|record| record.group == container)
.map(|record| record.object)
.collect();
for child in child_objects {
let child_type = ppc_q3_object_type_for_handle(q3_objects, child);
if ppc_q3_object_type_is_geometry(child_type) {
ppc_q3_group_add_membership_once(q3_group_memberships, group, child);
} else if child_type == PPC_Q3_TYPE_CONTAINER || ppc_q3_object_type_is_group(child_type) {
ppc_q3_file_mirror_container_geometry_into_group(
q3_group_memberships,
q3_objects,
group,
child,
);
}
}
}
fn ppc_q3_file_is_end_of_file(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_files: &[PpcQ3FileRecord],
) -> u32 {
let file = cpu.gpr[3];
if !ppc_q3_validate_file_handle(q3_objects, q3_error_state, file) {
return 1;
}
let Some(file_record) = q3_files.iter().find(|record| record.file == file) else {
return 1;
};
if !file_record.is_open || file_record.storage == 0 {
return 1;
}
if !ppc_q3_validate_storage_handle(q3_objects, q3_error_state, file_record.storage) {
return 1;
}
let Some(storage_record) = q3_objects
.iter()
.find(|record| record.object == file_record.storage)
else {
return 1;
};
u32::from(
ppc_q3_file_next_object_chunk(memory, *storage_record, file_record.read_offset).is_none(),
)
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct PpcQ3FileChunk {
offset: u32,
next_offset: u32,
object_type: u32,
body_size: u32,
total_size: u32,
parent_group_type: u32,
group_depth: u32,
group_stack: Vec<PpcQ3FileGroupChunk>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcQ3FileGroupChunk {
offset: u32,
total_size: u32,
group_type: u32,
}
fn ppc_q3_file_next_object_chunk(
memory: &mut PpcSectionMem,
storage: PpcQ3ObjectRecord,
start_offset: u32,
) -> Option<PpcQ3FileChunk> {
let mut offset = 0u32;
let mut group_stack = Vec::new();
while offset.checked_add(8)? <= storage.data_size {
let header_ptr = storage.data_ptr.checked_add(offset)?;
let object_type = memory.read_u32_be(header_ptr)?;
let body_size = memory.read_u32_be(header_ptr.checked_add(4)?)?;
let total_size = body_size.checked_add(8)?;
let next_offset = offset.checked_add(total_size)?;
if next_offset > storage.data_size {
return None;
}
if object_type == PPC_Q3_TYPE_BEGIN_GROUP {
group_stack.push(PpcQ3FileGroupChunk {
offset,
total_size,
group_type: ppc_q3_file_group_type(memory, header_ptr, body_size)?,
});
} else if object_type == PPC_Q3_TYPE_END_GROUP {
let _ = group_stack.pop();
} else if !ppc_q3_file_control_type(object_type) && offset >= start_offset {
return Some(PpcQ3FileChunk {
offset,
next_offset,
object_type,
body_size,
total_size,
parent_group_type: group_stack
.last()
.map(|group| group.group_type)
.unwrap_or(PPC_Q3_TYPE_NONE),
group_depth: u32::try_from(group_stack.len()).unwrap_or(u32::MAX),
group_stack: group_stack.clone(),
});
}
offset = next_offset;
}
None
}
fn ppc_q3_file_ensure_group_stack(
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &mut Vec<PpcQ3FileGroupRecord>,
file: u32,
storage: PpcQ3ObjectRecord,
group_stack: &[PpcQ3FileGroupChunk],
) -> Option<u32> {
let mut parent_group = 0;
for (index, group_chunk) in group_stack.iter().copied().enumerate() {
let group_depth = u32::try_from(index.saturating_add(1)).unwrap_or(u32::MAX);
let group = ppc_q3_file_group_for_chunk(
q3_objects,
next_q3_object,
q3_file_groups,
file,
storage,
group_chunk,
parent_group,
group_depth,
)?;
if parent_group != 0 {
ppc_q3_group_add_membership_once(q3_group_memberships, parent_group, group);
}
parent_group = group;
}
(parent_group != 0).then_some(parent_group)
}
fn ppc_q3_file_group_for_chunk(
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
q3_file_groups: &mut Vec<PpcQ3FileGroupRecord>,
file: u32,
storage: PpcQ3ObjectRecord,
group_chunk: PpcQ3FileGroupChunk,
parent_group: u32,
group_depth: u32,
) -> Option<u32> {
if let Some(record) = q3_file_groups
.iter()
.find(|record| record.file == file && record.offset == group_chunk.offset)
{
return Some(record.group);
}
let data_ptr = storage.data_ptr.checked_add(group_chunk.offset)?;
let group = ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
group_chunk.group_type,
data_ptr,
group_chunk.total_size,
);
if group == 0 {
return None;
}
if let Some(record) = q3_objects.iter_mut().find(|record| record.object == group) {
record.source = PpcQ3ObjectSource {
file,
offset: group_chunk.offset,
parent_group_type: q3_file_groups
.iter()
.find(|record| record.group == parent_group)
.map(|record| record.group_type)
.unwrap_or(PPC_Q3_TYPE_NONE),
group_depth,
};
}
q3_file_groups.push(PpcQ3FileGroupRecord {
file,
offset: group_chunk.offset,
group,
group_type: group_chunk.group_type,
parent_group,
group_depth,
});
Some(group)
}
fn ppc_q3_file_group_type(
memory: &mut PpcSectionMem,
header_ptr: u32,
body_size: u32,
) -> Option<u32> {
if body_size >= 4 {
memory.read_u32_be(header_ptr.checked_add(8)?)
} else {
Some(PPC_Q3_TYPE_NONE)
}
}
fn ppc_q3_file_control_type(object_type: u32) -> bool {
matches!(
object_type,
PPC_Q3_TYPE_3DMF | PPC_Q3_TYPE_BEGIN_GROUP | PPC_Q3_TYPE_END_GROUP | PPC_Q3_TYPE_TOC
)
}
fn ppc_q3_file_close(
cpu: &PpcCpu,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
q3_files: &mut Vec<PpcQ3FileRecord>,
) -> bool {
if !ppc_q3_validate_file_handle(q3_objects, q3_error_state, cpu.gpr[3]) {
return false;
}
let Some(record) = ppc_q3_file_mut(q3_files, cpu.gpr[3]) else {
return false;
};
record.is_open = false;
record.read_offset = 0;
record.read_object = 0;
true
}
fn ppc_q3_group_add_object(
group: u32,
object: u32,
before_position: Option<u32>,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_lights: &[PpcQ3LightRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> u32 {
if group == 0 || object == 0 {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return 0;
}
let group_type = ppc_q3_object_type_for_handle(q3_objects, group);
if !ppc_q3_object_type_is_group(group_type) {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return 0;
}
if !ppc_q3_object_exists(q3_objects, object) {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return 0;
}
if group_type == PPC_Q3_GROUP_TYPE_LIGHT
&& !q3_lights.iter().any(|record| record.light == object)
{
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return 0;
}
let (insert_index, position) = if let Some(position) = before_position {
let Some(index) =
ppc_q3_group_record_index_for_position(q3_group_memberships, group, position)
else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return 0;
};
(index, position)
} else {
let group_member_count = q3_group_memberships
.iter()
.filter(|record| record.group == group)
.count();
let Some(position) = ppc_q3_group_position_from_index(group_member_count) else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return 0;
};
(q3_group_memberships.len(), position)
};
if !ppc_q3_object_retain(q3_objects, q3_object_refs, object) {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return 0;
}
let record = PpcQ3GroupMembershipRecord {
group,
object,
before: before_position,
};
if before_position.is_some() {
q3_group_memberships.insert(insert_index, record);
} else {
q3_group_memberships.push(record);
}
position
}
fn ppc_q3_group_add_membership_once(
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
group: u32,
object: u32,
) {
if group == 0 || object == 0 {
return;
}
if q3_group_memberships
.iter()
.any(|record| record.group == group && record.object == object)
{
return;
}
q3_group_memberships.push(PpcQ3GroupMembershipRecord {
group,
object,
before: None,
});
}
fn ppc_q3_group_count_objects(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let group = cpu.gpr[3];
let count_out_ptr = cpu.gpr[4];
if group == 0 || count_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, count_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_group_handle(q3_objects, q3_error_state, group) {
return false;
}
let count =
ppc_q3_group_position_objects(q3_group_memberships, q3_objects, q3_file_groups, group)
.len();
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3Group_CountObjects group=${:08X} type='{}' count={}",
group,
format_ppc_fourcc(ppc_q3_object_type_for_handle(q3_objects, group)),
count
);
}
memory
.write_u32_be(count_out_ptr, u32::try_from(count).unwrap_or(u32::MAX))
.is_some()
}
fn ppc_q3_group_get_first_position(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let group = cpu.gpr[3];
let position_out_ptr = cpu.gpr[4];
if group == 0
|| position_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, position_out_ptr, 4)
{
return false;
}
if !ppc_q3_validate_group_handle(q3_objects, q3_error_state, group) {
return false;
}
let position = ppc_q3_group_first_visible_position_matching(
q3_group_memberships,
q3_objects,
q3_file_groups,
group,
|_| true,
);
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3Group_GetFirstPosition group=${:08X} type='{}' position={}",
group,
format_ppc_fourcc(ppc_q3_object_type_for_handle(q3_objects, group)),
position
);
}
memory.write_u32_be(position_out_ptr, position).is_some()
}
fn ppc_q3_group_get_next_position(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let group = cpu.gpr[3];
let position_ptr = cpu.gpr[4];
if group == 0 || position_ptr == 0 || !ppc_memory_can_write_bytes(memory, position_ptr, 4) {
return false;
}
let Some(position) = memory.read_u32_be(position_ptr) else {
return false;
};
if !ppc_q3_validate_group_handle(q3_objects, q3_error_state, group) {
return false;
}
if position == 0 {
return memory.write_u32_be(position_ptr, 0).is_some();
}
let Some(current_index) = ppc_q3_group_index_from_position(position) else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
};
let visible_objects =
ppc_q3_group_position_objects(q3_group_memberships, q3_objects, q3_file_groups, group);
if current_index >= visible_objects.len() {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
let next_position = current_index
.checked_add(1)
.filter(|next_index| *next_index < visible_objects.len())
.and_then(ppc_q3_group_position_from_index)
.unwrap_or(0);
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3Group_GetNextPosition group=${:08X} type='{}' current={} next={}",
group,
format_ppc_fourcc(ppc_q3_object_type_for_handle(q3_objects, group)),
position,
next_position
);
}
memory.write_u32_be(position_ptr, next_position).is_some()
}
fn ppc_q3_group_get_first_position_of_type(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let group = cpu.gpr[3];
let object_type = cpu.gpr[4];
let position_out_ptr = cpu.gpr[5];
if group == 0
|| object_type == PPC_Q3_TYPE_NONE
|| position_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, position_out_ptr, 4)
{
return false;
}
if !ppc_q3_validate_group_handle(q3_objects, q3_error_state, group) {
return false;
}
let position = ppc_q3_group_first_visible_position_matching(
q3_group_memberships,
q3_objects,
q3_file_groups,
group,
|object| {
ppc_q3_object_type_matches(
ppc_q3_object_type_for_handle(q3_objects, object),
object_type,
)
},
);
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Q3Group_GetFirstPositionOfType group=${:08X} group_type='{}' requested='{}' position={}",
group,
format_ppc_fourcc(ppc_q3_object_type_for_handle(q3_objects, group)),
format_ppc_fourcc(object_type),
position
);
}
memory.write_u32_be(position_out_ptr, position).is_some()
}
fn ppc_q3_group_get_position_object(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_lights: &[PpcQ3LightRecord],
q3_trimeshes: &[PpcQ3TriMeshRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let group = cpu.gpr[3];
let position = cpu.gpr[4];
let object_out_ptr = cpu.gpr[5];
if group == 0 || object_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, object_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_group_handle(q3_objects, q3_error_state, group) {
return false;
}
let Some(object) = ppc_q3_group_visible_object_for_position(
q3_group_memberships,
q3_objects,
q3_file_groups,
group,
position,
) else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
};
if !ppc_q3_group_member_accepts_object(q3_objects, q3_lights, q3_error_state, group, object) {
return false;
}
if memory.write_u32_be(object_out_ptr, object).is_none() {
return false;
}
if !ppc_q3_object_retain(q3_objects, q3_object_refs, object) {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
if ppc_hle_trace_enabled() || qd3d_trace_enabled() {
let object_type = ppc_q3_object_type_for_handle(q3_objects, object);
let trimesh_counts = q3_trimeshes
.iter()
.find(|record| record.trimesh == object)
.map(|record| {
(
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)
.unwrap_or(0),
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_NUM_POINTS_OFFSET)
.unwrap_or(0),
)
});
if let Some((triangles, points)) = trimesh_counts {
eprintln!(
"[PPC-TRACE] Q3Group_GetPositionObject group=${:08X} position={} object=${:08X} type='{}' triangles={} points={}",
group,
position,
object,
format_ppc_fourcc(object_type),
triangles,
points
);
} else {
eprintln!(
"[PPC-TRACE] Q3Group_GetPositionObject group=${:08X} position={} object=${:08X} type='{}'",
group,
position,
object,
format_ppc_fourcc(object_type)
);
}
}
true
}
fn ppc_q3_group_member_accepts_object(
q3_objects: &[PpcQ3ObjectRecord],
q3_lights: &[PpcQ3LightRecord],
q3_error_state: &mut PpcQ3ErrorState,
group: u32,
object: u32,
) -> bool {
if !ppc_q3_object_exists(q3_objects, object) {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
let group_type = ppc_q3_object_type_for_handle(q3_objects, group);
if group_type == PPC_Q3_GROUP_TYPE_LIGHT
&& !q3_lights.iter().any(|record| record.light == object)
{
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
true
}
fn ppc_q3_group_remove_position(
cpu: &PpcCpu,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> Option<u32> {
let group = cpu.gpr[3];
let position = cpu.gpr[4];
if !ppc_q3_validate_group_handle(q3_objects, q3_error_state, group) {
return None;
}
let Some(index) = ppc_q3_group_record_index_for_position(q3_group_memberships, group, position)
else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return None;
};
Some(q3_group_memberships.remove(index).object)
}
fn ppc_q3_validate_group_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
group: u32,
) -> bool {
let group_type = ppc_q3_object_type_for_handle(q3_objects, group);
if ppc_q3_object_type_is_group(group_type) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_group_first_visible_position_matching(
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
group: u32,
predicate: impl Fn(u32) -> bool,
) -> u32 {
ppc_q3_group_position_objects(q3_group_memberships, q3_objects, q3_file_groups, group)
.iter()
.copied()
.enumerate()
.find(|(_, object)| predicate(*object))
.and_then(|(index, _)| ppc_q3_group_position_from_index(index))
.unwrap_or(0)
}
fn ppc_q3_group_visible_object_for_position(
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
group: u32,
position: u32,
) -> Option<u32> {
let index = ppc_q3_group_index_from_position(position)?;
ppc_q3_group_position_objects(q3_group_memberships, q3_objects, q3_file_groups, group)
.get(index)
.copied()
}
fn ppc_q3_group_position_objects(
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
group: u32,
) -> Vec<u32> {
if ppc_q3_group_uses_direct_positions(q3_group_memberships, q3_objects, group) {
return ppc_q3_group_direct_position_objects(
q3_group_memberships,
q3_objects,
q3_file_groups,
group,
);
}
ppc_q3_group_visible_objects(q3_group_memberships, q3_objects, group)
}
fn ppc_q3_group_uses_direct_positions(
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
group: u32,
) -> bool {
let Some(group_record) = q3_objects.iter().find(|record| record.object == group) else {
return false;
};
if group_record.source.file != 0 || group_record.object_type != PPC_Q3_GROUP_TYPE_DISPLAY {
return false;
}
let direct_objects = ppc_q3_group_direct_objects(q3_group_memberships, group);
direct_objects.len() > 1
&& direct_objects.iter().all(|object| {
q3_objects
.iter()
.find(|record| record.object == *object)
.is_some_and(|record| {
record.source.file != 0
&& !ppc_q3_object_type_is_transform(record.object_type)
&& !ppc_q3_object_type_is_group(record.object_type)
})
})
}
fn ppc_q3_group_direct_objects(
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
group: u32,
) -> Vec<u32> {
q3_group_memberships
.iter()
.filter(|record| record.group == group)
.map(|record| record.object)
.collect()
}
fn ppc_q3_group_direct_position_objects(
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
group: u32,
) -> Vec<u32> {
let direct_objects = ppc_q3_group_direct_objects(q3_group_memberships, group);
let top_level_objects =
ppc_q3_group_direct_top_level_file_objects(&direct_objects, q3_objects, q3_file_groups);
if top_level_objects.len() > 1 && top_level_objects.len() < direct_objects.len() {
top_level_objects
} else {
direct_objects
}
}
fn ppc_q3_group_direct_top_level_file_objects(
direct_objects: &[u32],
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
) -> Vec<u32> {
let mut top_level_objects = Vec::new();
for object in direct_objects {
let Some(group) =
ppc_q3_top_level_file_object_for_object(q3_objects, q3_file_groups, *object)
else {
return Vec::new();
};
ppc_q3_group_visible_push_unique(&mut top_level_objects, group);
}
top_level_objects
}
fn ppc_q3_top_level_file_object_for_object(
q3_objects: &[PpcQ3ObjectRecord],
q3_file_groups: &[PpcQ3FileGroupRecord],
object: u32,
) -> Option<u32> {
let object_record = q3_objects.iter().find(|record| record.object == object)?;
if object_record.source.file == 0 || object_record.source.group_depth == 0 {
return None;
}
if object_record.source.group_depth == 1 {
return Some(object);
}
q3_file_groups
.iter()
.filter(|file_group| {
file_group.file == object_record.source.file
&& file_group.group_depth == 2
&& file_group.offset <= object_record.source.offset
})
.max_by_key(|file_group| file_group.offset)
.map(|file_group| file_group.group)
}
fn ppc_q3_group_visible_objects(
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
group: u32,
) -> Vec<u32> {
let mut visible = Vec::new();
let mut visited_groups = Vec::new();
for object in q3_group_memberships
.iter()
.filter(|record| record.group == group)
.map(|record| record.object)
{
ppc_q3_group_visible_push_unique(&mut visible, object);
ppc_q3_group_collect_visible_geometry(
q3_group_memberships,
q3_objects,
object,
&mut visible,
&mut visited_groups,
);
}
visible
}
fn ppc_q3_group_collect_visible_geometry(
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_objects: &[PpcQ3ObjectRecord],
object: u32,
visible: &mut Vec<u32>,
visited_groups: &mut Vec<u32>,
) {
let object_type = ppc_q3_object_type_for_handle(q3_objects, object);
if object_type != PPC_Q3_TYPE_CONTAINER && !ppc_q3_object_type_is_group(object_type) {
return;
}
if visited_groups.contains(&object) {
return;
}
visited_groups.push(object);
let child_objects: Vec<u32> = q3_group_memberships
.iter()
.filter(|record| record.group == object)
.map(|record| record.object)
.collect();
for child in child_objects {
let child_type = ppc_q3_object_type_for_handle(q3_objects, child);
if ppc_q3_object_type_is_geometry(child_type) {
ppc_q3_group_visible_push_unique(visible, child);
}
ppc_q3_group_collect_visible_geometry(
q3_group_memberships,
q3_objects,
child,
visible,
visited_groups,
);
}
}
fn ppc_q3_group_visible_push_unique(visible: &mut Vec<u32>, object: u32) {
if !visible.contains(&object) {
visible.push(object);
}
}
fn ppc_q3_group_record_index_for_position(
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
group: u32,
position: u32,
) -> Option<usize> {
if group == 0 {
return None;
}
let group_index = ppc_q3_group_index_from_position(position)?;
q3_group_memberships
.iter()
.enumerate()
.filter(|(_, record)| record.group == group)
.nth(group_index)
.map(|(index, _)| index)
}
fn ppc_q3_group_index_from_position(position: u32) -> Option<usize> {
usize::try_from(position.checked_sub(1)?).ok()
}
fn ppc_q3_group_position_from_index(index: usize) -> Option<u32> {
u32::try_from(index).ok()?.checked_add(1)
}
fn ppc_q3_view_mut(
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
view: u32,
) -> Option<&mut PpcQ3ViewStateRecord> {
if view == 0 {
return None;
}
if let Some(index) = q3_views.iter().position(|record| record.view == view) {
return q3_views.get_mut(index);
}
q3_views.push(PpcQ3ViewStateRecord::new(view));
q3_views.last_mut()
}
fn ppc_q3_known_view_mut<'a>(
q3_views: &'a mut Vec<PpcQ3ViewStateRecord>,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
view: u32,
) -> Option<&'a mut PpcQ3ViewStateRecord> {
if view == 0 {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return None;
}
if let Some(index) = q3_views.iter().position(|record| record.view == view) {
return q3_views.get_mut(index);
}
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view) {
return None;
}
q3_views.push(PpcQ3ViewStateRecord::new(view));
q3_views.last_mut()
}
fn ppc_q3_view_set_light_group(
cpu: &PpcCpu,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
q3_files: &mut Vec<PpcQ3FileRecord>,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &mut Vec<PpcQ3FileGroupRecord>,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_view_state_stack: &mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_completed_frames: &mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
q3_fog_styles: &mut Vec<PpcQ3FogStyleRecord>,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_shader_uv_transforms: &mut Vec<PpcQ3ShaderUvTransformRecord>,
q3_shader_boundaries: &mut Vec<PpcQ3ShaderBoundaryRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
q3_draw_contexts: &mut Vec<PpcQ3DrawContextRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
q3_lights: &mut Vec<PpcQ3LightRecord>,
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let view = cpu.gpr[3];
let light_group = cpu.gpr[4];
if view == 0 || light_group == 0 {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view)
|| !ppc_q3_view_slot_accepts_object(
q3_objects,
q3_error_state,
PpcQ3ViewSlot::LightGroup,
light_group,
)
{
return false;
}
let old_light_group = q3_views
.iter()
.find(|record| record.view == view)
.map(|record| record.light_group)
.unwrap_or(0);
if old_light_group == light_group {
return true;
}
let retained = ppc_q3_object_retain(q3_objects, q3_object_refs, light_group);
if !retained {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
if !ppc_q3_view_set_slot(cpu, q3_views, PpcQ3ViewSlot::LightGroup) {
let mut stores = PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
};
let _ = ppc_q3_object_release_reference(&mut stores, light_group);
return false;
}
if old_light_group != 0 {
let mut stores = PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
};
let _ = ppc_q3_object_release_reference(&mut stores, old_light_group);
}
true
}
fn ppc_q3_view_set_owned_slot(
cpu: &PpcCpu,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
q3_renderer_preferences: &mut Vec<PpcQ3RendererPreferenceRecord>,
q3_files: &mut Vec<PpcQ3FileRecord>,
q3_group_memberships: &mut Vec<PpcQ3GroupMembershipRecord>,
q3_file_groups: &mut Vec<PpcQ3FileGroupRecord>,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_view_state_stack: &mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_completed_frames: &mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
q3_fog_styles: &mut Vec<PpcQ3FogStyleRecord>,
q3_memory_storages: &mut Vec<PpcQ3MemoryStorageRecord>,
q3_attributes: &mut Vec<PpcQ3AttributeRecord>,
q3_shader_uv_transforms: &mut Vec<PpcQ3ShaderUvTransformRecord>,
q3_shader_boundaries: &mut Vec<PpcQ3ShaderBoundaryRecord>,
q3_mipmap_textures: &mut Vec<PpcQ3MipmapTextureRecord>,
q3_texture_shaders: &mut Vec<PpcQ3TextureShaderRecord>,
q3_draw_contexts: &mut Vec<PpcQ3DrawContextRecord>,
q3_trimeshes: &mut Vec<PpcQ3TriMeshRecord>,
q3_styles: &mut Vec<PpcQ3StyleRecord>,
q3_cameras: &mut Vec<PpcQ3CameraRecord>,
q3_lights: &mut Vec<PpcQ3LightRecord>,
slot: PpcQ3ViewSlot,
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let view = cpu.gpr[3];
let value = cpu.gpr[4];
if view == 0 || value == 0 {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view)
|| !ppc_q3_view_slot_accepts_object(q3_objects, q3_error_state, slot, value)
{
return false;
}
let old_value = q3_views
.iter()
.find(|record| record.view == view)
.map(|record| ppc_q3_view_slot_value(record, slot))
.unwrap_or(0);
if old_value == value {
return true;
}
let retained = ppc_q3_object_retain(q3_objects, q3_object_refs, value);
if !retained {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
if !ppc_q3_view_set_slot(cpu, q3_views, slot) {
let mut stores = PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
};
let _ = ppc_q3_object_release_reference(&mut stores, value);
return false;
}
if old_value != 0 {
let mut stores = PpcQ3ObjectStores {
q3_objects,
q3_object_refs,
q3_renderer_preferences,
q3_files,
q3_group_memberships,
q3_file_groups,
q3_views,
q3_submissions,
q3_view_transforms,
q3_submission_transforms,
q3_view_materials,
q3_submission_materials,
q3_submission_lights,
q3_view_state_stack,
q3_completed_frames,
q3_retained_frames,
q3_fog_styles,
q3_memory_storages,
q3_attributes,
q3_shader_uv_transforms,
q3_shader_boundaries,
q3_mipmap_textures,
q3_texture_shaders,
q3_draw_contexts,
q3_trimeshes,
q3_styles,
q3_cameras,
q3_lights,
};
let _ = ppc_q3_object_release_reference(&mut stores, old_value);
}
true
}
fn ppc_q3_view_slot_accepts_object(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
slot: PpcQ3ViewSlot,
value: u32,
) -> bool {
let object_type = ppc_q3_object_type_for_handle(q3_objects, value);
let accepted = match slot {
PpcQ3ViewSlot::Renderer => ppc_q3_object_type_is_renderer(object_type),
PpcQ3ViewSlot::LightGroup => object_type == PPC_Q3_GROUP_TYPE_LIGHT,
PpcQ3ViewSlot::DrawContext => ppc_q3_object_type_is_draw_context(object_type),
PpcQ3ViewSlot::Camera => ppc_q3_object_type_is_camera(object_type),
};
if accepted {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_validate_view_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
view: u32,
) -> bool {
if ppc_q3_object_type_for_handle(q3_objects, view) == PPC_Q3_TYPE_VIEW {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_view_slot_value(record: &PpcQ3ViewStateRecord, slot: PpcQ3ViewSlot) -> u32 {
match slot {
PpcQ3ViewSlot::Renderer => record.renderer,
PpcQ3ViewSlot::LightGroup => record.light_group,
PpcQ3ViewSlot::DrawContext => record.draw_context,
PpcQ3ViewSlot::Camera => record.camera,
}
}
fn ppc_q3_view_set_slot(
cpu: &PpcCpu,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
slot: PpcQ3ViewSlot,
) -> bool {
let value = cpu.gpr[4];
if value == 0 {
return false;
}
let Some(record) = ppc_q3_view_mut(q3_views, cpu.gpr[3]) else {
return false;
};
match slot {
PpcQ3ViewSlot::Renderer => record.renderer = value,
PpcQ3ViewSlot::LightGroup => record.light_group = value,
PpcQ3ViewSlot::DrawContext => record.draw_context = value,
PpcQ3ViewSlot::Camera => record.camera = value,
}
true
}
fn ppc_q3_view_get_owned_slot(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_views: &[PpcQ3ViewStateRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_object_refs: &mut Vec<PpcQ3ObjectReferenceRecord>,
slot: PpcQ3ViewSlot,
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let view = cpu.gpr[3];
let value_out_ptr = cpu.gpr[4];
if view == 0 || value_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, value_out_ptr, 4) {
return false;
}
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view) {
return false;
}
let value = q3_views
.iter()
.find(|record| record.view == view)
.map(|record| ppc_q3_view_slot_value(record, slot))
.unwrap_or(0);
if value != 0 && !ppc_q3_view_slot_accepts_object(q3_objects, q3_error_state, slot, value) {
return false;
}
if memory.write_u32_be(value_out_ptr, value).is_none() {
return false;
}
if value != 0 {
let _ = ppc_q3_object_retain(q3_objects, q3_object_refs, value);
}
true
}
fn ppc_q3_view_start_rendering(
cpu: &PpcCpu,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_objects: &[PpcQ3ObjectRecord],
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let view = cpu.gpr[3];
let Some(record) = ppc_q3_known_view_mut(q3_views, q3_objects, q3_error_state, view) else {
return false;
};
if record.rendering_depth == 0
&& ppc_q3_queued_frame_has_records_for_view(
record.view,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
)
{
ppc_q3_drain_queued_frame_for_view(
record.view,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
);
}
record.rendering_depth = record.rendering_depth.saturating_add(1);
record.cancelled = false;
true
}
fn ppc_q3_view_end_rendering(
cpu: &PpcCpu,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_objects: &[PpcQ3ObjectRecord],
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_completed_frames: &mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
q3_state_only_completed_frame_batches: &mut Vec<PpcQ3StateOnlyCompletedFrameBatch>,
q3_draw_contexts: &[PpcQ3DrawContextRecord],
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
q3_error_state: &mut PpcQ3ErrorState,
) -> u32 {
let view = cpu.gpr[3];
let Some(record) = ppc_q3_known_view_mut(q3_views, q3_objects, q3_error_state, view) else {
return PPC_Q3_VIEW_STATUS_ERROR;
};
let was_rendering = record.rendering_depth > 0;
record.rendering_depth = record.rendering_depth.saturating_sub(1);
let completed = was_rendering && record.rendering_depth == 0;
let cancelled = record.cancelled;
let view = record.view;
let draw_context = record.draw_context;
if completed {
if !qd3d_dump_frame_enabled() {
let mut has_submission = false;
let mut has_trimesh = false;
for submission in q3_submissions
.iter()
.filter(|submission| submission.view == view)
{
has_submission = true;
if submission.kind == PpcQ3SubmissionKind::TriMesh {
has_trimesh = true;
break;
}
}
if !has_submission || cancelled {
ppc_q3_drain_queued_frame_for_view(
view,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
);
return PPC_Q3_VIEW_STATUS_DONE;
}
if !has_trimesh {
if let Some(frame) = ppc_q3_take_retained_frame_for_view(q3_retained_frames, view) {
ppc_q3_drain_queued_frame_for_view(
view,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
);
q3_completed_frames.push(frame);
return PPC_Q3_VIEW_STATUS_DONE;
}
let target = ppc_q3_render_target_for_view_draw_context(
q3_objects,
q3_draw_contexts,
gworlds,
current_gworld,
draw_context,
);
push_q3_state_only_completed_frame_batch(
q3_state_only_completed_frame_batches,
target,
);
ppc_q3_drain_queued_frame_for_view(
view,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
);
return PPC_Q3_VIEW_STATUS_DONE;
}
}
let frame = ppc_q3_take_completed_frame(
view,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
);
if !cancelled && !frame.submissions.is_empty() {
q3_completed_frames.push(frame);
}
}
PPC_Q3_VIEW_STATUS_DONE
}
fn dispatch_q3_view_end_rendering_import(
cpu: &PpcCpu,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_objects: &[PpcQ3ObjectRecord],
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_completed_frames: &mut Vec<PpcQ3CompletedFrameRecord>,
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
q3_state_only_completed_frame_batches: &mut Vec<PpcQ3StateOnlyCompletedFrameBatch>,
q3_draw_contexts: &[PpcQ3DrawContextRecord],
q3_trimeshes: &[PpcQ3TriMeshRecord],
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
q3_error_state: &mut PpcQ3ErrorState,
allow_idle_state_only_fast_forward: bool,
) -> PpcImportAction {
let view = cpu.gpr[3];
let idle_no_renderable_direct_trimesh_frame = allow_idle_state_only_fast_forward
&& q3_submissions
.iter()
.any(|submission| submission.view == view)
&& !ppc_q3_submissions_include_renderable_direct_trimesh(
q3_submissions,
q3_trimeshes,
view,
);
let completed_frames_before = q3_completed_frames.len();
let state_only_batches_before = q3_state_only_completed_frame_batches.len();
let state_only_last_batch_frames_before = q3_state_only_completed_frame_batches
.last()
.map(|batch| batch.frames)
.unwrap_or_default();
let result = ppc_q3_view_end_rendering(
cpu,
q3_views,
q3_objects,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
q3_completed_frames,
q3_retained_frames,
q3_state_only_completed_frame_batches,
q3_draw_contexts,
gworlds,
current_gworld,
q3_error_state,
);
let state_only_batch_added = q3_state_only_completed_frame_batches.len()
> state_only_batches_before
|| q3_state_only_completed_frame_batches
.last()
.map(|batch| batch.frames > state_only_last_batch_frames_before)
.unwrap_or(false);
let retained_idle_frame_added = idle_no_renderable_direct_trimesh_frame
&& q3_completed_frames.len() > completed_frames_before;
if allow_idle_state_only_fast_forward
&& result == PPC_Q3_VIEW_STATUS_DONE
&& (state_only_batch_added || retained_idle_frame_added)
{
PpcImportAction::ReturnWithExtraCycles(result, PPC_Q3_IDLE_STATE_ONLY_FRAME_EXTRA_CYCLES)
} else {
PpcImportAction::Return(result)
}
}
fn ppc_q3_submissions_include_renderable_direct_trimesh(
q3_submissions: &[PpcQ3SubmissionRecord],
q3_trimeshes: &[PpcQ3TriMeshRecord],
view: u32,
) -> bool {
q3_submissions
.iter()
.filter(|submission| {
submission.view == view && submission.kind == PpcQ3SubmissionKind::TriMesh
})
.any(|submission| {
q3_trimeshes
.iter()
.find(|record| record.trimesh == submission.primary)
.and_then(|record| {
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_NUM_TRIANGLES_OFFSET)
})
.unwrap_or(0)
> 0
})
}
fn ppc_q3_take_completed_frame(
view: u32,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
) -> PpcQ3CompletedFrameRecord {
PpcQ3CompletedFrameRecord {
view,
submissions: ppc_q3_take_records_for_view(q3_submissions, view, |record| record.view),
submission_transforms: ppc_q3_take_records_for_view(
q3_submission_transforms,
view,
|record| record.view,
),
submission_materials: ppc_q3_take_records_for_view(
q3_submission_materials,
view,
|record| record.view,
),
submission_lights: ppc_q3_take_records_for_view(q3_submission_lights, view, |record| {
record.view
}),
retained_trimeshes: Vec::new(),
}
}
fn q3_state_only_completed_frame_total(batches: &[PpcQ3StateOnlyCompletedFrameBatch]) -> usize {
batches
.iter()
.map(|batch| batch.frames)
.fold(0usize, usize::saturating_add)
}
fn push_q3_state_only_completed_frame_batch(
batches: &mut Vec<PpcQ3StateOnlyCompletedFrameBatch>,
target: Option<PpcQ3RenderTarget>,
) {
if let Some(batch) = batches.last_mut().filter(|batch| batch.target == target) {
batch.frames = batch.frames.saturating_add(1);
} else {
batches.push(PpcQ3StateOnlyCompletedFrameBatch { frames: 1, target });
}
}
fn ppc_q3_completed_frame_render_target(
q3_objects: &[PpcQ3ObjectRecord],
q3_views: &[PpcQ3ViewStateRecord],
q3_draw_contexts: &[PpcQ3DrawContextRecord],
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
frame: &PpcQ3CompletedFrameRecord,
) -> Option<PpcQ3RenderTarget> {
frame
.submissions
.iter()
.filter_map(|submission| {
q3_views
.iter()
.find(|record| record.view == submission.view)
.map(|view| view.draw_context)
})
.filter(|draw_context| *draw_context != 0)
.find_map(|draw_context| {
ppc_q3_draw_context_render_target(q3_objects, q3_draw_contexts, gworlds, draw_context)
})
.or_else(|| {
ppc_front_buffer_for_gworld(gworlds, current_gworld).map(|front_buffer| {
PpcQ3RenderTarget {
front_buffer,
viewport: None,
clear_color: None,
source: PpcQ3RenderTargetSource::CurrentGWorld,
draw_context: None,
gworld: Some(current_gworld),
}
})
})
}
fn ppc_q3_completed_frame_has_trimesh(frame: &PpcQ3CompletedFrameRecord) -> bool {
frame
.submissions
.iter()
.any(|submission| submission.kind == PpcQ3SubmissionKind::TriMesh)
}
fn ppc_q3_capture_retained_trimeshes(
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_trimeshes: &[PpcQ3TriMeshRecord],
frame: &PpcQ3CompletedFrameRecord,
) -> Vec<PpcQ3TriMeshRecord> {
let mut retained = Vec::new();
for primary in frame
.submissions
.iter()
.filter(|submission| submission.kind == PpcQ3SubmissionKind::TriMesh)
.map(|submission| submission.primary)
{
if retained
.iter()
.any(|record: &PpcQ3TriMeshRecord| record.trimesh == primary)
{
continue;
}
if let Some(record) = q3_trimeshes.iter().find(|record| record.trimesh == primary) {
retained.push(record.clone());
continue;
}
let data = q3_objects
.iter()
.find(|record| record.object == primary && record.object_type == PPC_Q3_TYPE_TRIMESH)
.and_then(|object| {
if object.data_ptr != 0 && object.data_size >= PPC_Q3_TRIMESH_DATA_SIZE {
ppc_q3_read_bytes(memory, object.data_ptr, PPC_Q3_TRIMESH_DATA_SIZE)
} else {
None
}
})
.or_else(|| ppc_q3_read_bytes(memory, primary, PPC_Q3_TRIMESH_DATA_SIZE));
if let Some(data) = data {
retained.push(PpcQ3TriMeshRecord {
trimesh: primary,
data,
triangle_attribute_sets: Vec::new(),
get_data_copies: Vec::new(),
});
}
}
retained
}
fn ppc_q3_limit_retained_frame_trimeshes(frame: &mut PpcQ3CompletedFrameRecord, limit: usize) {
if limit == 0 {
frame.submissions.clear();
frame.submission_transforms.clear();
frame.submission_materials.clear();
frame.submission_lights.clear();
frame.retained_trimeshes.clear();
return;
}
let mut kept_submissions = Vec::new();
let mut kept_transforms = Vec::new();
let mut kept_materials = Vec::new();
let mut kept_lights = Vec::new();
let mut kept_trimeshes = Vec::new();
for submission in frame
.submissions
.iter()
.filter(|submission| submission.kind == PpcQ3SubmissionKind::TriMesh)
.take(limit)
{
kept_submissions.push(*submission);
if let Some(transform) = frame
.submission_transforms
.iter()
.find(|record| ppc_q3_submission_transform_matches(record, submission))
{
kept_transforms.push(*transform);
}
if let Some(material) = frame
.submission_materials
.iter()
.find(|record| ppc_q3_submission_material_matches(record, submission))
{
kept_materials.push(material.clone());
}
if let Some(lights) = frame
.submission_lights
.iter()
.find(|record| ppc_q3_submission_light_matches(record, submission))
{
kept_lights.push(lights.clone());
}
if let Some(trimesh) = frame
.retained_trimeshes
.iter()
.find(|record| record.trimesh == submission.primary)
{
kept_trimeshes.push(trimesh.clone());
}
}
frame.submissions = kept_submissions;
frame.submission_transforms = kept_transforms;
frame.submission_materials = kept_materials;
frame.submission_lights = kept_lights;
frame.retained_trimeshes = kept_trimeshes;
}
fn ppc_q3_replace_retained_frame(
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
frame: PpcQ3CompletedFrameRecord,
) {
let view = frame.view;
q3_retained_frames.retain(|record| record.view != view);
q3_retained_frames.push(PpcQ3RetainedFrameRecord { view, frame });
}
fn ppc_q3_take_retained_frame_for_view(
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
view: u32,
) -> Option<PpcQ3CompletedFrameRecord> {
let index = q3_retained_frames
.iter()
.rposition(|record| record.view == view)?;
Some(q3_retained_frames.remove(index).frame)
}
fn ppc_q3_render_target_for_view_draw_context(
q3_objects: &[PpcQ3ObjectRecord],
q3_draw_contexts: &[PpcQ3DrawContextRecord],
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
draw_context: u32,
) -> Option<PpcQ3RenderTarget> {
if draw_context != 0 {
if let Some(target) =
ppc_q3_draw_context_render_target(q3_objects, q3_draw_contexts, gworlds, draw_context)
{
return Some(target);
}
}
ppc_front_buffer_for_gworld(gworlds, current_gworld).map(|front_buffer| PpcQ3RenderTarget {
front_buffer,
viewport: None,
clear_color: None,
source: PpcQ3RenderTargetSource::CurrentGWorld,
draw_context: None,
gworld: Some(current_gworld),
})
}
fn ppc_q3_take_records_for_view<T>(
records: &mut Vec<T>,
view: u32,
mut record_view: impl FnMut(&T) -> u32,
) -> Vec<T> {
let mut taken = Vec::new();
let mut kept = Vec::with_capacity(records.len());
for record in records.drain(..) {
if record_view(&record) == view {
taken.push(record);
} else {
kept.push(record);
}
}
*records = kept;
taken
}
fn ppc_q3_drain_records_for_view<T>(
records: &mut Vec<T>,
view: u32,
mut record_view: impl FnMut(&T) -> u32,
) {
records.retain(|record| record_view(record) != view);
}
fn ppc_q3_records_have_view<T>(
records: &[T],
view: u32,
mut record_view: impl FnMut(&T) -> u32,
) -> bool {
records.iter().any(|record| record_view(record) == view)
}
fn ppc_q3_queued_frame_has_records_for_view(
view: u32,
q3_submissions: &[PpcQ3SubmissionRecord],
q3_submission_transforms: &[PpcQ3SubmissionTransformRecord],
q3_submission_materials: &[PpcQ3SubmissionMaterialRecord],
q3_submission_lights: &[PpcQ3SubmissionLightRecord],
) -> bool {
ppc_q3_records_have_view(q3_submissions, view, |record| record.view)
|| ppc_q3_records_have_view(q3_submission_transforms, view, |record| record.view)
|| ppc_q3_records_have_view(q3_submission_materials, view, |record| record.view)
|| ppc_q3_records_have_view(q3_submission_lights, view, |record| record.view)
}
fn ppc_q3_drain_queued_frame_for_view(
view: u32,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
) {
ppc_q3_drain_records_for_view(q3_submissions, view, |record| record.view);
ppc_q3_drain_records_for_view(q3_submission_transforms, view, |record| record.view);
ppc_q3_drain_records_for_view(q3_submission_materials, view, |record| record.view);
ppc_q3_drain_records_for_view(q3_submission_lights, view, |record| record.view);
}
fn ppc_q3_completed_frame_references_object(
frame: &PpcQ3CompletedFrameRecord,
object: u32,
) -> bool {
frame.view == object
|| frame
.submissions
.iter()
.any(|record| ppc_q3_submission_record_references_object(record, object))
|| frame.submission_transforms.iter().any(|record| {
record.view == object || record.primary == object || record.secondary == object
})
|| frame
.submission_materials
.iter()
.any(|record| ppc_q3_submission_material_references_object(record, object))
|| frame
.submission_lights
.iter()
.any(|record| ppc_q3_submission_light_references_object(record, object))
}
fn ppc_q3_submission_record_references_object(record: &PpcQ3SubmissionRecord, object: u32) -> bool {
record.view == object || record.primary == object || record.secondary == object
}
fn ppc_q3_submission_material_references_object(
record: &PpcQ3SubmissionMaterialRecord,
object: u32,
) -> bool {
record.view == object
|| record.primary == object
|| record.secondary == object
|| record.shader == object
|| record.styles.iter().any(|style| style.style == object)
|| record
.shader_uv_transform
.map(|transform| transform.shader == object)
.unwrap_or(false)
|| record
.shader_boundary
.map(|boundary| boundary.shader == object)
.unwrap_or(false)
|| record
.texture_shader
.map(|shader| shader.shader == object || shader.texture == object)
.unwrap_or(false)
|| record
.mipmap_texture
.as_ref()
.map(|texture| texture.texture == object)
.unwrap_or(false)
|| record
.attributes
.iter()
.any(|attribute| attribute.attribute_set == object)
}
fn ppc_q3_submission_light_references_object(
record: &PpcQ3SubmissionLightRecord,
object: u32,
) -> bool {
record.view == object
|| record.primary == object
|| record.secondary == object
|| record.light_group == object
|| record.lights.iter().any(|light| light.light == object)
}
fn ppc_q3_view_state_snapshot_references_object(
record: &PpcQ3ViewStateSnapshotRecord,
object: u32,
) -> bool {
record.view == object
|| record
.transform
.as_ref()
.map(|transform| transform.view == object)
.unwrap_or(false)
|| record
.material
.as_ref()
.map(|material| ppc_q3_view_material_references_object(material, object))
.unwrap_or(false)
}
fn ppc_q3_view_material_references_object(record: &PpcQ3ViewMaterialRecord, object: u32) -> bool {
record.view == object
|| record.shader == object
|| record.styles.iter().any(|style| style.style == object)
|| record
.attributes
.iter()
.any(|attribute| attribute.attribute_set == object)
}
fn ppc_q3_view_start_bounding_box(
cpu: &PpcCpu,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let view = cpu.gpr[3];
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view) {
return false;
}
let Some(record) = ppc_q3_view_mut(q3_views, view) else {
return false;
};
record.bounding_box_depth = record.bounding_box_depth.saturating_add(1);
true
}
fn ppc_q3_view_end_bounding_box(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_objects: &[PpcQ3ObjectRecord],
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_retained_frames: &mut Vec<PpcQ3RetainedFrameRecord>,
q3_trimeshes: &[PpcQ3TriMeshRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> u32 {
let bounding_box_out_ptr = cpu.gpr[4];
if bounding_box_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, bounding_box_out_ptr, PPC_Q3_BOUNDING_BOX_SIZE)
{
return PPC_Q3_VIEW_STATUS_ERROR;
}
let view = cpu.gpr[3];
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view) {
return PPC_Q3_VIEW_STATUS_ERROR;
}
let Some(record) = ppc_q3_view_mut(q3_views, view) else {
return PPC_Q3_VIEW_STATUS_ERROR;
};
let was_bounding = record.bounding_box_depth > 0;
record.bounding_box_depth = record.bounding_box_depth.saturating_sub(1);
let completed = was_bounding && record.bounding_box_depth == 0;
let view = record.view;
if completed {
let frame = ppc_q3_take_completed_frame(
view,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
);
if ppc_q3_completed_frame_has_trimesh(&frame) {
let mut frame = frame;
frame.retained_trimeshes =
ppc_q3_capture_retained_trimeshes(memory, q3_objects, q3_trimeshes, &frame);
ppc_q3_limit_retained_frame_trimeshes(
&mut frame,
PPC_Q3_RETAINED_BOUNDING_TRIMESH_PREVIEW_LIMIT,
);
ppc_q3_replace_retained_frame(q3_retained_frames, frame);
}
}
if ppc_q3_write_bounding_box(memory, bounding_box_out_ptr).is_none() {
return PPC_Q3_VIEW_STATUS_ERROR;
}
PPC_Q3_VIEW_STATUS_DONE
}
fn ppc_q3_write_bounding_box(memory: &mut PpcSectionMem, bounding_box_ptr: u32) -> Option<()> {
ppc_write_q3_vector3d(memory, bounding_box_ptr, (-1.0, -1.0, -1.0))?;
ppc_write_q3_vector3d(
memory,
bounding_box_ptr.checked_add(PPC_Q3_BOUNDING_BOX_MAX_OFFSET)?,
(1.0, 1.0, 1.0),
)?;
memory.write_u32_be(
bounding_box_ptr.checked_add(PPC_Q3_BOUNDING_BOX_IS_EMPTY_OFFSET)?,
0,
)?;
Some(())
}
fn ppc_q3_view_cancel(
cpu: &PpcCpu,
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_objects: &[PpcQ3ObjectRecord],
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let view = cpu.gpr[3];
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view) {
return false;
}
let view = {
let Some(record) = ppc_q3_view_mut(q3_views, view) else {
return false;
};
record.cancelled = true;
record.rendering_depth = 0;
record.bounding_box_depth = 0;
record.view
};
let _ = ppc_q3_take_completed_frame(
view,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
);
true
}
fn ppc_q3_submit(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_view_state_stack: &mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_attributes: &[PpcQ3AttributeRecord],
q3_styles: &[PpcQ3StyleRecord],
q3_shader_boundaries: &[PpcQ3ShaderBoundaryRecord],
q3_shader_uv_transforms: &[PpcQ3ShaderUvTransformRecord],
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
q3_mipmap_textures: &[PpcQ3MipmapTextureRecord],
q3_trimeshes: &[PpcQ3TriMeshRecord],
q3_lights: &[PpcQ3LightRecord],
q3_error_state: &mut PpcQ3ErrorState,
kind: PpcQ3SubmissionKind,
) -> bool {
let (view, primary, secondary) = match kind {
PpcQ3SubmissionKind::ResetTransform
| PpcQ3SubmissionKind::Push
| PpcQ3SubmissionKind::Pop => (cpu.gpr[3], 0, 0),
_ => (cpu.gpr[4], cpu.gpr[3], 0),
};
if matches!(
kind,
PpcQ3SubmissionKind::Shader
| PpcQ3SubmissionKind::Style
| PpcQ3SubmissionKind::FogStyle
| PpcQ3SubmissionKind::TriMesh
| PpcQ3SubmissionKind::MatrixTransform
| PpcQ3SubmissionKind::Object
) && primary == 0
{
return false;
}
if !ppc_q3_submit_primary_accepts_object(q3_objects, q3_error_state, kind, primary) {
return false;
}
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view) {
return false;
}
if ppc_q3_view_mut(q3_views, view).is_none() {
return false;
}
let local_to_world = match kind {
PpcQ3SubmissionKind::MatrixTransform => {
let Some(matrix) = ppc_read_q3_matrix4x4(memory, primary) else {
return false;
};
ppc_q3_view_transform_push_matrix(q3_view_transforms, view, matrix)
}
PpcQ3SubmissionKind::ResetTransform => {
ppc_q3_view_transform_reset(q3_view_transforms, view)
}
PpcQ3SubmissionKind::Push => ppc_q3_view_state_push(
q3_view_state_stack,
q3_view_transforms,
q3_view_materials,
view,
),
PpcQ3SubmissionKind::Pop => {
let Some(local_to_world) = ppc_q3_view_state_pop(
q3_view_state_stack,
q3_view_transforms,
q3_view_materials,
view,
) else {
return false;
};
local_to_world
}
PpcQ3SubmissionKind::Shader
| PpcQ3SubmissionKind::Style
| PpcQ3SubmissionKind::FogStyle
| PpcQ3SubmissionKind::TriMesh
| PpcQ3SubmissionKind::Object => ppc_q3_view_transform_current(q3_view_transforms, view),
};
let light_snapshot = ppc_q3_submission_light_snapshot(
q3_views,
q3_group_memberships,
q3_lights,
view,
kind,
primary,
secondary,
);
let mut material = ppc_q3_view_material_for_submission(
q3_objects,
q3_view_materials,
q3_styles,
view,
kind,
primary,
None,
);
if kind == PpcQ3SubmissionKind::TriMesh {
let merged_retained_attributes = ppc_q3_view_material_merge_trimesh_attributes(
&mut material,
q3_trimeshes,
q3_attributes,
primary,
);
if !merged_retained_attributes {
let attribute_set = memory
.read_u32_be(primary.saturating_add(PPC_Q3_TRIMESH_ATTRIBUTE_SET_OFFSET))
.filter(|attribute_set| *attribute_set != 0);
if let Some(attribute_set) = attribute_set {
let mut attributes = ppc_q3_attributes_for_set(q3_attributes, attribute_set);
if attributes.is_empty() {
attributes = ppc_q3_attributes_for_set(q3_attributes, primary);
}
ppc_q3_view_material_merge_attributes(&mut material, attributes);
}
}
}
ppc_q3_record_submission(
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
view,
kind,
primary,
secondary,
local_to_world,
material.clone(),
q3_shader_boundaries,
q3_shader_uv_transforms,
q3_texture_shaders,
q3_mipmap_textures,
light_snapshot,
);
if kind == PpcQ3SubmissionKind::Object {
let mut object_local_to_world = local_to_world;
let mut object_material = material;
if ppc_q3_object_type_for_handle(q3_objects, primary) == PPC_Q3_TYPE_TRIMESH {
ppc_q3_record_trimesh_submission(
q3_views,
q3_group_memberships,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
q3_attributes,
q3_shader_boundaries,
q3_shader_uv_transforms,
q3_texture_shaders,
q3_mipmap_textures,
q3_trimeshes,
q3_lights,
view,
primary,
object_local_to_world,
object_material,
);
} else {
ppc_q3_record_object_submission_children(
memory,
q3_objects,
q3_group_memberships,
q3_views,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
q3_attributes,
q3_styles,
q3_shader_boundaries,
q3_shader_uv_transforms,
q3_texture_shaders,
q3_mipmap_textures,
q3_trimeshes,
q3_lights,
view,
primary,
&mut object_local_to_world,
&mut object_material,
0,
);
}
}
true
}
fn ppc_q3_submit_primary_accepts_object(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
kind: PpcQ3SubmissionKind,
primary: u32,
) -> bool {
let accepts = match kind {
PpcQ3SubmissionKind::Shader => {
ppc_q3_object_type_is_shader(ppc_q3_object_type_for_handle(q3_objects, primary))
}
PpcQ3SubmissionKind::Style => {
ppc_q3_object_type_is_style(ppc_q3_object_type_for_handle(q3_objects, primary))
}
PpcQ3SubmissionKind::Object => {
ppc_q3_object_type_is_drawable(ppc_q3_object_type_for_handle(q3_objects, primary))
}
PpcQ3SubmissionKind::FogStyle
| PpcQ3SubmissionKind::MatrixTransform
| PpcQ3SubmissionKind::Pop
| PpcQ3SubmissionKind::Push
| PpcQ3SubmissionKind::ResetTransform
| PpcQ3SubmissionKind::TriMesh => true,
};
if accepts {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_direct_style_submit(
cpu: &PpcCpu,
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_shader_boundaries: &[PpcQ3ShaderBoundaryRecord],
q3_shader_uv_transforms: &[PpcQ3ShaderUvTransformRecord],
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
q3_mipmap_textures: &[PpcQ3MipmapTextureRecord],
q3_lights: &[PpcQ3LightRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
style_kind: PpcQ3StyleKind,
style_type: u32,
) -> bool {
let value = cpu.gpr[3];
let view = cpu.gpr[4];
if !ppc_q3_style_value_valid(style_kind, value) {
return false;
}
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view) {
return false;
}
if ppc_q3_view_mut(q3_views, view).is_none() {
return false;
}
let style = PpcQ3StyleRecord {
style: 0,
kind: style_kind,
value,
};
let local_to_world = ppc_q3_view_transform_current(q3_view_transforms, view);
let light_snapshot = ppc_q3_submission_light_snapshot(
q3_views,
q3_group_memberships,
q3_lights,
view,
PpcQ3SubmissionKind::Style,
value,
style_type,
);
let material = {
let material = ppc_q3_view_material_mut(q3_view_materials, view);
ppc_q3_view_material_set_style(material, style);
material.clone()
};
ppc_q3_record_submission(
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
view,
PpcQ3SubmissionKind::Style,
value,
style_type,
local_to_world,
material,
q3_shader_boundaries,
q3_shader_uv_transforms,
q3_texture_shaders,
q3_mipmap_textures,
light_snapshot,
);
true
}
fn ppc_q3_fog_style_submit(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_views: &mut Vec<PpcQ3ViewStateRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_fog_styles: &mut Vec<PpcQ3FogStyleRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_shader_boundaries: &[PpcQ3ShaderBoundaryRecord],
q3_shader_uv_transforms: &[PpcQ3ShaderUvTransformRecord],
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
q3_mipmap_textures: &[PpcQ3MipmapTextureRecord],
q3_lights: &[PpcQ3LightRecord],
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let data_ptr = cpu.gpr[3];
let view = cpu.gpr[4];
if data_ptr == 0 || view == 0 {
return false;
}
let Some(data) = ppc_read_q3_fog_style_data(memory, data_ptr) else {
return false;
};
if !ppc_q3_fog_style_data_valid(data) {
return false;
}
if !ppc_q3_validate_view_handle(q3_objects, q3_error_state, view) {
return false;
}
if ppc_q3_view_mut(q3_views, view).is_none() {
return false;
}
let Some(secondary) = u32::try_from(q3_fog_styles.len())
.ok()
.and_then(|index| index.checked_add(1))
else {
return false;
};
q3_fog_styles.push(PpcQ3FogStyleRecord {
view,
data_ptr,
data,
});
let local_to_world = ppc_q3_view_transform_current(q3_view_transforms, view);
let light_snapshot = ppc_q3_submission_light_snapshot(
q3_views,
q3_group_memberships,
q3_lights,
view,
PpcQ3SubmissionKind::FogStyle,
data_ptr,
secondary,
);
let material = ppc_q3_view_material_for_submission(
&[],
q3_view_materials,
&[],
view,
PpcQ3SubmissionKind::FogStyle,
data_ptr,
Some(data),
);
ppc_q3_record_submission(
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
view,
PpcQ3SubmissionKind::FogStyle,
data_ptr,
secondary,
local_to_world,
material,
q3_shader_boundaries,
q3_shader_uv_transforms,
q3_texture_shaders,
q3_mipmap_textures,
light_snapshot,
);
true
}
fn ppc_q3_record_submission(
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
view: u32,
kind: PpcQ3SubmissionKind,
primary: u32,
secondary: u32,
local_to_world: [[f32; 4]; 4],
material: PpcQ3ViewMaterialRecord,
q3_shader_boundaries: &[PpcQ3ShaderBoundaryRecord],
q3_shader_uv_transforms: &[PpcQ3ShaderUvTransformRecord],
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
q3_mipmap_textures: &[PpcQ3MipmapTextureRecord],
light_snapshot: PpcQ3SubmissionLightRecord,
) {
let texture_shader = q3_texture_shaders
.iter()
.find(|record| record.shader == material.shader)
.copied();
let shader_boundary = q3_shader_boundaries
.iter()
.find(|record| record.shader == material.shader)
.copied();
let shader_uv_transform = q3_shader_uv_transforms
.iter()
.find(|record| record.shader == material.shader)
.copied();
let mipmap_texture = texture_shader.and_then(|shader| {
q3_mipmap_textures
.iter()
.find(|record| record.texture == shader.texture)
.cloned()
});
q3_submissions.push(PpcQ3SubmissionRecord {
view,
kind,
primary,
secondary,
});
q3_submission_transforms.push(PpcQ3SubmissionTransformRecord {
view,
kind,
primary,
secondary,
local_to_world,
});
q3_submission_materials.push(PpcQ3SubmissionMaterialRecord {
view,
kind,
primary,
secondary,
shader: material.shader,
illumination_type: material.illumination_type,
styles: material.styles,
fog_style: material.fog_style,
attributes: material.attributes,
shader_uv_transform,
shader_boundary,
texture_shader,
mipmap_texture,
});
q3_submission_lights.push(light_snapshot);
}
fn ppc_q3_record_object_submission_children(
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_views: &[PpcQ3ViewStateRecord],
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_attributes: &[PpcQ3AttributeRecord],
q3_styles: &[PpcQ3StyleRecord],
q3_shader_boundaries: &[PpcQ3ShaderBoundaryRecord],
q3_shader_uv_transforms: &[PpcQ3ShaderUvTransformRecord],
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
q3_mipmap_textures: &[PpcQ3MipmapTextureRecord],
q3_trimeshes: &[PpcQ3TriMeshRecord],
q3_lights: &[PpcQ3LightRecord],
view: u32,
group: u32,
local_to_world: &mut [[f32; 4]; 4],
material: &mut PpcQ3ViewMaterialRecord,
depth: u32,
) {
if depth >= 64 {
return;
}
let children = ppc_q3_object_submission_children(q3_objects, q3_group_memberships, group);
for child in children {
let child_object = q3_objects
.iter()
.find(|record| record.object == child)
.copied();
let object_type = child_object
.map(|record| record.object_type)
.unwrap_or(PPC_Q3_TYPE_NONE);
if object_type == PPC_Q3_TYPE_ATTRIBUTE_SET {
let attributes = ppc_q3_attributes_for_set(q3_attributes, child);
if !attributes.is_empty() {
ppc_q3_view_material_set_attributes(material, attributes);
}
continue;
}
if object_type == PPC_Q3_SURFACE_SHADER_TYPE_TEXTURE {
material.shader = child;
continue;
}
if ppc_q3_object_type_is_illumination_shader(object_type) {
material.illumination_type = object_type;
continue;
}
if let Some(style_kind) = ppc_q3_style_kind_for_type(object_type) {
if let Some(style) = q3_styles
.iter()
.find(|record| record.style == child && record.kind == style_kind)
.copied()
{
ppc_q3_view_material_set_style(material, style);
}
continue;
}
if object_type == PPC_Q3_TRANSFORM_TYPE_MATRIX {
if let Some(matrix) = child_object
.as_ref()
.and_then(ppc_q3_matrix_transform_matrix_ptr)
.and_then(|matrix_ptr| ppc_read_q3_matrix4x4(memory, matrix_ptr))
{
*local_to_world = ppc_q3_matrix4x4_multiply_values(*local_to_world, matrix);
}
continue;
}
if object_type == PPC_Q3_TYPE_TRIMESH {
ppc_q3_record_trimesh_submission(
q3_views,
q3_group_memberships,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
q3_attributes,
q3_shader_boundaries,
q3_shader_uv_transforms,
q3_texture_shaders,
q3_mipmap_textures,
q3_trimeshes,
q3_lights,
view,
child,
*local_to_world,
material.clone(),
);
continue;
}
if q3_group_memberships
.iter()
.any(|membership| membership.group == child)
{
ppc_q3_record_object_submission_children(
memory,
q3_objects,
q3_group_memberships,
q3_views,
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
q3_attributes,
q3_styles,
q3_shader_boundaries,
q3_shader_uv_transforms,
q3_texture_shaders,
q3_mipmap_textures,
q3_trimeshes,
q3_lights,
view,
child,
local_to_world,
material,
depth.saturating_add(1),
);
continue;
}
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_q3_record_trimesh_submission(
q3_views: &[PpcQ3ViewStateRecord],
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_submissions: &mut Vec<PpcQ3SubmissionRecord>,
q3_submission_transforms: &mut Vec<PpcQ3SubmissionTransformRecord>,
q3_submission_materials: &mut Vec<PpcQ3SubmissionMaterialRecord>,
q3_submission_lights: &mut Vec<PpcQ3SubmissionLightRecord>,
q3_attributes: &[PpcQ3AttributeRecord],
q3_shader_boundaries: &[PpcQ3ShaderBoundaryRecord],
q3_shader_uv_transforms: &[PpcQ3ShaderUvTransformRecord],
q3_texture_shaders: &[PpcQ3TextureShaderRecord],
q3_mipmap_textures: &[PpcQ3MipmapTextureRecord],
q3_trimeshes: &[PpcQ3TriMeshRecord],
q3_lights: &[PpcQ3LightRecord],
view: u32,
trimesh: u32,
local_to_world: [[f32; 4]; 4],
mut material: PpcQ3ViewMaterialRecord,
) {
ppc_q3_view_material_merge_trimesh_attributes(
&mut material,
q3_trimeshes,
q3_attributes,
trimesh,
);
let light_snapshot = ppc_q3_submission_light_snapshot(
q3_views,
q3_group_memberships,
q3_lights,
view,
PpcQ3SubmissionKind::TriMesh,
trimesh,
0,
);
ppc_q3_record_submission(
q3_submissions,
q3_submission_transforms,
q3_submission_materials,
q3_submission_lights,
view,
PpcQ3SubmissionKind::TriMesh,
trimesh,
0,
local_to_world,
material,
q3_shader_boundaries,
q3_shader_uv_transforms,
q3_texture_shaders,
q3_mipmap_textures,
light_snapshot,
);
}
fn ppc_q3_object_submission_children(
q3_objects: &[PpcQ3ObjectRecord],
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
group: u32,
) -> Vec<u32> {
let mut children: Vec<(usize, u32)> = q3_group_memberships
.iter()
.enumerate()
.filter(|(_, membership)| membership.group == group)
.map(|(index, membership)| (index, membership.object))
.collect();
if ppc_q3_object_is_io_proxy_display_group(q3_objects, group) {
return children
.into_iter()
.find(|(_, child)| ppc_q3_io_proxy_display_group_child_supported(q3_objects, *child))
.map(|(_, child)| vec![child])
.unwrap_or_default();
}
if ppc_q3_object_is_ordered_display_group(q3_objects, group) {
children.sort_by_key(|(index, child)| {
(
ppc_q3_ordered_display_group_child_sort_key(q3_objects, *child),
*index,
)
});
}
children.into_iter().map(|(_, child)| child).collect()
}
fn ppc_q3_object_is_ordered_display_group(q3_objects: &[PpcQ3ObjectRecord], object: u32) -> bool {
ppc_q3_object_type_for_handle(q3_objects, object) == PPC_Q3_GROUP_TYPE_ORDERED_DISPLAY
}
fn ppc_q3_object_is_io_proxy_display_group(q3_objects: &[PpcQ3ObjectRecord], object: u32) -> bool {
ppc_q3_object_type_for_handle(q3_objects, object) == PPC_Q3_GROUP_TYPE_IO_PROXY_DISPLAY
}
fn ppc_q3_io_proxy_display_group_child_supported(
q3_objects: &[PpcQ3ObjectRecord],
object: u32,
) -> bool {
let object_type = ppc_q3_object_type_for_handle(q3_objects, object);
ppc_q3_object_type_is_geometry(object_type) || ppc_q3_object_type_is_display_group(object_type)
}
fn ppc_q3_ordered_display_group_child_sort_key(
q3_objects: &[PpcQ3ObjectRecord],
object: u32,
) -> u8 {
let object_type = ppc_q3_object_type_for_handle(q3_objects, object);
if ppc_q3_object_type_is_transform(object_type) {
0
} else if ppc_q3_object_type_is_style(object_type) {
1
} else if ppc_q3_object_type_is_set(object_type) {
2
} else if ppc_q3_object_type_is_shader(object_type) {
3
} else if ppc_q3_object_type_is_geometry(object_type) {
4
} else if ppc_q3_object_type_is_display_group(object_type) {
5
} else {
6
}
}
fn ppc_q3_object_type_for_handle(q3_objects: &[PpcQ3ObjectRecord], object: u32) -> u32 {
ppc_q3_known_object_type_for_handle(q3_objects, object).unwrap_or(PPC_Q3_TYPE_NONE)
}
fn ppc_q3_known_object_type_for_handle(
q3_objects: &[PpcQ3ObjectRecord],
object: u32,
) -> Option<u32> {
q3_objects
.iter()
.find(|record| record.object == object)
.map(|record| record.object_type)
}
fn ppc_q3_submission_light_snapshot(
q3_views: &[PpcQ3ViewStateRecord],
q3_group_memberships: &[PpcQ3GroupMembershipRecord],
q3_lights: &[PpcQ3LightRecord],
view: u32,
kind: PpcQ3SubmissionKind,
primary: u32,
secondary: u32,
) -> PpcQ3SubmissionLightRecord {
let light_group = q3_views
.iter()
.find(|record| record.view == view)
.map(|record| record.light_group)
.unwrap_or(0);
let lights = if light_group == 0 {
Vec::new()
} else {
q3_group_memberships
.iter()
.filter(|membership| membership.group == light_group)
.filter_map(|membership| {
q3_lights
.iter()
.find(|light| light.light == membership.object)
.copied()
})
.collect()
};
PpcQ3SubmissionLightRecord {
view,
kind,
primary,
secondary,
light_group,
lights,
}
}
fn ppc_q3_view_material_mut(
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
view: u32,
) -> &mut PpcQ3ViewMaterialRecord {
if let Some(index) = q3_view_materials
.iter()
.position(|record| record.view == view)
{
return &mut q3_view_materials[index];
}
q3_view_materials.push(PpcQ3ViewMaterialRecord::new(view));
q3_view_materials
.last_mut()
.expect("just pushed Q3 view material record")
}
fn ppc_q3_view_material_for_submission(
q3_objects: &[PpcQ3ObjectRecord],
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
q3_styles: &[PpcQ3StyleRecord],
view: u32,
kind: PpcQ3SubmissionKind,
primary: u32,
fog_style: Option<PpcQ3FogStyleData>,
) -> PpcQ3ViewMaterialRecord {
let record = ppc_q3_view_material_mut(q3_view_materials, view);
match kind {
PpcQ3SubmissionKind::Shader => {
if let Some(illumination_type) = ppc_q3_illumination_shader_type(q3_objects, primary) {
record.illumination_type = illumination_type;
} else {
record.shader = primary;
}
}
PpcQ3SubmissionKind::Style => {
if let Some(style) = q3_styles
.iter()
.find(|style| style.style == primary)
.copied()
{
ppc_q3_view_material_set_style(record, style);
}
}
PpcQ3SubmissionKind::FogStyle => {
record.fog_style = fog_style;
}
PpcQ3SubmissionKind::TriMesh
| PpcQ3SubmissionKind::MatrixTransform
| PpcQ3SubmissionKind::ResetTransform
| PpcQ3SubmissionKind::Push
| PpcQ3SubmissionKind::Pop
| PpcQ3SubmissionKind::Object => {}
}
record.clone()
}
fn ppc_q3_view_material_set_style(material: &mut PpcQ3ViewMaterialRecord, style: PpcQ3StyleRecord) {
if let Some(record) = material
.styles
.iter_mut()
.find(|record| record.kind == style.kind)
{
*record = style;
} else {
material.styles.push(style);
material.styles.sort_by_key(|record| match record.kind {
PpcQ3StyleKind::Backfacing => 0,
PpcQ3StyleKind::Interpolation => 1,
PpcQ3StyleKind::Fill => 2,
PpcQ3StyleKind::Orientation => 3,
});
}
}
fn ppc_q3_view_material_set_attributes(
material: &mut PpcQ3ViewMaterialRecord,
attributes: Vec<PpcQ3AttributeRecord>,
) {
if let Some(shader) = ppc_q3_attributes_surface_shader(&attributes) {
material.shader = shader;
}
material.attributes = attributes;
}
fn ppc_q3_view_material_merge_trimesh_attributes(
material: &mut PpcQ3ViewMaterialRecord,
q3_trimeshes: &[PpcQ3TriMeshRecord],
q3_attributes: &[PpcQ3AttributeRecord],
trimesh: u32,
) -> bool {
let Some(record) = q3_trimeshes.iter().find(|record| record.trimesh == trimesh) else {
return false;
};
let mesh_attribute_set =
ppc_q3_trimesh_header_u32(&record.data, PPC_Q3_TRIMESH_ATTRIBUTE_SET_OFFSET)
.filter(|attribute_set| *attribute_set != 0);
for attribute_set in mesh_attribute_set
.iter()
.chain(record.triangle_attribute_sets.iter())
{
let attributes = ppc_q3_attributes_for_set(q3_attributes, *attribute_set);
ppc_q3_view_material_merge_attributes(material, attributes);
}
true
}
fn ppc_q3_view_material_merge_attributes(
material: &mut PpcQ3ViewMaterialRecord,
attributes: Vec<PpcQ3AttributeRecord>,
) {
if let Some(shader) = ppc_q3_attributes_surface_shader(&attributes) {
material.shader = shader;
}
for attribute in attributes {
if let Some(existing) = material
.attributes
.iter_mut()
.find(|record| record.attribute_type == attribute.attribute_type)
{
*existing = attribute;
} else {
material.attributes.push(attribute);
}
}
}
fn ppc_q3_illumination_shader_type(q3_objects: &[PpcQ3ObjectRecord], shader: u32) -> Option<u32> {
q3_objects
.iter()
.find(|record| record.object == shader)
.map(|record| record.object_type)
.filter(|object_type| ppc_q3_object_type_is_illumination_shader(*object_type))
}
fn ppc_q3_attributes_for_set(
q3_attributes: &[PpcQ3AttributeRecord],
attribute_set: u32,
) -> Vec<PpcQ3AttributeRecord> {
q3_attributes
.iter()
.filter(|record| record.attribute_set == attribute_set)
.cloned()
.collect()
}
fn ppc_q3_attributes_surface_shader(attributes: &[PpcQ3AttributeRecord]) -> Option<u32> {
attributes
.iter()
.find(|record| record.attribute_type == PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER)
.and_then(ppc_q3_attribute_surface_shader_handle)
}
fn ppc_q3_attribute_surface_shader_handle(record: &PpcQ3AttributeRecord) -> Option<u32> {
ppc_q3_attribute_surface_shader_handle_for_data(record.attribute_type, &record.data)
}
fn ppc_q3_attribute_surface_shader_handle_for_data(
attribute_type: u32,
data: &[u8],
) -> Option<u32> {
if attribute_type != PPC_Q3_ATTRIBUTE_TYPE_SURFACE_SHADER {
return None;
}
Some(u32::from_be_bytes([
*data.first()?,
*data.get(1)?,
*data.get(2)?,
*data.get(3)?,
]))
}
fn ppc_q3_attribute_surface_shader_accepts_object(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
surface_shader: u32,
) -> bool {
let Some(object_type) = q3_objects
.iter()
.find(|record| record.object == surface_shader)
.map(|record| record.object_type)
else {
return true;
};
if ppc_q3_object_type_is_surface_shader(object_type) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_view_transform_mut(
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
view: u32,
) -> &mut PpcQ3ViewTransformRecord {
if let Some(index) = q3_view_transforms
.iter()
.position(|record| record.view == view)
{
return &mut q3_view_transforms[index];
}
q3_view_transforms.push(PpcQ3ViewTransformRecord::new(view));
q3_view_transforms
.last_mut()
.expect("just pushed Q3 view transform record")
}
fn ppc_q3_view_transform_current_value(
q3_view_transforms: &[PpcQ3ViewTransformRecord],
view: u32,
) -> [[f32; 4]; 4] {
q3_view_transforms
.iter()
.find(|record| record.view == view)
.map(|record| record.local_to_world)
.unwrap_or_else(ppc_q3_matrix4x4_identity)
}
fn ppc_q3_view_transform_current(
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
view: u32,
) -> [[f32; 4]; 4] {
ppc_q3_view_transform_mut(q3_view_transforms, view).local_to_world
}
fn ppc_q3_view_transform_push_matrix(
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
view: u32,
matrix: [[f32; 4]; 4],
) -> [[f32; 4]; 4] {
let record = ppc_q3_view_transform_mut(q3_view_transforms, view);
record.stack.push(matrix);
record.local_to_world = ppc_q3_matrix4x4_multiply_values(record.local_to_world, matrix);
record.local_to_world
}
fn ppc_q3_view_transform_reset(
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
view: u32,
) -> [[f32; 4]; 4] {
let record = ppc_q3_view_transform_mut(q3_view_transforms, view);
record.stack.clear();
record.local_to_world = ppc_q3_matrix4x4_identity();
record.local_to_world
}
fn ppc_q3_view_state_push(
q3_view_state_stack: &mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_view_transforms: &[PpcQ3ViewTransformRecord],
q3_view_materials: &[PpcQ3ViewMaterialRecord],
view: u32,
) -> [[f32; 4]; 4] {
let transform = q3_view_transforms
.iter()
.find(|record| record.view == view)
.cloned();
let material = q3_view_materials
.iter()
.find(|record| record.view == view)
.cloned();
let local_to_world = transform
.as_ref()
.map(|record| record.local_to_world)
.unwrap_or_else(ppc_q3_matrix4x4_identity);
q3_view_state_stack.push(PpcQ3ViewStateSnapshotRecord {
view,
transform,
material,
});
local_to_world
}
fn ppc_q3_view_state_pop(
q3_view_state_stack: &mut Vec<PpcQ3ViewStateSnapshotRecord>,
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
view: u32,
) -> Option<[[f32; 4]; 4]> {
let index = q3_view_state_stack
.iter()
.rposition(|record| record.view == view)?;
let snapshot = q3_view_state_stack.remove(index);
ppc_q3_restore_view_transform(q3_view_transforms, view, snapshot.transform);
ppc_q3_restore_view_material(q3_view_materials, view, snapshot.material);
Some(ppc_q3_view_transform_current_value(
q3_view_transforms,
view,
))
}
fn ppc_q3_restore_view_transform(
q3_view_transforms: &mut Vec<PpcQ3ViewTransformRecord>,
view: u32,
transform: Option<PpcQ3ViewTransformRecord>,
) {
if let Some(transform) = transform {
if let Some(index) = q3_view_transforms
.iter()
.position(|record| record.view == view)
{
q3_view_transforms[index] = transform;
} else {
q3_view_transforms.push(transform);
}
} else {
q3_view_transforms.retain(|record| record.view != view);
}
}
fn ppc_q3_restore_view_material(
q3_view_materials: &mut Vec<PpcQ3ViewMaterialRecord>,
view: u32,
material: Option<PpcQ3ViewMaterialRecord>,
) {
if let Some(material) = material {
if let Some(index) = q3_view_materials
.iter()
.position(|record| record.view == view)
{
q3_view_materials[index] = material;
} else {
q3_view_materials.push(material);
}
} else {
q3_view_materials.retain(|record| record.view != view);
}
}
fn ppc_read_q3_fog_style_data(
memory: &mut PpcSectionMem,
data_ptr: u32,
) -> Option<PpcQ3FogStyleData> {
if data_ptr == 0 {
return None;
}
let color_b_ptr = data_ptr.checked_add(PPC_Q3_FOG_STYLE_DATA_SIZE.checked_sub(4)?)?;
Some(PpcQ3FogStyleData {
state: memory.read_u32_be(data_ptr)?,
mode: memory.read_u32_be(data_ptr.checked_add(4)?)?,
fog_start: ppc_read_f32_be(memory, data_ptr.checked_add(8)?)?,
fog_end: ppc_read_f32_be(memory, data_ptr.checked_add(12)?)?,
density: ppc_read_f32_be(memory, data_ptr.checked_add(16)?)?,
color: (
ppc_read_f32_be(memory, data_ptr.checked_add(20)?)?,
ppc_read_f32_be(memory, data_ptr.checked_add(24)?)?,
ppc_read_f32_be(memory, data_ptr.checked_add(28)?)?,
ppc_read_f32_be(memory, color_b_ptr)?,
),
})
}
fn ppc_q3_fog_style_data_valid(data: PpcQ3FogStyleData) -> bool {
data.state <= 1
&& (PPC_Q3_FOG_MODE_LINEAR..=PPC_Q3_FOG_MODE_ALPHA).contains(&data.mode)
&& data.fog_start.is_finite()
&& data.fog_end.is_finite()
&& data.density.is_finite()
&& data.color.0.is_finite()
&& data.color.1.is_finite()
&& data.color.2.is_finite()
&& data.color.3.is_finite()
}
fn ppc_q3_vector3d_normalize(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vector_ptr: u32,
result_ptr: u32,
) -> u32 {
if result_ptr == 0 || !ppc_memory_can_write_bytes(memory, result_ptr, PPC_Q3_VECTOR3D_SIZE) {
if qd3d_collision_trace_enabled() {
println!(
"[QD3D-COLLISION] Vector3D_Normalize invalid-out lr=${:08X} sp=${:08X} in=${:08X} out=${:08X}",
cpu.lr, cpu.gpr[1], vector_ptr, result_ptr
);
}
return 0;
}
let Some((x, y, z)) = ppc_read_q3_vector3d(memory, vector_ptr) else {
if qd3d_collision_trace_enabled() {
println!(
"[QD3D-COLLISION] Vector3D_Normalize invalid-in lr=${:08X} sp=${:08X} in=${:08X} out=${:08X}",
cpu.lr, cpu.gpr[1], vector_ptr, result_ptr
);
}
return 0;
};
let length = (x.mul_add(x, y.mul_add(y, z * z))).sqrt();
let result = if length > 0.0 {
(x / length, y / length, z / length)
} else {
(0.0, 0.0, 0.0)
};
if ppc_write_q3_vector3d(memory, result_ptr, result).is_some() {
if qd3d_collision_trace_enabled() {
println!(
"[QD3D-COLLISION] Vector3D_Normalize lr=${:08X} sp=${:08X} in=${:08X} out=${:08X} value=({:.6},{:.6},{:.6}) length={:.6} result=({:.6},{:.6},{:.6})",
cpu.lr,
cpu.gpr[1],
vector_ptr,
result_ptr,
x,
y,
z,
length,
result.0,
result.1,
result.2
);
}
result_ptr
} else {
if qd3d_collision_trace_enabled() {
println!(
"[QD3D-COLLISION] Vector3D_Normalize write-failed lr=${:08X} sp=${:08X} in=${:08X} out=${:08X}",
cpu.lr, cpu.gpr[1], vector_ptr, result_ptr
);
}
0
}
}
fn ppc_q3_vector2d_normalize(memory: &mut PpcSectionMem, vector_ptr: u32, result_ptr: u32) -> u32 {
if result_ptr == 0 || !ppc_memory_can_write_bytes(memory, result_ptr, PPC_Q3_VECTOR2D_SIZE) {
return 0;
}
let Some((x, y)) = ppc_read_q3_vector2d(memory, vector_ptr) else {
return 0;
};
let length = (x.mul_add(x, y * y)).sqrt();
let result = if length > 0.0 {
(x / length, y / length)
} else {
(0.0, 0.0)
};
if ppc_write_q3_vector2d(memory, result_ptr, result).is_some() {
result_ptr
} else {
0
}
}
fn ppc_q3_vector3d_cross(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
left_ptr: u32,
right_ptr: u32,
result_ptr: u32,
) -> u32 {
if result_ptr == 0 || !ppc_memory_can_write_bytes(memory, result_ptr, PPC_Q3_VECTOR3D_SIZE) {
if qd3d_collision_trace_enabled() {
println!(
"[QD3D-COLLISION] Vector3D_Cross invalid-out lr=${:08X} sp=${:08X} left=${:08X} right=${:08X} out=${:08X}",
cpu.lr, cpu.gpr[1], left_ptr, right_ptr, result_ptr
);
}
return 0;
}
let Some(left) = ppc_read_q3_vector3d(memory, left_ptr) else {
if qd3d_collision_trace_enabled() {
println!(
"[QD3D-COLLISION] Vector3D_Cross invalid-left lr=${:08X} sp=${:08X} left=${:08X} right=${:08X} out=${:08X}",
cpu.lr, cpu.gpr[1], left_ptr, right_ptr, result_ptr
);
}
return 0;
};
let Some(right) = ppc_read_q3_vector3d(memory, right_ptr) else {
if qd3d_collision_trace_enabled() {
println!(
"[QD3D-COLLISION] Vector3D_Cross invalid-right lr=${:08X} sp=${:08X} left=${:08X} right=${:08X} out=${:08X}",
cpu.lr, cpu.gpr[1], left_ptr, right_ptr, result_ptr
);
}
return 0;
};
let result = ppc_q3_vector3d_cross_values(left, right);
if ppc_write_q3_vector3d(memory, result_ptr, result).is_some() {
if qd3d_collision_trace_enabled() {
println!(
"[QD3D-COLLISION] Vector3D_Cross lr=${:08X} sp=${:08X} left=${:08X} right=${:08X} out=${:08X} left=({:.6},{:.6},{:.6}) right=({:.6},{:.6},{:.6}) result=({:.6},{:.6},{:.6})",
cpu.lr,
cpu.gpr[1],
left_ptr,
right_ptr,
result_ptr,
left.0,
left.1,
left.2,
right.0,
right.1,
right.2,
result.0,
result.1,
result.2
);
}
result_ptr
} else {
if qd3d_collision_trace_enabled() {
println!(
"[QD3D-COLLISION] Vector3D_Cross write-failed lr=${:08X} sp=${:08X} left=${:08X} right=${:08X} out=${:08X}",
cpu.lr, cpu.gpr[1], left_ptr, right_ptr, result_ptr
);
}
0
}
}
fn ppc_q3_point2d_distance(memory: &mut PpcSectionMem, first_ptr: u32, second_ptr: u32) -> f32 {
let Some((x1, y1)) = ppc_read_q3_vector2d(memory, first_ptr) else {
return 0.0;
};
let Some((x2, y2)) = ppc_read_q3_vector2d(memory, second_ptr) else {
return 0.0;
};
let dx = x1 - x2;
let dy = y1 - y2;
(dx.mul_add(dx, dy * dy)).sqrt()
}
fn ppc_q3_point3d_distance(memory: &mut PpcSectionMem, first_ptr: u32, second_ptr: u32) -> f32 {
let Some((x1, y1, z1)) = ppc_read_q3_vector3d(memory, first_ptr) else {
return 0.0;
};
let Some((x2, y2, z2)) = ppc_read_q3_vector3d(memory, second_ptr) else {
return 0.0;
};
let dx = x1 - x2;
let dy = y1 - y2;
let dz = z1 - z2;
(dx.mul_add(dx, dy.mul_add(dy, dz * dz))).sqrt()
}
fn ppc_q3_point3d_cross_product_tri(
memory: &mut PpcSectionMem,
first_ptr: u32,
second_ptr: u32,
third_ptr: u32,
result_ptr: u32,
) -> u32 {
if result_ptr == 0 || !ppc_memory_can_write_bytes(memory, result_ptr, PPC_Q3_VECTOR3D_SIZE) {
return 0;
}
let Some(first) = ppc_read_q3_vector3d(memory, first_ptr) else {
return 0;
};
let Some(second) = ppc_read_q3_vector3d(memory, second_ptr) else {
return 0;
};
let Some(third) = ppc_read_q3_vector3d(memory, third_ptr) else {
return 0;
};
let first_edge = (second.0 - first.0, second.1 - first.1, second.2 - first.2);
let second_edge = (third.0 - first.0, third.1 - first.1, third.2 - first.2);
let result = ppc_q3_vector3d_cross_values(first_edge, second_edge);
if ppc_write_q3_vector3d(memory, result_ptr, result).is_some() {
result_ptr
} else {
0
}
}
fn ppc_q3_matrix3x3_set_translate(
memory: &mut PpcSectionMem,
matrix_ptr: u32,
x: f32,
y: f32,
) -> u32 {
let mut matrix = [[0.0; 3]; 3];
matrix[0][0] = 1.0;
matrix[1][1] = 1.0;
matrix[2][0] = x;
matrix[2][1] = y;
matrix[2][2] = 1.0;
if ppc_write_q3_matrix3x3(memory, matrix_ptr, &matrix).is_some() {
matrix_ptr
} else {
0
}
}
fn ppc_q3_matrix4x4_set_identity(memory: &mut PpcSectionMem, matrix_ptr: u32) -> u32 {
if ppc_write_q3_matrix4x4(memory, matrix_ptr, &ppc_q3_matrix4x4_identity()).is_some() {
matrix_ptr
} else {
0
}
}
fn ppc_q3_matrix4x4_set_translate(
memory: &mut PpcSectionMem,
matrix_ptr: u32,
x: f32,
y: f32,
z: f32,
) -> u32 {
let mut matrix = ppc_q3_matrix4x4_identity();
matrix[3][0] = x;
matrix[3][1] = y;
matrix[3][2] = z;
if ppc_write_q3_matrix4x4(memory, matrix_ptr, &matrix).is_some() {
matrix_ptr
} else {
0
}
}
fn ppc_q3_matrix4x4_set_scale(
memory: &mut PpcSectionMem,
matrix_ptr: u32,
x: f32,
y: f32,
z: f32,
) -> u32 {
let mut matrix = [[0.0; 4]; 4];
matrix[0][0] = x;
matrix[1][1] = y;
matrix[2][2] = z;
matrix[3][3] = 1.0;
if ppc_write_q3_matrix4x4(memory, matrix_ptr, &matrix).is_some() {
matrix_ptr
} else {
0
}
}
fn ppc_q3_matrix4x4_set_rotate_x(memory: &mut PpcSectionMem, matrix_ptr: u32, angle: f32) -> u32 {
let matrix = ppc_q3_matrix4x4_rotate_x(angle);
if ppc_write_q3_matrix4x4(memory, matrix_ptr, &matrix).is_some() {
matrix_ptr
} else {
0
}
}
fn ppc_q3_matrix4x4_set_rotate_y(memory: &mut PpcSectionMem, matrix_ptr: u32, angle: f32) -> u32 {
let matrix = ppc_q3_matrix4x4_rotate_y(angle);
if ppc_write_q3_matrix4x4(memory, matrix_ptr, &matrix).is_some() {
matrix_ptr
} else {
0
}
}
fn ppc_q3_matrix4x4_set_rotate_z(memory: &mut PpcSectionMem, matrix_ptr: u32, angle: f32) -> u32 {
let matrix = ppc_q3_matrix4x4_rotate_z(angle);
if ppc_write_q3_matrix4x4(memory, matrix_ptr, &matrix).is_some() {
matrix_ptr
} else {
0
}
}
fn ppc_q3_matrix4x4_set_rotate_xyz(
memory: &mut PpcSectionMem,
matrix_ptr: u32,
x_angle: f32,
y_angle: f32,
z_angle: f32,
) -> u32 {
let matrix = ppc_q3_matrix4x4_multiply_values(
ppc_q3_matrix4x4_multiply_values(
ppc_q3_matrix4x4_rotate_x(x_angle),
ppc_q3_matrix4x4_rotate_y(y_angle),
),
ppc_q3_matrix4x4_rotate_z(z_angle),
);
if ppc_write_q3_matrix4x4(memory, matrix_ptr, &matrix).is_some() {
matrix_ptr
} else {
0
}
}
fn ppc_q3_matrix4x4_multiply(
memory: &mut PpcSectionMem,
left_ptr: u32,
right_ptr: u32,
result_ptr: u32,
) -> u32 {
let Some(left) = ppc_read_q3_matrix4x4(memory, left_ptr) else {
return 0;
};
let Some(right) = ppc_read_q3_matrix4x4(memory, right_ptr) else {
return 0;
};
let result = ppc_q3_matrix4x4_multiply_values(left, right);
if ppc_write_q3_matrix4x4(memory, result_ptr, &result).is_some() {
result_ptr
} else {
0
}
}
fn ppc_math_dtox80(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> bool {
let Some(hi) = memory.read_u32_be(cpu.gpr[3]) else {
return false;
};
let Some(lo) = memory.read_u32_be(cpu.gpr[3].wrapping_add(4)) else {
return false;
};
let extended = Extended80::from(f64::from_bits((u64::from(hi) << 32) | u64::from(lo)));
let sign_bit = if extended.sign { 0x8000 } else { 0 };
let out = cpu.gpr[4];
// Universal Interfaces fp.h (MathLib 2), `dtox80(const double *, extended80 *)`:
// convert a PowerPC double into the 10-byte big-endian 68K extended format.
memory
.write_u16_be(out, sign_bit | extended.exponent)
.is_some()
&& memory
.write_u16_be(out.wrapping_add(2), (extended.significand >> 48) as u16)
.is_some()
&& memory
.write_u16_be(out.wrapping_add(4), (extended.significand >> 32) as u16)
.is_some()
&& memory
.write_u16_be(out.wrapping_add(6), (extended.significand >> 16) as u16)
.is_some()
&& memory
.write_u16_be(out.wrapping_add(8), extended.significand as u16)
.is_some()
}
fn ppc_virtual_microseconds(
tick_count: u32,
cycles_per_tick: u32,
cycle_phase: u32,
elapsed_cycles: u64,
) -> u64 {
let cycles_per_tick = u64::from(cycles_per_tick.max(1));
let elapsed_cycles = u64::from(cycle_phase).saturating_add(elapsed_cycles);
u64::from(tick_count)
.saturating_mul(PPC_MICROSECONDS_PER_TICK)
.saturating_add(elapsed_cycles.saturating_mul(PPC_MICROSECONDS_PER_TICK) / cycles_per_tick)
}
fn ppc_virtual_tick_count(
tick_count: u32,
cycles_per_tick: u32,
cycle_phase: u32,
elapsed_cycles: u64,
) -> u32 {
// Inside Macintosh: Processes (1993), p. 3-46: TickCount is the low-memory
// time counter maintained by the vertical retrace interrupt. The native
// runner keeps the persisted counter at the start of an execution slice,
// so imports within that slice must include elapsed guest cycles. This is
// especially important when an idle poll is accelerated with extra cycles:
// inventing a caller-local future tick can make two Toolbox clock reads
// disagree and send applications down their fatal startup path.
let cycles_per_tick = u64::from(cycles_per_tick.max(1));
let elapsed_cycles = u64::from(cycle_phase).saturating_add(elapsed_cycles);
tick_count.wrapping_add((elapsed_cycles / cycles_per_tick) as u32)
}
fn ppc_cycles_until_next_tick(cycles_per_tick: u32, cycle_phase: u32, elapsed_cycles: u64) -> u64 {
let cycles_per_tick = u64::from(cycles_per_tick.max(1));
let cycle_phase = u64::from(cycle_phase).saturating_add(elapsed_cycles) % cycles_per_tick;
cycles_per_tick - cycle_phase
}
fn dispatch_simple_hot_import_fast(
target: &PpcImportDispatcherTarget,
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
microseconds: u64,
) -> Option<PpcImportAction> {
match target {
PpcImportDispatcherTarget::Microseconds => {
Some(dispatch_microseconds_import(cpu, memory, microseconds, None))
}
_ => dispatch_math::dispatch_math_import(target, cpu, memory),
}
}
fn ppc_q3_matrix4x4_transpose(memory: &mut PpcSectionMem, matrix_ptr: u32, result_ptr: u32) -> u32 {
let Some(matrix) = ppc_read_q3_matrix4x4(memory, matrix_ptr) else {
return 0;
};
let result = ppc_q3_matrix4x4_transpose_values(matrix);
if ppc_write_q3_matrix4x4(memory, result_ptr, &result).is_some() {
result_ptr
} else {
0
}
}
fn ppc_q3_matrix4x4_invert(memory: &mut PpcSectionMem, matrix_ptr: u32, result_ptr: u32) -> u32 {
let Some(matrix) = ppc_read_q3_matrix4x4(memory, matrix_ptr) else {
return 0;
};
let Some(result) = ppc_q3_matrix4x4_invert_values(matrix) else {
return 0;
};
if ppc_write_q3_matrix4x4(memory, result_ptr, &result).is_some() {
result_ptr
} else {
0
}
}
fn ppc_q3_point3d_transform(
memory: &mut PpcSectionMem,
point_ptr: u32,
matrix_ptr: u32,
result_ptr: u32,
) -> u32 {
let Some(point) = ppc_read_q3_vector3d(memory, point_ptr) else {
return 0;
};
let Some(matrix) = ppc_read_q3_matrix4x4(memory, matrix_ptr) else {
return 0;
};
let result = ppc_q3_point3d_transform_values(point, matrix);
if ppc_write_q3_vector3d(memory, result_ptr, result).is_some() {
result_ptr
} else {
0
}
}
fn ppc_q3_point3d_transform_array(
memory: &mut PpcSectionMem,
in_vertex_ptr: u32,
matrix_ptr: u32,
out_vertex_ptr: u32,
num_vertices: u32,
in_struct_size: u32,
out_struct_size: u32,
output_4d: bool,
) -> bool {
let count = num_vertices as i32;
if count < 0 {
return false;
}
if count == 0 {
return true;
}
let output_size = if output_4d { 16 } else { 12 };
if in_vertex_ptr == 0
|| matrix_ptr == 0
|| out_vertex_ptr == 0
|| in_struct_size < 12
|| out_struct_size < output_size
{
return false;
}
let Some(matrix) = ppc_read_q3_matrix4x4(memory, matrix_ptr) else {
return false;
};
let mut points = Vec::with_capacity(count as usize);
for index in 0..(count as u32) {
let Some(offset) = index.checked_mul(in_struct_size) else {
return false;
};
let Some(point_ptr) = in_vertex_ptr.checked_add(offset) else {
return false;
};
let Some(point) = ppc_read_q3_vector3d(memory, point_ptr) else {
return false;
};
points.push(point);
}
for (index, point) in points.into_iter().enumerate() {
let Some(offset) = (index as u32).checked_mul(out_struct_size) else {
return false;
};
let Some(point_ptr) = out_vertex_ptr.checked_add(offset) else {
return false;
};
if output_4d {
let transformed = ppc_q3_point3d_transform_4d_values(point, matrix);
if ppc_write_q3_rational_point4d(memory, point_ptr, transformed).is_none() {
return false;
}
} else if ppc_write_q3_vector3d(
memory,
point_ptr,
ppc_q3_point3d_transform_values(point, matrix),
)
.is_none()
{
return false;
}
}
true
}
fn ppc_q3_vector3d_transform(
memory: &mut PpcSectionMem,
vector_ptr: u32,
matrix_ptr: u32,
result_ptr: u32,
) -> u32 {
let Some(vector) = ppc_read_q3_vector3d(memory, vector_ptr) else {
return 0;
};
let Some(matrix) = ppc_read_q3_matrix4x4(memory, matrix_ptr) else {
return 0;
};
let result = ppc_q3_vector3d_transform_values(vector, matrix);
if ppc_write_q3_vector3d(memory, result_ptr, result).is_some() {
result_ptr
} else {
0
}
}
fn ppc_q3_matrix_transform_new(
cpu: &PpcCpu,
q3_objects: &mut Vec<PpcQ3ObjectRecord>,
next_q3_object: &mut u32,
) -> u32 {
let matrix_ptr = cpu.gpr[3];
if matrix_ptr == 0 {
return 0;
}
ppc_q3_alloc_object(
q3_objects,
next_q3_object,
PpcQ3ObjectKind::Generic,
PPC_Q3_TRANSFORM_TYPE_MATRIX,
matrix_ptr,
64,
)
}
fn ppc_q3_matrix_transform_set(
cpu: &PpcCpu,
q3_objects: &mut [PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let transform = cpu.gpr[3];
let matrix_ptr = cpu.gpr[4];
if transform == 0 || matrix_ptr == 0 {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
let Some(record) = q3_objects
.iter_mut()
.find(|record| record.object == transform)
else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
};
if record.object_type != PPC_Q3_TRANSFORM_TYPE_MATRIX {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
return false;
}
record.data_ptr = matrix_ptr;
record.data_size = 64;
true
}
fn ppc_q3_validate_transform_handle(
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
transform: u32,
) -> bool {
if ppc_q3_object_type_is_transform(ppc_q3_object_type_for_handle(q3_objects, transform)) {
true
} else {
q3_error_state.post(PPC_Q3_ERROR_INVALID_OBJECT_PARAMETER);
false
}
}
fn ppc_q3_matrix_transform_matrix_ptr(record: &PpcQ3ObjectRecord) -> Option<u32> {
if record.object_type == PPC_Q3_TRANSFORM_TYPE_MATRIX && record.data_size >= 72 {
record.data_ptr.checked_add(8)
} else if record.data_size >= 64 {
Some(record.data_ptr)
} else {
None
}
}
fn ppc_q3_transform_get_matrix(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
q3_objects: &[PpcQ3ObjectRecord],
q3_error_state: &mut PpcQ3ErrorState,
) -> bool {
let transform = cpu.gpr[3];
let matrix_out_ptr = cpu.gpr[4];
if matrix_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, matrix_out_ptr, PPC_Q3_MATRIX4X4_SIZE)
{
return false;
}
if !ppc_q3_validate_transform_handle(q3_objects, q3_error_state, transform) {
return false;
}
let Some(record) = q3_objects.iter().find(|record| record.object == transform) else {
return false;
};
let Some(matrix_ptr) = ppc_q3_matrix_transform_matrix_ptr(record) else {
return false;
};
matrix_ptr != 0 && ppc_q3_copy_or_zero(memory, matrix_ptr, matrix_out_ptr, 64)
}
fn ppc_q3_vector3d_cross_values(left: (f32, f32, f32), right: (f32, f32, f32)) -> (f32, f32, f32) {
(
left.1.mul_add(right.2, -(left.2 * right.1)),
left.2.mul_add(right.0, -(left.0 * right.2)),
left.0.mul_add(right.1, -(left.1 * right.0)),
)
}
fn ppc_q3_vector3d_sub(left: (f32, f32, f32), right: (f32, f32, f32)) -> (f32, f32, f32) {
(left.0 - right.0, left.1 - right.1, left.2 - right.2)
}
fn ppc_q3_vector3d_dot(left: (f32, f32, f32), right: (f32, f32, f32)) -> f32 {
left.0
.mul_add(right.0, left.1.mul_add(right.1, left.2 * right.2))
}
fn ppc_q3_vector3d_normalized_value(vector: (f32, f32, f32)) -> Option<(f32, f32, f32)> {
let length = ppc_q3_vector3d_dot(vector, vector).sqrt();
if !length.is_finite() || length == 0.0 {
return None;
}
Some((vector.0 / length, vector.1 / length, vector.2 / length))
}
fn ppc_read_q3_vector2d(memory: &mut PpcSectionMem, vector_ptr: u32) -> Option<(f32, f32)> {
Some((
ppc_read_f32_be(memory, vector_ptr)?,
ppc_read_f32_be(memory, vector_ptr + 4)?,
))
}
fn ppc_read_q3_vector3d(memory: &mut PpcSectionMem, vector_ptr: u32) -> Option<(f32, f32, f32)> {
Some((
ppc_read_f32_be(memory, vector_ptr)?,
ppc_read_f32_be(memory, vector_ptr + 4)?,
ppc_read_f32_be(memory, vector_ptr + 8)?,
))
}
fn ppc_read_q3_color_rgb(memory: &mut PpcSectionMem, color_ptr: u32) -> Option<(f32, f32, f32)> {
ppc_read_q3_vector3d(memory, color_ptr)
}
fn ppc_write_q3_vector2d(
memory: &mut PpcSectionMem,
vector_ptr: u32,
(x, y): (f32, f32),
) -> Option<()> {
ppc_write_f32_be(memory, vector_ptr, x)?;
ppc_write_f32_be(memory, vector_ptr + 4, y)?;
Some(())
}
fn ppc_write_q3_vector3d(
memory: &mut PpcSectionMem,
vector_ptr: u32,
(x, y, z): (f32, f32, f32),
) -> Option<()> {
ppc_write_f32_be(memory, vector_ptr, x)?;
ppc_write_f32_be(memory, vector_ptr + 4, y)?;
ppc_write_f32_be(memory, vector_ptr + 8, z)?;
Some(())
}
fn ppc_write_q3_area(
memory: &mut PpcSectionMem,
area_ptr: u32,
min_x: f32,
min_y: f32,
max_x: f32,
max_y: f32,
) -> Option<()> {
ppc_write_q3_vector2d(memory, area_ptr, (min_x, min_y))?;
ppc_write_q3_vector2d(memory, area_ptr.checked_add(8)?, (max_x, max_y))?;
Some(())
}
fn ppc_write_q3_color_rgb(
memory: &mut PpcSectionMem,
color_ptr: u32,
color: (f32, f32, f32),
) -> Option<()> {
ppc_write_q3_vector3d(memory, color_ptr, color)
}
fn ppc_write_q3_rational_point4d(
memory: &mut PpcSectionMem,
point_ptr: u32,
(x, y, z, w): (f32, f32, f32, f32),
) -> Option<()> {
ppc_write_f32_be(memory, point_ptr, x)?;
ppc_write_f32_be(memory, point_ptr + 4, y)?;
ppc_write_f32_be(memory, point_ptr + 8, z)?;
ppc_write_f32_be(memory, point_ptr + 12, w)?;
Some(())
}
fn ppc_read_q3_matrix4x4(memory: &mut PpcSectionMem, matrix_ptr: u32) -> Option<[[f32; 4]; 4]> {
let mut matrix = [[0.0; 4]; 4];
for (row, values) in matrix.iter_mut().enumerate() {
for (column, value) in values.iter_mut().enumerate() {
let offset = ((row * 4 + column) * 4) as u32;
*value = ppc_read_f32_be(memory, matrix_ptr.checked_add(offset)?)?;
}
}
Some(matrix)
}
fn ppc_read_q3_matrix3x3(memory: &mut PpcSectionMem, matrix_ptr: u32) -> Option<[[f32; 3]; 3]> {
let mut matrix = [[0.0; 3]; 3];
for (row, values) in matrix.iter_mut().enumerate() {
for (column, value) in values.iter_mut().enumerate() {
let offset = ((row * 3 + column) * 4) as u32;
*value = ppc_read_f32_be(memory, matrix_ptr.checked_add(offset)?)?;
}
}
Some(matrix)
}
fn ppc_write_q3_matrix3x3(
memory: &mut PpcSectionMem,
matrix_ptr: u32,
matrix: &[[f32; 3]; 3],
) -> Option<()> {
for (row, values) in matrix.iter().enumerate() {
for (column, value) in values.iter().enumerate() {
let offset = ((row * 3 + column) * 4) as u32;
ppc_write_f32_be(memory, matrix_ptr.checked_add(offset)?, *value)?;
}
}
Some(())
}
fn ppc_write_q3_matrix4x4(
memory: &mut PpcSectionMem,
matrix_ptr: u32,
matrix: &[[f32; 4]; 4],
) -> Option<()> {
for (row, values) in matrix.iter().enumerate() {
for (column, value) in values.iter().enumerate() {
let offset = ((row * 4 + column) * 4) as u32;
ppc_write_f32_be(memory, matrix_ptr.checked_add(offset)?, *value)?;
}
}
Some(())
}
fn ppc_q3_matrix3x3_identity() -> [[f32; 3]; 3] {
let mut matrix = [[0.0; 3]; 3];
for (index, row) in matrix.iter_mut().enumerate() {
row[index] = 1.0;
}
matrix
}
fn ppc_q3_matrix4x4_rotate_x(angle: f32) -> [[f32; 4]; 4] {
let (sin, cos) = angle.sin_cos();
let mut matrix = ppc_q3_matrix4x4_identity();
matrix[1][1] = cos;
matrix[1][2] = sin;
matrix[2][1] = -sin;
matrix[2][2] = cos;
matrix
}
fn ppc_q3_matrix4x4_rotate_y(angle: f32) -> [[f32; 4]; 4] {
let (sin, cos) = angle.sin_cos();
let mut matrix = ppc_q3_matrix4x4_identity();
matrix[0][0] = cos;
matrix[0][2] = -sin;
matrix[2][0] = sin;
matrix[2][2] = cos;
matrix
}
fn ppc_q3_matrix4x4_rotate_z(angle: f32) -> [[f32; 4]; 4] {
let (sin, cos) = angle.sin_cos();
let mut matrix = ppc_q3_matrix4x4_identity();
matrix[0][0] = cos;
matrix[0][1] = sin;
matrix[1][0] = -sin;
matrix[1][1] = cos;
matrix
}
fn ppc_q3_matrix4x4_multiply_values(left: [[f32; 4]; 4], right: [[f32; 4]; 4]) -> [[f32; 4]; 4] {
let mut result = [[0.0; 4]; 4];
for row in 0..4 {
for column in 0..4 {
result[row][column] = left[row][0].mul_add(
right[0][column],
left[row][1].mul_add(
right[1][column],
left[row][2].mul_add(right[2][column], left[row][3] * right[3][column]),
),
);
}
}
result
}
fn ppc_q3_matrix4x4_transpose_values(matrix: [[f32; 4]; 4]) -> [[f32; 4]; 4] {
let mut result = [[0.0; 4]; 4];
for row in 0..4 {
for column in 0..4 {
result[row][column] = matrix[column][row];
}
}
result
}
fn ppc_q3_point3d_transform_values(
(x, y, z): (f32, f32, f32),
matrix: [[f32; 4]; 4],
) -> (f32, f32, f32) {
let tx = x.mul_add(
matrix[0][0],
y.mul_add(matrix[1][0], z.mul_add(matrix[2][0], matrix[3][0])),
);
let ty = x.mul_add(
matrix[0][1],
y.mul_add(matrix[1][1], z.mul_add(matrix[2][1], matrix[3][1])),
);
let tz = x.mul_add(
matrix[0][2],
y.mul_add(matrix[1][2], z.mul_add(matrix[2][2], matrix[3][2])),
);
let tw = x.mul_add(
matrix[0][3],
y.mul_add(matrix[1][3], z.mul_add(matrix[2][3], matrix[3][3])),
);
if tw != 0.0 && tw != 1.0 {
(tx / tw, ty / tw, tz / tw)
} else {
(tx, ty, tz)
}
}
fn ppc_q3_point3d_transform_4d_values(
(x, y, z): (f32, f32, f32),
matrix: [[f32; 4]; 4],
) -> (f32, f32, f32, f32) {
(
x.mul_add(
matrix[0][0],
y.mul_add(matrix[1][0], z.mul_add(matrix[2][0], matrix[3][0])),
),
x.mul_add(
matrix[0][1],
y.mul_add(matrix[1][1], z.mul_add(matrix[2][1], matrix[3][1])),
),
x.mul_add(
matrix[0][2],
y.mul_add(matrix[1][2], z.mul_add(matrix[2][2], matrix[3][2])),
),
x.mul_add(
matrix[0][3],
y.mul_add(matrix[1][3], z.mul_add(matrix[2][3], matrix[3][3])),
),
)
}
fn ppc_q3_vector3d_transform_values(
(x, y, z): (f32, f32, f32),
matrix: [[f32; 4]; 4],
) -> (f32, f32, f32) {
(
x.mul_add(matrix[0][0], y.mul_add(matrix[1][0], z * matrix[2][0])),
x.mul_add(matrix[0][1], y.mul_add(matrix[1][1], z * matrix[2][1])),
x.mul_add(matrix[0][2], y.mul_add(matrix[1][2], z * matrix[2][2])),
)
}
fn ppc_q3_matrix4x4_invert_values(matrix: [[f32; 4]; 4]) -> Option<[[f32; 4]; 4]> {
let mut augmented = [[0.0f64; 8]; 4];
for row in 0..4 {
for column in 0..4 {
augmented[row][column] = f64::from(matrix[row][column]);
}
augmented[row][4 + row] = 1.0;
}
for pivot_column in 0..4 {
let mut pivot_row = pivot_column;
for candidate in (pivot_column + 1)..4 {
if augmented[candidate][pivot_column].abs() > augmented[pivot_row][pivot_column].abs() {
pivot_row = candidate;
}
}
let pivot = augmented[pivot_row][pivot_column];
if pivot.abs() <= f64::EPSILON {
return None;
}
if pivot_row != pivot_column {
augmented.swap(pivot_row, pivot_column);
}
let pivot = augmented[pivot_column][pivot_column];
for column in 0..8 {
augmented[pivot_column][column] /= pivot;
}
for row in 0..4 {
if row == pivot_column {
continue;
}
let factor = augmented[row][pivot_column];
if factor == 0.0 {
continue;
}
for column in 0..8 {
augmented[row][column] -= factor * augmented[pivot_column][column];
}
}
}
let mut inverse = [[0.0f32; 4]; 4];
for row in 0..4 {
for column in 0..4 {
inverse[row][column] = augmented[row][4 + column] as f32;
}
}
Some(inverse)
}
fn ppc_fpr_as_f32(cpu: &PpcCpu, index: usize) -> f32 {
f64::from_bits(cpu.fpr[index]) as f32
}
fn ppc_read_f32_be(memory: &mut PpcSectionMem, addr: u32) -> Option<f32> {
Some(f32::from_bits(memory.read_u32_be(addr)?))
}
fn ppc_write_f32_be(memory: &mut PpcSectionMem, addr: u32, value: f32) -> Option<()> {
memory.write_u32_be(addr, value.to_bits())
}
pub(super) fn ppc_random(memory: &mut PpcSectionMem) -> u16 {
let old_seed = memory.read_u32_be(PPC_RAND_SEED_ADDR).unwrap_or(1);
let seed = if old_seed == 0 { 1 } else { old_seed };
let new_seed = ((u64::from(seed) * 16_807) % 2_147_483_647) as u32;
let _ = memory.write_u32_be(PPC_RAND_SEED_ADDR, new_seed);
let result = new_seed as u16;
if result == 0x8000 {
0
} else {
result
}
}
fn ppc_string_to_num(cpu: &PpcCpu, memory: &mut PpcSectionMem) {
let string_ptr = cpu.gpr[3];
let number_ptr = cpu.gpr[4];
if string_ptr == 0 || number_ptr == 0 || !ppc_memory_can_write_bytes(memory, number_ptr, 4) {
return;
}
let Some(bytes) = ppc_read_pstring_bytes(memory, string_ptr) else {
return;
};
let mut index = 0usize;
while bytes
.get(index)
.is_some_and(|byte| byte.is_ascii_whitespace())
{
index += 1;
}
let mut sign = 1i64;
if let Some(byte) = bytes.get(index) {
if *byte == b'-' {
sign = -1;
index += 1;
} else if *byte == b'+' {
index += 1;
}
}
let mut value = 0i64;
while let Some(byte) = bytes.get(index) {
if !byte.is_ascii_digit() {
break;
}
value = value
.saturating_mul(10)
.saturating_add(i64::from(byte - b'0'));
index += 1;
}
let signed = value
.saturating_mul(sign)
.clamp(i32::MIN as i64, i32::MAX as i64) as i32;
let _ = memory.write_u32_be(number_ptr, signed as u32);
}
fn ppc_snd_new_channel(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
sound: &mut PpcSoundState,
) -> i16 {
let channel_out_ptr = cpu.gpr[3];
if channel_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, channel_out_ptr, 4) {
return PPC_PARAM_ERR;
}
let synth = cpu.gpr[4] as i16;
if !matches!(
synth,
0 | PPC_SQUARE_WAVE_SYNTH_ID | PPC_WAVE_TABLE_SYNTH_ID | PPC_SAMPLED_SYNTH_ID
) {
return PPC_RES_PROBLEM;
}
let user_routine = cpu.gpr[6];
let existing_channel = memory.read_u32_be(channel_out_ptr).unwrap_or(0);
let allocated = existing_channel == 0;
let (channel, preserved_user_info, q_length) = if existing_channel != 0 {
if !ppc_memory_can_write_bytes(memory, existing_channel, 36) {
return PPC_PARAM_ERR;
}
let Some(preserved_user_info) = memory.read_u32_be(existing_channel + 12) else {
return PPC_PARAM_ERR;
};
let Some(q_length) = memory.read_u16_be(existing_channel + 30) else {
return PPC_PARAM_ERR;
};
(existing_channel, preserved_user_info, q_length.max(1))
} else {
let channel = ppc_process_heap_alloc(
process_memory_manager,
memory,
heap_cursor,
PPC_GUEST_SND_CHANNEL_SIZE,
true,
);
if channel == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return PPC_MEM_FULL_ERR;
}
(channel, 0, 128)
};
let writes_ok = memory.write_u32_be(channel, 0).is_some()
&& memory.write_u32_be(channel + 4, 0).is_some()
&& memory.write_u32_be(channel + 8, user_routine).is_some()
&& memory
.write_u32_be(channel + 12, preserved_user_info)
.is_some()
&& memory.write_u32_be(channel + 16, 0).is_some()
&& memory.write_u32_be(channel + 20, 0).is_some()
&& memory.write_u32_be(channel + 24, 0).is_some()
&& memory.write_u16_be(channel + 28, 0).is_some()
&& memory.write_u16_be(channel + 30, q_length).is_some()
&& memory.write_u16_be(channel + 32, 0).is_some()
&& memory.write_u16_be(channel + 34, 0).is_some()
&& memory.write_u32_be(channel_out_ptr, channel).is_some();
if !writes_ok {
return PPC_PARAM_ERR;
}
*last_mem_error = PPC_NO_ERR;
sound.manager.register_channel(
channel,
allocated,
user_routine,
CallbackTaskArchitecture::PowerPc,
);
if ppc_sound_trace_enabled() {
eprintln!(
"[PPC-SOUND] SndNewChannel chan=${channel:08X} synth={synth} init=${:08X} user_routine=${user_routine:08X}",
cpu.gpr[5]
);
}
PPC_NO_ERR
}
fn ppc_snd_channel_status(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
sound: &PpcSoundState,
) -> i16 {
let channel = cpu.gpr[3];
let byte_count = cpu.gpr[4];
let status_ptr = cpu.gpr[5];
if byte_count > 0
&& (status_ptr == 0 || !ppc_memory_can_write_bytes(memory, status_ptr, byte_count))
{
return PPC_PARAM_ERR;
}
for offset in 0..byte_count {
let Some(addr) = status_ptr.checked_add(offset) else {
return PPC_PARAM_ERR;
};
if memory.write_u8(addr, 0).is_none() {
return PPC_PARAM_ERR;
}
}
if let Some(busy) = sound.manager.channel_busy(channel) {
if byte_count > 12 && memory.write_u8(status_ptr + 12, u8::from(busy)).is_none() {
return PPC_PARAM_ERR;
}
if byte_count > 14
&& memory
.write_u8(
status_ptr + 14,
u8::from(sound.manager.file_playback_paused(channel).unwrap_or(false)),
)
.is_none()
{
return PPC_PARAM_ERR;
}
}
PPC_NO_ERR
}
fn ppc_snd_get_info(cpu: &PpcCpu, memory: &mut PpcSectionMem, sound: &PpcSoundState) -> i16 {
const SI_UNKNOWN_INFO_TYPE: i16 = -231;
let channel = cpu.gpr[3];
let selector = cpu.gpr[4];
let info_ptr = cpu.gpr[5];
if channel == 0 || info_ptr == 0 {
return PPC_PARAM_ERR;
}
// Universal Interfaces 3.4.1 Sound.h identifies SndGetInfo as a Sound
// Manager 3.1 SoundLib call. These scalar selectors describe the native
// HLE mixer's canonical mono, 8-bit, 22.254 kHz channel. Unknown queries
// return the documented siUnknownInfoType instead of fabricating data.
let result = match &selector.to_be_bytes() {
b"srat" => memory.write_u32_be(info_ptr, crate::sound::RATE_22KHZ_FIXED),
b"ssiz" => memory.write_u16_be(info_ptr, 8),
b"chan" => memory.write_u16_be(info_ptr, 1),
b"hwbs" => {
memory.write_u8(
info_ptr,
u8::from(sound.manager.channel_busy(channel).unwrap_or(false)),
)
}
_ => return SI_UNKNOWN_INFO_TYPE,
};
if result.is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcParsedSndHeader {
format: u32,
num_channels: u16,
sample_size: u16,
sample_rate: u32,
sample_count: u32,
buffer: u32,
num_frames: u32,
data_offset: u32,
}
fn ppc_parse_snd_header(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
) -> i16 {
let handle = cpu.gpr[3];
let info_ptr = cpu.gpr[4];
let num_frames_ptr = cpu.gpr[5];
let data_offset_ptr = cpu.gpr[6];
if info_ptr == 0
|| num_frames_ptr == 0
|| data_offset_ptr == 0
|| !ppc_memory_can_write_bytes(memory, info_ptr, 28)
|| !ppc_memory_can_write_bytes(memory, num_frames_ptr, 4)
|| !ppc_memory_can_write_bytes(memory, data_offset_ptr, 4)
{
return PPC_PARAM_ERR;
}
let Some(record) = handles.iter().find(|record| record.handle == handle) else {
return PPC_PARAM_ERR;
};
let Some(resource_ptr) = memory.read_u32_be(handle) else {
return PPC_PARAM_ERR;
};
if resource_ptr == 0 || resource_ptr != record.ptr {
return PPC_PARAM_ERR;
}
let Some(header_offset) = ppc_sound_header_offset(memory, resource_ptr) else {
return PPC_BAD_FORMAT;
};
let Some(parsed) = ppc_parse_snd_header_fields(memory, resource_ptr, header_offset) else {
return PPC_BAD_FORMAT;
};
let writes = [
memory.write_u32_be(info_ptr, 0),
memory.write_u32_be(info_ptr + 4, parsed.format),
memory.write_u16_be(info_ptr + 8, parsed.num_channels),
memory.write_u16_be(info_ptr + 10, parsed.sample_size),
memory.write_u32_be(info_ptr + 12, parsed.sample_rate),
memory.write_u32_be(info_ptr + 16, parsed.sample_count),
memory.write_u32_be(info_ptr + 20, parsed.buffer),
memory.write_u32_be(info_ptr + 24, 0),
memory.write_u32_be(num_frames_ptr, parsed.num_frames),
memory.write_u32_be(data_offset_ptr, parsed.data_offset),
];
if writes.iter().all(Option::is_some) {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
}
}
/// Parse the sampled-sound header embedded in a format-1 or format-2 `snd `
/// resource. Sound Manager 3.0's ParseSndHeader reports a SoundComponentData
/// record plus the frame count and resource-relative start of the sample data.
fn ppc_parse_snd_header_fields(
memory: &mut PpcSectionMem,
resource_ptr: u32,
header_offset: u32,
) -> Option<PpcParsedSndHeader> {
const STD_SH: u8 = 0x00;
const CMP_SH: u8 = 0xfe;
const EXT_SH: u8 = 0xff;
const RAW_FORMAT: u32 = u32::from_be_bytes(*b"raw ");
const TWOS_FORMAT: u32 = u32::from_be_bytes(*b"twos");
let header = resource_ptr.checked_add(header_offset)?;
let sample_ptr = memory.read_u32_be(header)?;
let sample_rate = memory.read_u32_be(header.checked_add(8)?)?;
let encode = memory.read_u8(header.checked_add(20)?)?;
let (format, num_channels, sample_size, sample_count, num_frames, inline_offset) = match encode
{
STD_SH => {
let length = memory.read_u32_be(header.checked_add(4)?)?;
(RAW_FORMAT, 1, 8, length, length, 22)
}
EXT_SH => {
let channels = memory.read_u32_be(header.checked_add(4)?)?;
let channels = u16::try_from(channels).ok()?;
let frames = memory.read_u32_be(header.checked_add(22)?)?;
let sample_size = memory.read_u16_be(header.checked_add(48)?)?;
let format = match sample_size {
8 => RAW_FORMAT,
16 => TWOS_FORMAT,
_ => return None,
};
(format, channels, sample_size, frames, frames, 64)
}
CMP_SH => {
let channels = memory.read_u32_be(header.checked_add(4)?)?;
let channels = u16::try_from(channels).ok()?;
let frames = memory.read_u32_be(header.checked_add(22)?)?;
let format = memory.read_u32_be(header.checked_add(40)?)?;
let sample_size = memory.read_u16_be(header.checked_add(62)?)?;
(format, channels, sample_size, frames, frames, 64)
}
_ => return None,
};
let inline_data = header.checked_add(inline_offset)?;
let buffer = if sample_ptr == 0 {
inline_data
} else {
sample_ptr
};
let data_offset = if sample_ptr == 0 {
header_offset.checked_add(inline_offset)?
} else {
sample_ptr.checked_sub(resource_ptr).unwrap_or(0)
};
Some(PpcParsedSndHeader {
format,
num_channels,
sample_size,
sample_rate,
sample_count,
buffer,
num_frames,
data_offset,
})
}
fn ppc_snd_do_immediate(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
sound: &mut PpcSoundState,
) -> i16 {
let channel = cpu.gpr[3];
let cmd_ptr = cpu.gpr[4];
let Some(command) = ppc_read_snd_command(memory, cmd_ptr) else {
return PPC_PARAM_ERR;
};
if command.command == crate::sound::cmd::GET_RATE && command.param2 != 0 {
if !ppc_memory_can_write_bytes(memory, command.param2, 4)
|| memory
.write_u32_be(
command.param2,
sound
.manager
.channel_rate(channel)
.unwrap_or(0x0001_0000),
)
.is_none()
{
return PPC_PARAM_ERR;
}
}
if let Some(decoded) = ppc_decode_buffer_command(memory, channel, command) {
sound.manager.play_buffer_command_for_architecture(
channel,
decoded.samples,
decoded.sample_rate_fixed,
CallbackTaskArchitecture::PowerPc,
);
} else {
sound.manager.execute_immediate_command(
channel,
crate::sound::SndCommand {
cmd: command.command,
param1: command.param1,
param2: command.param2,
},
);
}
sound
.immediate_commands
.push(PpcSndCommandRecord { channel, ..command });
PPC_NO_ERR
}
fn ppc_snd_do_command(cpu: &PpcCpu, memory: &mut PpcSectionMem, sound: &mut PpcSoundState) -> i16 {
let channel = cpu.gpr[3];
let Some(command) = ppc_read_snd_command(memory, cpu.gpr[4]) else {
return PPC_PARAM_ERR;
};
if ppc_sound_trace_enabled() {
eprintln!(
"[PPC-SOUND] SndDoCommand chan=${channel:08X} cmd={} param1={} param2=${:08X} noWait={}",
command.command, command.param1, command.param2, cpu.gpr[5] != 0
);
}
// Inside Macintosh: Sound (1994), pp. 2-130–2-131: SndDoCommand appends
// the eight-byte SndCommand to the channel's FIFO queue. A callbackCmd
// following sampled sound runs only when that sound has completed, with
// a copy of the queued command as the callback's second argument. The
// process manager retains the command and selects the native callback ABI
// from the channel created by SndNewChannel; it is not a file-play
// completion routine.
// `noWait` controls whether the classic implementation may sleep until
// a FIFO slot opens. The host runner cannot block the guest, so both
// variants return queueFull when the process-owned FIFO is full.
if let Some(decoded) = ppc_decode_buffer_command(memory, channel, command) {
if !sound.manager.enqueue_buffer_command_for_architecture(
channel,
decoded.samples,
decoded.sample_rate_fixed,
CallbackTaskArchitecture::PowerPc,
) {
return -203; // queueFull
}
} else {
if !sound.manager.enqueue_command(
channel,
crate::sound::SndCommand {
cmd: command.command,
param1: command.param1,
param2: command.param2,
},
) {
return -203; // queueFull
}
}
sound
.queued_commands
.push(PpcSndCommandRecord { channel, ..command });
PPC_NO_ERR
}
fn ppc_snd_dispose_channel(cpu: &mut PpcCpu, sound: &mut PpcSoundState) -> i16 {
let channel = cpu.gpr[3];
sound.manager.remove_channel(channel);
sound
.decoded_file_playbacks
.retain(|record| record.channel != channel);
sound.file_playbacks.retain(|record| record.channel != channel);
PPC_NO_ERR
}
fn ppc_snd_play(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
sound: &mut PpcSoundState,
) -> i16 {
const RES_PROBLEM: i16 = -204;
const BAD_FORMAT: i16 = -206;
let channel = cpu.gpr[3];
let sound_handle = cpu.gpr[4];
let async_play = cpu.gpr[5] != 0;
if sound_handle == 0 || memory.read_u32_be(sound_handle).unwrap_or(0) == 0 {
return RES_PROBLEM;
}
let Some(bytes) = ppc_handle_bytes(memory, handles, sound_handle) else {
return RES_PROBLEM;
};
let Some(commands) = ppc_decode_snd_resource_commands(&bytes) else {
return BAD_FORMAT;
};
let effective_channel = if channel == 0 {
// Sound 1994, p. 2-122: NIL ignores async and uses an internal
// channel for the duration of the sampled playback.
sound.manager.create_internal_channel()
} else {
channel
};
if ppc_sound_trace_enabled() {
eprintln!(
"[PPC-SOUND] SndPlay chan=${channel:08X} effective=${effective_channel:08X} handle=${sound_handle:08X} async={} commands={}",
async_play,
commands.len()
);
}
// Inside Macintosh: Sound (1994), pp. 2-121--2-123: preserve every
// resource command in order. An idle first buffer can start immediately;
// commands after it (and all commands on a busy channel) remain in the
// process-owned FIFO until the current buffer completes.
for command in commands {
match command {
PpcDecodedSndResourceCommand::Buffer {
samples,
sample_rate_fixed,
} => {
let busy = sound.manager.channel_busy(effective_channel).unwrap_or(false);
let queued = sound
.manager
.channel_has_queued_commands(effective_channel)
.unwrap_or(false);
if busy || queued {
if !sound.manager.enqueue_buffer_command_for_architecture(
effective_channel,
samples,
sample_rate_fixed,
CallbackTaskArchitecture::PowerPc,
) {
return -203; // queueFull
}
} else {
sound.manager.play_buffer_command_for_architecture(
effective_channel,
samples,
sample_rate_fixed,
CallbackTaskArchitecture::PowerPc,
);
}
}
PpcDecodedSndResourceCommand::Command(command) => {
let busy = sound.manager.channel_busy(effective_channel).unwrap_or(false);
let queued = sound
.manager
.channel_has_queued_commands(effective_channel)
.unwrap_or(false);
if busy || queued || command.cmd == crate::sound::cmd::CALLBACK {
if !sound.manager.enqueue_command(effective_channel, command) {
return -203; // queueFull
}
} else {
sound
.manager
.execute_immediate_command(effective_channel, command);
}
}
}
}
PPC_NO_ERR
}
fn ppc_decode_buffer_command(
memory: &mut PpcSectionMem,
channel: u32,
command: PpcSndCommandRecord,
) -> Option<PpcDecodedBufferCommandRecord> {
const BUFFER_CMD: u16 = 81;
if command.command != BUFFER_CMD || command.param2 == 0 {
return None;
}
let Some(decoded) = ppc_decode_snd_header_from_memory(memory, command.param2) else {
if ppc_sound_trace_enabled() {
eprintln!(
"[PPC-SOUND] could not decode bufferCmd header=${:08X}",
command.param2
);
}
return None;
};
Some(PpcDecodedBufferCommandRecord {
channel,
sample_rate_fixed: decoded.summary.sample_rate_fixed,
samples: decoded.samples,
})
}
/// Decode a Sound Manager SoundHeader referenced by bufferCmd.
///
/// Inside Macintosh: Sound (1994), pp. 2-104, 2-106, and 2-109 define the
/// standard, extended, and compressed headers. A non-NIL samplePtr addresses
/// the samples independently of the header; otherwise sampleArea follows the
/// fixed header. Extended PCM is interleaved and 8- or 16-bit, while the
/// compressed form identifies MACE through compressionID/format.
fn ppc_decode_snd_header_from_memory(
memory: &mut PpcSectionMem,
header_addr: u32,
) -> Option<PpcDecodedAiffData> {
const STD_SH: u8 = 0x00;
const CMP_SH: u8 = 0xfe;
const EXT_SH: u8 = 0xff;
const MACE3_FORMAT: u32 = u32::from_be_bytes(*b"MAC3");
const MACE6_FORMAT: u32 = u32::from_be_bytes(*b"MAC6");
const MAX_RETAINED_SAMPLE_BYTES: u32 = 64 * 1024 * 1024;
let sample_ptr = memory.read_u32_be(header_addr)?;
let sample_rate_fixed = memory.read_u32_be(header_addr.checked_add(8)?)?;
let encode = memory.read_u8(header_addr.checked_add(20)?)?;
let samples = match encode {
STD_SH => {
let length = memory.read_u32_be(header_addr.checked_add(4)?)?;
if length > MAX_RETAINED_SAMPLE_BYTES {
return None;
}
let data_addr = if sample_ptr != 0 {
sample_ptr
} else {
header_addr.checked_add(22)?
};
ppc_memory_read_bytes(memory, data_addr, length)?
}
EXT_SH => {
let channels =
usize::try_from(memory.read_u32_be(header_addr.checked_add(4)?)?).ok()?;
let frames = usize::try_from(memory.read_u32_be(header_addr.checked_add(22)?)?).ok()?;
let sample_size = usize::from(memory.read_u16_be(header_addr.checked_add(48)?)?);
let bytes_per_sample = match sample_size {
8 => 1usize,
16 => 2usize,
_ => return None,
};
let byte_count = frames
.checked_mul(channels)?
.checked_mul(bytes_per_sample)?;
let byte_count = u32::try_from(byte_count).ok()?;
if byte_count > MAX_RETAINED_SAMPLE_BYTES {
return None;
}
let data_addr = if sample_ptr != 0 {
sample_ptr
} else {
header_addr.checked_add(64)?
};
let raw = ppc_memory_read_bytes(memory, data_addr, byte_count)?;
ppc_decode_interleaved_pcm_samples(&raw, 0, frames, channels, sample_size)?
}
CMP_SH => {
let channels =
usize::try_from(memory.read_u32_be(header_addr.checked_add(4)?)?).ok()?;
let frames = usize::try_from(memory.read_u32_be(header_addr.checked_add(22)?)?).ok()?;
let compression_format = memory.read_u32_be(header_addr.checked_add(40)?)?;
let compression_id = memory.read_u16_be(header_addr.checked_add(56)?)? as i16;
let packet_size = usize::from(memory.read_u16_be(header_addr.checked_add(58)?)?);
let sample_size = usize::from(memory.read_u16_be(header_addr.checked_add(62)?)?);
if channels != 1 || sample_size != 8 {
return None;
}
let (packet_bits, decode): (usize, fn(&[u8]) -> Vec<u8>) =
match (compression_id, compression_format) {
(3, _) | (-1, MACE3_FORMAT) => (16, crate::trap::decode_mace3_mono_to_u8),
(4, _) | (-1, MACE6_FORMAT) => (8, crate::trap::decode_mace6_mono_to_u8),
_ => return None,
};
let packet_size = if packet_size == 0 {
packet_bits
} else {
packet_size
};
if packet_size != packet_bits {
return None;
}
let byte_count = frames.checked_mul(packet_bits / 8)?;
let byte_count = u32::try_from(byte_count).ok()?;
if byte_count > MAX_RETAINED_SAMPLE_BYTES {
return None;
}
let data_addr = if sample_ptr != 0 {
sample_ptr
} else {
header_addr.checked_add(64)?
};
let compressed = ppc_memory_read_bytes(memory, data_addr, byte_count)?;
decode(&compressed)
}
_ => return None,
};
ppc_decoded_sound_data(samples, sample_rate_fixed)
}
fn ppc_snd_play_double_buffer(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
sound: &mut PpcSoundState,
) -> i16 {
let channel = cpu.gpr[3];
let header = cpu.gpr[4];
if channel == 0 || header == 0 || !ppc_memory_can_write_bytes(memory, header, 24) {
return PPC_PARAM_ERR;
}
let buffer0 = memory.read_u32_be(header + 12).unwrap_or(0);
let buffer1 = memory.read_u32_be(header + 16).unwrap_or(0);
let callback = memory.read_u32_be(header + 20).unwrap_or(0);
let num_channels = memory.read_u16_be(header).unwrap_or(0);
let sample_size = memory.read_u16_be(header + 2).unwrap_or(0);
let compression_id = memory.read_u16_be(header + 4).unwrap_or(0) as i16;
let packet_size = memory.read_u16_be(header + 6).unwrap_or(0);
let raw_sample_rate = memory.read_u32_be(header + 8).unwrap_or(0);
let sample_rate_fixed = if raw_sample_rate == 0 {
crate::sound::RATE_22KHZ_FIXED
} else {
raw_sample_rate
};
if ppc_sound_trace_enabled() {
eprintln!(
"[PPC-SOUND] SndPlayDoubleBuffer chan=${:08X} header=${:08X} channels={} bits={} rate=${:08X} buf0=${:08X} buf1=${:08X} callback=${:08X}",
channel,
header,
num_channels,
sample_size,
sample_rate_fixed,
buffer0,
buffer1,
callback
);
}
sound.manager.stop_double_buffer_playbacks(channel);
let mut playback = PpcSoundDoubleBufferPlaybackRecord {
channel,
header,
buffers: [buffer0, buffer1],
callback,
callback_architecture: CallbackTaskArchitecture::PowerPc,
sample_rate_fixed,
num_channels,
sample_size,
compression_id,
packet_size,
current_buffer_index: 0,
callback_pending_mask: 0,
active: true,
host_initialized: false,
host_buffer_loaded: false,
};
sound.manager.note_double_buffer_submission();
playback.host_initialized = true;
if let Some(samples) = ppc_decode_ready_double_buffer(memory, playback) {
sound
.manager
.play_double_buffer_samples(channel, samples, sample_rate_fixed);
playback.host_buffer_loaded = true;
}
sound
.manager
.with_mut(|manager| manager.double_buffer_playbacks.push(playback));
sound.double_buffer_play_count = sound.double_buffer_play_count.saturating_add(1);
sound.last_double_buffer_channel = channel;
sound.last_double_buffer_header = header;
PPC_NO_ERR
}
fn ppc_decode_ready_double_buffer(
memory: &mut PpcSectionMem,
playback: PpcSoundDoubleBufferPlaybackRecord,
) -> Option<Vec<crate::sound::StereoSample>> {
const MAX_RETAINED_SAMPLE_BYTES: usize = 64 * 1024 * 1024;
if playback.compression_id != 0 {
return None;
}
let buffer_ptr = playback.buffers[usize::from(playback.current_buffer_index & 1)];
if buffer_ptr == 0 {
return None;
}
let num_frames = usize::try_from(memory.read_u32_be(buffer_ptr)?).ok()?;
let flags = memory.read_u32_be(buffer_ptr.checked_add(4)?)?;
if flags & 0x01 == 0 || num_frames == 0 {
return None;
}
let num_channels = usize::from(playback.num_channels);
let sample_size = usize::from(playback.sample_size);
let bytes_per_sample = match sample_size {
8 => 1usize,
16 => 2usize,
_ => return None,
};
let byte_count = num_frames
.checked_mul(num_channels)?
.checked_mul(bytes_per_sample)?;
if byte_count > MAX_RETAINED_SAMPLE_BYTES {
return None;
}
let mut raw = vec![0; byte_count];
memory.read_bytes_into(buffer_ptr.checked_add(16)?, &mut raw)?;
crate::trap::decode_interleaved_stereo_samples(
&raw,
num_frames,
num_channels,
sample_size,
)
}
fn ppc_read_snd_command(memory: &mut PpcSectionMem, cmd_ptr: u32) -> Option<PpcSndCommandRecord> {
Some(PpcSndCommandRecord {
channel: 0,
command: memory.read_u16_be(cmd_ptr)?,
param1: memory.read_u16_be(cmd_ptr + 2)? as i16,
param2: memory.read_u32_be(cmd_ptr + 4)?,
})
}
fn ppc_snd_start_file_play(
cpu: &mut PpcCpu,
files: &[PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
sound: &mut PpcSoundState,
) -> i16 {
let channel = cpu.gpr[3];
let ref_num = cpu.gpr[4] as u16 as i16;
let resource_id = cpu.gpr[5] as u16 as i16;
let file_playback_index = u32::try_from(sound.file_playbacks.len()).ok();
let (aiff, decoded_sound) = if ref_num == 0 && resource_id != 0 {
(
None,
ppc_snd_resource_playback_for_id(resource_id, vfs_resources, current_resource_refnum),
)
} else {
ppc_aiff_playback_for_refnum(ref_num, files, vfs_files)
};
let decoded_aiff_summary = decoded_sound.as_ref().map(|decoded| decoded.summary);
let record = PpcSoundFilePlaybackRecord {
channel,
ref_num,
resource_id,
buffer_size: cpu.gpr[6],
buffer: cpu.gpr[7],
selection: cpu.gpr[8],
completion: cpu.gpr[9],
completion_command: None,
async_play: cpu.gpr[10] != 0,
aiff,
decoded_aiff: decoded_aiff_summary,
};
let completion = Some((
CallbackTaskArchitecture::PowerPc,
if record.async_play {
record.completion
} else {
0
},
));
if let Some(decoded_sound) = decoded_sound {
sound.manager.play_file_buffer(
channel,
decoded_sound.samples.clone(),
decoded_sound.summary.sample_rate_fixed,
completion,
);
if let Some(file_playback_index) = file_playback_index {
sound
.decoded_file_playbacks
.push(PpcDecodedAiffPlaybackRecord {
file_playback_index,
channel,
sample_rate_fixed: decoded_sound.summary.sample_rate_fixed,
samples: decoded_sound.samples,
});
}
} else {
sound.manager.play_file_buffer(
channel,
Vec::new(),
crate::sound::OUTPUT_RATE << 16,
completion,
);
}
sound.file_playbacks.push(record);
sound.start_count = sound.start_count.saturating_add(1);
PPC_NO_ERR
}
fn ppc_aiff_playback_for_refnum(
ref_num: i16,
files: &[PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
) -> (Option<PpcAiffMetadata>, Option<PpcDecodedAiffData>) {
let path = files
.iter()
.find(|file| file.ref_num == ref_num)
.map(|file| file.path.as_str());
let Some(path) = path else {
return (None, None);
};
let data = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(path))
.map(|file| file.data.as_slice());
let Some(data) = data else {
return (None, None);
};
(ppc_parse_aiff_metadata(data), ppc_decode_aiff_samples(data))
}
fn ppc_snd_resource_playback_for_id(
resource_id: i16,
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> Option<PpcDecodedAiffData> {
let index = ppc_vfs_resource_index(
vfs_resources,
current_resource_refnum,
u32::from_be_bytes(*b"snd "),
resource_id,
false,
)?;
ppc_decode_snd_resource_samples(&vfs_resources[index].data)
}
fn ppc_decode_aiff_samples(data: &[u8]) -> Option<PpcDecodedAiffData> {
let (samples, sample_rate_fixed) = crate::trap::parse_aiff_samples(data)?;
ppc_decoded_sound_data(samples, sample_rate_fixed)
}
#[derive(Debug)]
enum PpcDecodedSndResourceCommand {
Command(crate::sound::SndCommand),
Buffer {
samples: Vec<u8>,
sample_rate_fixed: u32,
},
}
fn ppc_decode_snd_resource_commands(
data: &[u8],
) -> Option<Vec<PpcDecodedSndResourceCommand>> {
const SOUND_CMD: u16 = 80;
const BUFFER_CMD: u16 = 81;
const DATA_OFFSET_FLAG: u16 = 0x8000;
let format = ppc_read_be_u16_from_slice(data, 0)?;
let mut command_offset = match format {
1 => {
let synth_count = usize::from(ppc_read_be_u16_from_slice(data, 2)?);
4usize.checked_add(synth_count.checked_mul(6)?)?
}
2 => 4,
_ => return None,
};
let command_count = usize::from(ppc_read_be_u16_from_slice(data, command_offset)?);
command_offset = command_offset.checked_add(2)?;
let commands_end = command_offset.checked_add(command_count.checked_mul(8)?)?;
if commands_end > data.len() {
return None;
}
let mut commands = Vec::with_capacity(command_count);
let mut has_buffer = false;
for index in 0..command_count {
let command_ptr = command_offset.checked_add(index.checked_mul(8)?)?;
let raw_command = ppc_read_be_u16_from_slice(data, command_ptr)?;
let mut command = raw_command & !DATA_OFFSET_FLAG;
let param1 = ppc_read_be_u16_from_slice(data, command_ptr.checked_add(2)?)? as i16;
let parameter = ppc_read_be_u32_from_slice(data, command_ptr.checked_add(4)?)?;
let has_data_offset = (raw_command & DATA_OFFSET_FLAG) != 0;
if format == 2 && index == 0 && command == SOUND_CMD {
command = BUFFER_CMD;
}
if has_data_offset && (command == BUFFER_CMD || command == SOUND_CMD) {
let mut header_offset = parameter as usize;
if format == 2
&& index == 0
&& command == BUFFER_CMD
&& header_offset == commands_end.checked_add(6)?
{
header_offset = commands_end;
}
let decoded = ppc_decode_snd_header_at(data, header_offset)?;
has_buffer = true;
commands.push(PpcDecodedSndResourceCommand::Buffer {
samples: decoded.samples,
sample_rate_fixed: decoded.summary.sample_rate_fixed,
});
} else {
commands.push(PpcDecodedSndResourceCommand::Command(
crate::sound::SndCommand {
cmd: command,
param1,
param2: parameter,
},
));
}
}
has_buffer.then_some(commands)
}
fn ppc_decode_snd_resource_samples(data: &[u8]) -> Option<PpcDecodedAiffData> {
ppc_decode_snd_resource_commands(data)?.into_iter().find_map(|command| {
let PpcDecodedSndResourceCommand::Buffer {
samples,
sample_rate_fixed,
} = command
else {
return None;
};
ppc_decoded_sound_data(samples, sample_rate_fixed)
})
}
fn ppc_decode_snd_header_at(data: &[u8], header_offset: usize) -> Option<PpcDecodedAiffData> {
const STD_SH: u8 = 0x00;
const CMP_SH: u8 = 0xfe;
const EXT_SH: u8 = 0xff;
const MACE3_FORMAT: u32 = u32::from_be_bytes(*b"MAC3");
const MACE6_FORMAT: u32 = u32::from_be_bytes(*b"MAC6");
let sample_ptr = ppc_read_be_u32_from_slice(data, header_offset)? as usize;
let sample_rate_fixed = ppc_read_be_u32_from_slice(data, header_offset.checked_add(8)?)?;
let encode = *data.get(header_offset.checked_add(20)?)?;
let samples = match encode {
STD_SH => {
let length = ppc_read_be_u32_from_slice(data, header_offset.checked_add(4)?)? as usize;
let data_start = if sample_ptr != 0 && sample_ptr < data.len() {
sample_ptr
} else {
header_offset.checked_add(22)?
};
data.get(data_start..data_start.checked_add(length)?)?
.to_vec()
}
EXT_SH => {
let channels =
ppc_read_be_u32_from_slice(data, header_offset.checked_add(4)?)? as usize;
let frames = ppc_read_be_u32_from_slice(data, header_offset.checked_add(22)?)? as usize;
let sample_size = usize::from(ppc_read_be_u16_from_slice(
data,
header_offset.checked_add(48)?,
)?);
let data_start = if sample_ptr != 0 && sample_ptr < data.len() {
sample_ptr
} else {
header_offset.checked_add(64)?
};
ppc_decode_interleaved_pcm_samples(data, data_start, frames, channels, sample_size)?
}
CMP_SH => {
let channels =
ppc_read_be_u32_from_slice(data, header_offset.checked_add(4)?)? as usize;
let frames = ppc_read_be_u32_from_slice(data, header_offset.checked_add(22)?)? as usize;
let compression_format =
ppc_read_be_u32_from_slice(data, header_offset.checked_add(40)?)?;
let compression_id =
ppc_read_be_u16_from_slice(data, header_offset.checked_add(56)?)? as i16;
let packet_size = usize::from(ppc_read_be_u16_from_slice(
data,
header_offset.checked_add(58)?,
)?);
let sample_size = usize::from(ppc_read_be_u16_from_slice(
data,
header_offset.checked_add(62)?,
)?);
if channels != 1 || sample_size != 8 {
return None;
}
let (packet_bits, decode): (usize, fn(&[u8]) -> Vec<u8>) =
match (compression_id, compression_format) {
(3, _) | (-1, MACE3_FORMAT) => (16, crate::trap::decode_mace3_mono_to_u8),
(4, _) | (-1, MACE6_FORMAT) => (8, crate::trap::decode_mace6_mono_to_u8),
_ => return None,
};
let packet_size = if packet_size == 0 {
packet_bits
} else {
packet_size
};
if packet_size != packet_bits {
return None;
}
let data_start = if sample_ptr != 0 && sample_ptr < data.len() {
sample_ptr
} else {
header_offset.checked_add(64)?
};
let byte_count = frames.checked_mul(packet_bits / 8)?;
let compressed = data.get(data_start..data_start.checked_add(byte_count)?)?;
decode(compressed)
}
_ => return None,
};
ppc_decoded_sound_data(samples, sample_rate_fixed)
}
fn ppc_decode_interleaved_pcm_samples(
data: &[u8],
data_start: usize,
frames: usize,
channels: usize,
sample_size: usize,
) -> Option<Vec<u8>> {
if frames == 0 || channels == 0 {
return Some(Vec::new());
}
let bytes_per_sample = sample_size / 8;
if bytes_per_sample == 0 {
return None;
}
let frame_bytes = channels.checked_mul(bytes_per_sample)?;
let byte_count = frames.checked_mul(frame_bytes)?;
let raw = data.get(data_start..data_start.checked_add(byte_count)?)?;
let mut samples = Vec::with_capacity(frames);
for frame in 0..frames {
let mut accum = 0i32;
let frame_start = frame.checked_mul(frame_bytes)?;
for channel in 0..channels {
let offset = frame_start.checked_add(channel.checked_mul(bytes_per_sample)?)?;
let sample = match sample_size {
8 => raw[offset] as i32 - 128,
16 => i16::from_be_bytes([raw[offset], raw[offset + 1]]) as i32 >> 8,
_ => return None,
};
accum += sample;
}
samples.push((accum / channels as i32 + 128).clamp(0, 255) as u8);
}
Some(samples)
}
fn ppc_decoded_sound_data(samples: Vec<u8>, sample_rate_fixed: u32) -> Option<PpcDecodedAiffData> {
let sample_count = u32::try_from(samples.len()).ok()?;
let preview_len = samples.len().min(16);
let mut preview = [0; 16];
preview[..preview_len].copy_from_slice(&samples[..preview_len]);
Some(PpcDecodedAiffData {
summary: PpcDecodedAiffSamples {
sample_rate_fixed,
sample_count,
preview_len: preview_len as u8,
preview,
},
samples,
})
}
struct PpcDecodedAiffData {
summary: PpcDecodedAiffSamples,
samples: Vec<u8>,
}
fn ppc_parse_aiff_metadata(data: &[u8]) -> Option<PpcAiffMetadata> {
const FORM: u32 = u32::from_be_bytes(*b"FORM");
const AIFF: u32 = u32::from_be_bytes(*b"AIFF");
const AIFC: u32 = u32::from_be_bytes(*b"AIFC");
const COMM: u32 = u32::from_be_bytes(*b"COMM");
const SSND: u32 = u32::from_be_bytes(*b"SSND");
const NONE: u32 = u32::from_be_bytes(*b"NONE");
if ppc_read_be_u32_from_slice(data, 0)? != FORM {
return None;
}
let form_size = ppc_read_be_u32_from_slice(data, 4)? as usize;
let form_type = ppc_read_be_u32_from_slice(data, 8)?;
if form_type != AIFF && form_type != AIFC {
return None;
}
let form_end = 8usize.checked_add(form_size)?.min(data.len());
let mut offset = 12usize;
let mut channel_count = None;
let mut sample_frame_count = None;
let mut sample_size = None;
let mut sample_rate_hz = None;
let mut compression_type = if form_type == AIFF { Some(NONE) } else { None };
let mut sound_data_offset = None;
let mut sound_data_size = None;
while offset.checked_add(8)? <= form_end {
let chunk_id = ppc_read_be_u32_from_slice(data, offset)?;
let chunk_size = ppc_read_be_u32_from_slice(data, offset + 4)? as usize;
let chunk_data = offset.checked_add(8)?;
let chunk_end = chunk_data.checked_add(chunk_size)?;
if chunk_end > data.len() {
return None;
}
match chunk_id {
COMM if chunk_size >= 18 => {
channel_count = Some(ppc_read_be_u16_from_slice(data, chunk_data)?);
sample_frame_count = Some(ppc_read_be_u32_from_slice(data, chunk_data + 2)?);
sample_size = Some(ppc_read_be_u16_from_slice(data, chunk_data + 6)?);
sample_rate_hz = Some(ppc_read_extended_sample_rate(data, chunk_data + 8)?);
if form_type == AIFC && chunk_size >= 22 {
compression_type = Some(ppc_read_be_u32_from_slice(data, chunk_data + 18)?);
}
}
SSND if chunk_size >= 8 => {
let offset_to_sound = ppc_read_be_u32_from_slice(data, chunk_data)? as usize;
let data_start = chunk_data.checked_add(8)?.checked_add(offset_to_sound)?;
if data_start > chunk_end {
return None;
}
sound_data_offset = Some(u32::try_from(data_start).ok()?);
sound_data_size = Some(u32::try_from(chunk_end - data_start).ok()?);
}
_ => {}
}
offset = chunk_end.checked_add(chunk_size & 1)?;
}
Some(PpcAiffMetadata {
form_type,
channel_count: channel_count?,
sample_frame_count: sample_frame_count?,
sample_size: sample_size?,
sample_rate_hz: sample_rate_hz?,
compression_type: compression_type?,
sound_data_offset: sound_data_offset?,
sound_data_size: sound_data_size?,
})
}
fn ppc_read_be_u16_from_slice(data: &[u8], offset: usize) -> Option<u16> {
Some(u16::from_be_bytes([
*data.get(offset)?,
*data.get(offset.checked_add(1)?)?,
]))
}
fn ppc_read_be_u32_from_slice(data: &[u8], offset: usize) -> Option<u32> {
Some(u32::from_be_bytes([
*data.get(offset)?,
*data.get(offset.checked_add(1)?)?,
*data.get(offset.checked_add(2)?)?,
*data.get(offset.checked_add(3)?)?,
]))
}
fn ppc_read_extended_sample_rate(data: &[u8], offset: usize) -> Option<u32> {
let exponent = ppc_read_be_u16_from_slice(data, offset)?;
let sign = exponent & 0x8000 != 0;
let exponent = i32::from(exponent & 0x7fff);
if sign || exponent == 0 {
return Some(0);
}
let mut mantissa = 0u64;
for byte_offset in 0..8usize {
mantissa = (mantissa << 8) | u64::from(*data.get(offset.checked_add(2 + byte_offset)?)?);
}
let value = (mantissa as f64) * 2f64.powi(exponent - 16383 - 63);
Some(value.round().clamp(0.0, f64::from(u32::MAX)) as u32)
}
fn ppc_snd_pause_file_play(cpu: &mut PpcCpu, sound: &mut PpcSoundState) -> i16 {
let channel = cpu.gpr[3];
sound.pause_count = sound.pause_count.saturating_add(1);
sound.manager.toggle_file_paused(channel);
PPC_NO_ERR
}
fn ppc_snd_stop_file_play(cpu: &mut PpcCpu, sound: &mut PpcSoundState) -> i16 {
let channel = cpu.gpr[3];
let _quiet_now = cpu.gpr[4] != 0;
sound.stop_count = sound.stop_count.saturating_add(1);
sound.manager.quiet_channel(channel);
PPC_NO_ERR
}
fn ppc_get_sound_header_offset(cpu: &mut PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let handle = cpu.gpr[3];
let offset_ptr = cpu.gpr[4];
if offset_ptr == 0 || !ppc_memory_can_write_bytes(memory, offset_ptr, 4) {
return PPC_PARAM_ERR;
}
let Some(resource_ptr) = memory.read_u32_be(handle) else {
let _ = memory.write_u32_be(offset_ptr, 0);
return PPC_PARAM_ERR;
};
match ppc_sound_header_offset(memory, resource_ptr) {
Some(offset) if memory.write_u32_be(offset_ptr, offset).is_some() => PPC_NO_ERR,
Some(_) => PPC_PARAM_ERR,
None => {
let _ = memory.write_u32_be(offset_ptr, 0);
PPC_BAD_FORMAT
}
}
}
fn ppc_sound_header_offset(memory: &mut PpcSectionMem, resource_ptr: u32) -> Option<u32> {
const PPC_SOUND_CMD_SOUND: u16 = 80;
const PPC_SOUND_CMD_BUFFER: u16 = 81;
const PPC_SOUND_DATA_OFFSET_FLAG: u16 = 0x8000;
let format = memory.read_u16_be(resource_ptr)?;
let mut command_offset = match format {
1 => {
let synth_count = memory.read_u16_be(resource_ptr + 2)? as u32;
4u32.checked_add(synth_count.checked_mul(6)?)?
}
2 => 4,
_ => return None,
};
let command_count = memory.read_u16_be(resource_ptr.checked_add(command_offset)?)? as u32;
command_offset = command_offset.checked_add(2)?;
for index in 0..command_count {
let cmd_offset = command_offset.checked_add(index.checked_mul(8)?)?;
let cmd = memory.read_u16_be(resource_ptr.checked_add(cmd_offset)?)?;
if cmd == (PPC_SOUND_CMD_SOUND | PPC_SOUND_DATA_OFFSET_FLAG)
|| cmd == (PPC_SOUND_CMD_BUFFER | PPC_SOUND_DATA_OFFSET_FLAG)
{
return memory.read_u32_be(resource_ptr.checked_add(cmd_offset.checked_add(4)?)?);
}
}
None
}
fn ppc_qt_record_error(quicktime: &mut PpcQuickTimeState, error: i16) -> i16 {
quicktime.movie_error = error;
if error != PPC_NO_ERR && quicktime.movie_sticky_error == PPC_NO_ERR {
quicktime.movie_sticky_error = error;
}
error
}
fn ppc_qt_enter_movies(quicktime: &mut PpcQuickTimeState) -> i16 {
quicktime.movie_toolbox_enter_count = quicktime.movie_toolbox_enter_count.saturating_add(1);
quicktime.movie_toolbox_init_depth = quicktime.movie_toolbox_init_depth.saturating_add(1);
ppc_qt_record_error(quicktime, PPC_NO_ERR)
}
fn ppc_qt_exit_movies(quicktime: &mut PpcQuickTimeState) {
quicktime.movie_toolbox_exit_count = quicktime.movie_toolbox_exit_count.saturating_add(1);
quicktime.movie_toolbox_init_depth = quicktime.movie_toolbox_init_depth.saturating_sub(1);
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
}
fn ppc_qt_get_movies_error(quicktime: &mut PpcQuickTimeState) -> i16 {
let error = quicktime.movie_error;
quicktime.movie_error = PPC_NO_ERR;
error
}
fn ppc_qt_get_movies_sticky_error(quicktime: &mut PpcQuickTimeState) -> i16 {
let error = quicktime.movie_sticky_error;
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
error
}
fn ppc_qt_clear_movies_sticky_error(quicktime: &mut PpcQuickTimeState) {
quicktime.movie_sticky_error = PPC_NO_ERR;
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
}
fn ppc_qt_clear_graphics_importer(quicktime: &mut PpcQuickTimeState) {
quicktime.graphics_importer_open = false;
quicktime.graphics_importer_gworld = 0;
quicktime.graphics_importer_gdevice = 0;
quicktime.graphics_importer_path.clear();
quicktime.graphics_importer_data.clear();
quicktime.graphics_importer_bounds = None;
}
fn ppc_close_component(cpu: &mut PpcCpu, quicktime: &mut PpcQuickTimeState) -> i16 {
if cpu.gpr[3] == PPC_QT_GRAPHICS_IMPORTER && quicktime.graphics_importer_open {
ppc_qt_clear_graphics_importer(quicktime);
PPC_NO_ERR
} else {
PPC_INVALID_COMPONENT_ID
}
}
fn ppc_qt_get_graphics_importer_for_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
quicktime: &mut PpcQuickTimeState,
) -> i16 {
let spec_ptr = cpu.gpr[3];
let importer_out_ptr = cpu.gpr[4];
if importer_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, importer_out_ptr, 4) {
return PPC_PARAM_ERR;
}
if memory
.write_u32_be(importer_out_ptr, PPC_QT_GRAPHICS_IMPORTER)
.is_none()
{
return PPC_PARAM_ERR;
}
ppc_qt_clear_graphics_importer(quicktime);
quicktime.graphics_importer_open = true;
if spec_ptr == 0 {
return PPC_NO_ERR;
}
let Ok(path) = ppc_existing_path_for_fsspec(memory, vfs_directories, vfs_files, &[], spec_ptr)
else {
return PPC_NO_ERR;
};
let Some(file) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&path))
else {
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GetGraphicsImporterForFile path='{}' missing",
path
);
}
return PPC_NO_ERR;
};
quicktime.graphics_importer_path = path;
quicktime.graphics_importer_data = file.data.to_vec();
quicktime.graphics_importer_bounds = ppc_qt_pict_bounds(&quicktime.graphics_importer_data);
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GetGraphicsImporterForFile path='{}' data_len={} bounds={:?}",
quicktime.graphics_importer_path,
quicktime.graphics_importer_data.len(),
quicktime.graphics_importer_bounds
);
}
PPC_NO_ERR
}
fn ppc_qt_graphics_import_get_bounds_rect(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
quicktime: &PpcQuickTimeState,
) -> i16 {
let bounds_ptr = cpu.gpr[4];
if cpu.gpr[3] != PPC_QT_GRAPHICS_IMPORTER
|| !quicktime.graphics_importer_open
|| bounds_ptr == 0
{
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, bounds_ptr, 8) {
return PPC_PARAM_ERR;
}
let (top, left, bottom, right) = quicktime.graphics_importer_bounds.unwrap_or((
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
));
if ppc_write_rect(memory, bounds_ptr, top, left, bottom, right).is_none() {
PPC_PARAM_ERR
} else {
PPC_NO_ERR
}
}
fn ppc_qt_graphics_import_set_gworld(cpu: &mut PpcCpu, quicktime: &mut PpcQuickTimeState) -> i16 {
if cpu.gpr[3] != PPC_QT_GRAPHICS_IMPORTER || !quicktime.graphics_importer_open {
return PPC_PARAM_ERR;
}
quicktime.graphics_importer_gworld = cpu.gpr[4];
quicktime.graphics_importer_gdevice = cpu.gpr[5];
PPC_NO_ERR
}
fn ppc_qt_graphics_import_draw(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_GRAPHICS_IMPORTER || !quicktime.graphics_importer_open {
return PPC_PARAM_ERR;
}
let gworld = if quicktime.graphics_importer_gworld != 0 {
quicktime.graphics_importer_gworld
} else {
current_gworld
};
let Some(front_buffer) = ppc_live_front_buffer_for_gworld(memory, gworlds, gworld) else {
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GraphicsImportDraw path='{}' gworld=${:08X} result=paramErr no-front-buffer",
quicktime.graphics_importer_path, gworld
);
}
return PPC_PARAM_ERR;
};
quicktime.graphics_import_draw_count = quicktime.graphics_import_draw_count.saturating_add(1);
let source_drawn =
ppc_qt_draw_pict_source_to_16bpp(memory, front_buffer, &quicktime.graphics_importer_data);
if source_drawn {
quicktime.graphics_import_source_draw_count = quicktime
.graphics_import_source_draw_count
.saturating_add(1);
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GraphicsImportDraw path='{}' gworld=${:08X} data_len={} source=true fallback=false draw_count={} source_count={}",
quicktime.graphics_importer_path,
gworld,
quicktime.graphics_importer_data.len(),
quicktime.graphics_import_draw_count,
quicktime.graphics_import_source_draw_count
);
}
return PPC_NO_ERR;
}
let fallback_drawn = ppc_qt_draw_visible_16bpp_frame(
memory,
front_buffer,
0x10u32.saturating_add(quicktime.graphics_import_draw_count),
);
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GraphicsImportDraw path='{}' gworld=${:08X} data_len={} source=false fallback={} draw_count={} source_count={}",
quicktime.graphics_importer_path,
gworld,
quicktime.graphics_importer_data.len(),
fallback_drawn,
quicktime.graphics_import_draw_count,
quicktime.graphics_import_source_draw_count
);
}
if fallback_drawn {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
}
}
fn ppc_qt_pict_record_offset_and_bounds(data: &[u8]) -> Option<(usize, (i16, i16, i16, i16))> {
[0usize, 512usize].into_iter().find_map(|offset| {
let header = data.get(offset..offset.checked_add(10)?)?;
let top = i16::from_be_bytes(header.get(2..4)?.try_into().ok()?);
let left = i16::from_be_bytes(header.get(4..6)?.try_into().ok()?);
let bottom = i16::from_be_bytes(header.get(6..8)?.try_into().ok()?);
let right = i16::from_be_bytes(header.get(8..10)?.try_into().ok()?);
let width = i32::from(right) - i32::from(left);
let height = i32::from(bottom) - i32::from(top);
(width > 0 && height > 0 && width <= 8192 && height <= 8192)
.then_some((offset, (top, left, bottom, right)))
})
}
fn ppc_qt_pict_bounds(data: &[u8]) -> Option<(i16, i16, i16, i16)> {
ppc_qt_pict_record_offset_and_bounds(data).map(|(_, bounds)| bounds)
}
fn ppc_rgb555_to_rgb16(pixel: u16) -> [u16; 3] {
fn component(value: u16) -> u16 {
(((u32::from(value) * 65_535) + 15) / 31) as u16
}
[
component((pixel >> 10) & 0x1f),
component((pixel >> 5) & 0x1f),
component(pixel & 0x1f),
]
}
fn ppc_rgb555_to_clut_index(pixel: u16, clut: &[[u16; 3]; 256]) -> u8 {
let [red, green, blue] = ppc_rgb555_to_rgb16(pixel & 0x7fff);
pict::closest_clut_index(red, green, blue, clut)
}
fn ppc_draw_raw_quilt_frame(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
data: &[u8],
pict_bounds: (i16, i16, i16, i16),
dst_rect: (i16, i16, i16, i16),
clut: &[[u16; 3]; 256],
zero_is_opaque: bool,
) -> bool {
if data.len() < 24 || data[10..24].iter().any(|byte| *byte != 0) {
return false;
}
let (src_top, src_left, src_bottom, src_right) = pict_bounds;
let src_width = i32::from(src_right) - i32::from(src_left);
let src_height = i32::from(src_bottom) - i32::from(src_top);
if src_width <= 0 || src_height <= 0 {
return false;
}
let raw = &data[24..];
let Ok(src_height_usize) = usize::try_from(src_height) else {
return false;
};
if src_height_usize == 0 || raw.len() % src_height_usize != 0 {
return false;
}
let src_row_bytes = raw.len() / src_height_usize;
let Ok(src_width_usize) = usize::try_from(src_width) else {
return false;
};
if src_row_bytes < src_width_usize {
return false;
}
let (dst_top, dst_left, dst_bottom, dst_right) = dst_rect;
let dst_width = i32::from(dst_right) - i32::from(dst_left);
let dst_height = i32::from(dst_bottom) - i32::from(dst_top);
if dst_width <= 0 || dst_height <= 0 {
return false;
}
let copy_top = i32::from(dst_top).max(0).min(front_buffer.height as i32);
let copy_bottom = i32::from(dst_bottom).max(0).min(front_buffer.height as i32);
let copy_left = i32::from(dst_left).max(0).min(front_buffer.width as i32);
let copy_right = i32::from(dst_right).max(0).min(front_buffer.width as i32);
if copy_bottom <= copy_top || copy_right <= copy_left {
return false;
}
for y in copy_top..copy_bottom {
let src_y =
((y - i32::from(dst_top)) * src_height / dst_height).clamp(0, src_height - 1) as usize;
for x in copy_left..copy_right {
let src_x = ((x - i32::from(dst_left)) * src_width / dst_width).clamp(0, src_width - 1)
as usize;
let Some(mut color_index) = raw
.get(src_y.saturating_mul(src_row_bytes).saturating_add(src_x))
.copied()
else {
continue;
};
if zero_is_opaque && color_index == 0 {
color_index = pict::closest_clut_index(0, 0, 0, clut);
}
if front_buffer.depth == 8 {
let Some(dst_addr) = front_buffer
.base_addr
.checked_add((y as u32).saturating_mul(front_buffer.row_bytes))
.and_then(|row| row.checked_add(x as u32))
else {
continue;
};
let _ = memory.write_u8(dst_addr, color_index);
} else if front_buffer.depth == 16 {
let [red, green, blue] = clut[color_index as usize];
let pixel = ppc_q3_rgb555((
f32::from(red) / 65_535.0,
f32::from(green) / 65_535.0,
f32::from(blue) / 65_535.0,
));
let _ = ppc_q3_write_software_pixel(memory, front_buffer, (x, y), pixel);
} else {
return false;
}
}
}
true
}
pub(super) fn ppc_draw_pict_bytes_to_16bpp(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
data: &[u8],
dst_rect: (i16, i16, i16, i16),
clut: &[[u16; 3]; 256],
device_ct_seed: u32,
quilt_zero_is_opaque: bool,
) -> bool {
if front_buffer.base_addr == 0 || front_buffer.width == 0 || front_buffer.height == 0 {
return false;
}
let Some((pict_offset, bounds)) = ppc_qt_pict_record_offset_and_bounds(data) else {
return false;
};
let (dst_top, dst_left, dst_bottom, dst_right) = dst_rect;
if dst_bottom <= dst_top || dst_right <= dst_left {
return false;
}
let Ok(width) = u16::try_from(front_buffer.width) else {
return false;
};
let Ok(height) = u16::try_from(front_buffer.height) else {
return false;
};
if pict_offset == 0
&& ppc_draw_raw_quilt_frame(
memory,
front_buffer,
data,
bounds,
dst_rect,
clut,
quilt_zero_is_opaque,
)
{
return true;
}
if matches!(front_buffer.depth, 1 | 2 | 4 | 8) {
let Some(minimum_row_bytes) = front_buffer
.width
.checked_mul(front_buffer.depth)
.and_then(|bits| bits.checked_add(7))
.map(|bits| bits / 8)
else {
return false;
};
if front_buffer.row_bytes < minimum_row_bytes {
return false;
}
let row_bytes = front_buffer.row_bytes;
let Some(buffer_len) = row_bytes.checked_mul(front_buffer.height) else {
return false;
};
let Some(buffer_len_usize) = usize::try_from(buffer_len).ok() else {
return false;
};
let pict_base = 0x0001_0000u32;
let Some(pict_end) = pict_base.checked_add(u32::try_from(data.len()).unwrap_or(u32::MAX))
else {
return false;
};
let screen_base = (pict_end.saturating_add(0x0fff)) & !0x0fffu32;
let Some(screen_end) = screen_base.checked_add(buffer_len) else {
return false;
};
let Some(ram_size) = usize::try_from(screen_end.saturating_add(0x1000)).ok() else {
return false;
};
if ram_size > 128 * 1024 * 1024 {
return false;
}
let mut indexed = vec![0u8; buffer_len_usize];
for y in 0..front_buffer.height {
let Some(src_addr) = front_buffer
.base_addr
.checked_add(y.saturating_mul(front_buffer.row_bytes))
else {
return false;
};
let Some(dst_offset) = usize::try_from(y.saturating_mul(row_bytes)).ok() else {
return false;
};
let Some(row_len) = usize::try_from(row_bytes).ok() else {
return false;
};
if memory
.read_bytes_into(src_addr, &mut indexed[dst_offset..dst_offset + row_len])
.is_none()
{
return false;
}
}
// Color QuickDraw matches colors only against pixel values the
// destination PixMap can represent. A short 1/2/4-bit CTable is
// overlaid on the logical 8-bit table, so hide that inherited tail
// from the PICT renderer; otherwise a color can match (for example)
// index 42 and then be truncated to the low one or two packed bits.
// This is the same depth-limiting rule used by the 68K DrawPicture
// path. Imaging With QuickDraw (1994), pp. 4-81--4-83 and 7-44--7-45.
let packed_clut = matches!(front_buffer.depth, 1 | 2 | 4).then(|| {
let mut packed_clut = *clut;
let entry_count = 1usize << front_buffer.depth;
let terminal = packed_clut[entry_count - 1];
packed_clut[entry_count..].fill(terminal);
packed_clut
});
let draw_clut = packed_clut.as_ref().unwrap_or(clut);
let mut bus = MacMemoryBus::new(ram_size);
bus.write_bytes(pict_base, data);
bus.write_bytes(screen_base, &indexed);
bus.begin_uncapped_write_probe();
let (rendered, _) = pict::draw_picture(
&mut bus,
pict_base + u32::try_from(pict_offset).unwrap_or(0),
dst_top,
dst_left,
dst_bottom,
dst_right,
(
screen_base,
row_bytes,
width,
height,
front_buffer.depth as u16,
),
draw_clut,
device_ct_seed,
None,
);
if !rendered {
return false;
}
return ppc_commit_picture_writes(memory, &mut bus, screen_base, front_buffer, buffer_len);
}
if front_buffer.depth != 16 || front_buffer.row_bytes < front_buffer.width.saturating_mul(2) {
return false;
}
let row_bytes = front_buffer.row_bytes;
let Some(buffer_len) = row_bytes.checked_mul(front_buffer.height) else {
return false;
};
let Some(buffer_len_usize) = usize::try_from(buffer_len).ok() else {
return false;
};
let pict_base = 0x0001_0000u32;
let Some(pict_end) = pict_base.checked_add(u32::try_from(data.len()).unwrap_or(u32::MAX))
else {
return false;
};
let screen_base = (pict_end.saturating_add(0x0fff)) & !0x0fffu32;
let Some(screen_end) = screen_base.checked_add(buffer_len) else {
return false;
};
let Some(ram_size) = usize::try_from(screen_end.saturating_add(0x1000)).ok() else {
return false;
};
if ram_size > 128 * 1024 * 1024 {
return false;
}
let mut direct = vec![0u8; buffer_len_usize];
for y in 0..front_buffer.height {
let Some(src_addr) = front_buffer
.base_addr
.checked_add(y.saturating_mul(front_buffer.row_bytes))
else {
return false;
};
let Some(dst_offset) = usize::try_from(y.saturating_mul(row_bytes)).ok() else {
return false;
};
let Some(row_len) = usize::try_from(row_bytes).ok() else {
return false;
};
if memory
.read_bytes_into(src_addr, &mut direct[dst_offset..dst_offset + row_len])
.is_none()
{
return false;
}
}
let mut bus = MacMemoryBus::new(ram_size);
bus.write_bytes(pict_base, data);
bus.write_bytes(screen_base, &direct);
bus.begin_uncapped_write_probe();
let (rendered, _) = pict::draw_picture(
&mut bus,
pict_base + u32::try_from(pict_offset).unwrap_or(0),
dst_top,
dst_left,
dst_bottom,
dst_right,
(screen_base, row_bytes, width, height, 16),
clut,
device_ct_seed,
None,
);
if !rendered {
return false;
}
ppc_commit_picture_writes(memory, &mut bus, screen_base, front_buffer, buffer_len)
}
fn ppc_commit_picture_writes(
memory: &mut PpcSectionMem,
bus: &mut MacMemoryBus,
screen_base: u32,
front_buffer: PpcFrontBuffer,
buffer_len: u32,
) -> bool {
// DrawPicture scales the picture into dstRect; its drawing operations can
// extend beyond the picture frame. Copy the actual writes, not a rectangle
// or a logical-pixel diff. Imaging With QuickDraw (1994), pp. 7-44--7-45.
for range in bus.finish_write_probe_ranges() {
let start = range.start.max(screen_base);
let end = range.end.min(screen_base + buffer_len);
if start < end {
let bytes = bus.read_bytes(start, (end - start) as usize);
if memory
.write_bytes(front_buffer.base_addr + start - screen_base, &bytes)
.is_none()
{
return false;
}
}
}
true
}
fn ppc_qt_movie_bounds(data: &[u8]) -> Option<(i16, i16, i16, i16)> {
ppc_qt_scan_movie_bounds(data, 0, data.len(), 0)
}
fn ppc_qt_movie_duration(data: &[u8]) -> Option<(u32, u64)> {
ppc_qt_scan_movie_duration(data, 0, data.len(), 0)
}
fn ppc_qt_movie_first_video_track(data: &[u8]) -> Option<PpcQuickTimeVideoTrackRecord> {
ppc_qt_scan_movie_video_track(data, 0, data.len(), 0)
}
fn ppc_qt_movie_video_samples(data: &[u8]) -> Option<PpcQuickTimeVideoSampleTableRecord> {
ppc_qt_scan_movie_video_samples(data, 0, data.len(), 0)
}
fn ppc_qt_movie_first_audio_track(data: &[u8]) -> Option<PpcQuickTimeAudioTrackRecord> {
ppc_qt_scan_movie_audio_track(data, 0, data.len(), 0)
}
fn ppc_qt_atom_range(data: &[u8], offset: usize, end: usize) -> Option<(&[u8], usize, usize)> {
if offset.checked_add(8)? > end || end > data.len() {
return None;
}
let size = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
let atom_type = data.get(offset + 4..offset + 8)?;
let (content_start, atom_end) = if size == 1 {
let extended_size = u64::from_be_bytes(data.get(offset + 8..offset + 16)?.try_into().ok()?);
let extended_size = usize::try_from(extended_size).ok()?;
if extended_size < 16 {
return None;
}
(offset + 16, offset.checked_add(extended_size)?)
} else if size == 0 {
(offset + 8, end)
} else {
let size = usize::try_from(size).ok()?;
if size < 8 {
return None;
}
(offset + 8, offset.checked_add(size)?)
};
if atom_end > end || content_start > atom_end {
return None;
}
Some((atom_type, content_start, atom_end))
}
fn ppc_qt_scan_movie_bounds(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<(i16, i16, i16, i16)> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
let mut bounds = None;
while offset.checked_add(8)? <= end {
let size = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
let atom_type = data.get(offset + 4..offset + 8)?;
let (content_start, atom_end) = if size == 1 {
let extended_size =
u64::from_be_bytes(data.get(offset + 8..offset + 16)?.try_into().ok()?);
let extended_size = usize::try_from(extended_size).ok()?;
if extended_size < 16 {
return bounds;
}
(offset + 16, offset.checked_add(extended_size)?)
} else if size == 0 {
(offset + 8, end)
} else {
let size = usize::try_from(size).ok()?;
if size < 8 {
return bounds;
}
(offset + 8, offset.checked_add(size)?)
};
if atom_end > end || content_start > atom_end {
return bounds;
}
if atom_type == b"tkhd" {
bounds = ppc_qt_union_bounds(bounds, ppc_qt_tkhd_bounds(data, content_start, atom_end));
} else if ppc_qt_is_container_atom(atom_type) {
bounds = ppc_qt_union_bounds(
bounds,
ppc_qt_scan_movie_bounds(data, content_start, atom_end, depth + 1),
);
}
if atom_end == end {
break;
}
offset = atom_end;
}
bounds
}
fn ppc_qt_scan_movie_duration(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<(u32, u64)> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let size = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
let atom_type = data.get(offset + 4..offset + 8)?;
let (content_start, atom_end) = if size == 1 {
let extended_size =
u64::from_be_bytes(data.get(offset + 8..offset + 16)?.try_into().ok()?);
let extended_size = usize::try_from(extended_size).ok()?;
if extended_size < 16 {
return None;
}
(offset + 16, offset.checked_add(extended_size)?)
} else if size == 0 {
(offset + 8, end)
} else {
let size = usize::try_from(size).ok()?;
if size < 8 {
return None;
}
(offset + 8, offset.checked_add(size)?)
};
if atom_end > end || content_start > atom_end {
return None;
}
if atom_type == b"mvhd" {
if let Some(duration) = ppc_qt_mvhd_duration(data, content_start, atom_end) {
return Some(duration);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(duration) =
ppc_qt_scan_movie_duration(data, content_start, atom_end, depth + 1)
{
return Some(duration);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
#[derive(Default)]
struct PpcQuickTimeTrackSampleInfo {
handler_subtype: u32,
media_time_scale: u32,
media_duration: u64,
sample_count: u32,
first_sample_duration: u32,
first_sample_size: u32,
first_chunk_offset: u64,
first_samples_per_chunk: u32,
sample_description_id: u32,
codec: u32,
audio_channel_count: u16,
audio_sample_size_bits: u16,
audio_sample_rate_fixed: u32,
}
impl PpcQuickTimeTrackSampleInfo {
fn is_complete_for(&self, handler_subtype: u32) -> bool {
self.handler_subtype == handler_subtype
&& self.media_time_scale != 0
&& self.media_duration != 0
&& self.sample_count != 0
&& self.first_sample_duration != 0
&& self.first_sample_size != 0
&& self.first_samples_per_chunk != 0
&& self.sample_description_id != 0
&& self.codec != 0
}
fn into_video_track(self, data: &[u8]) -> Option<PpcQuickTimeVideoTrackRecord> {
if !self.is_complete_for(u32::from_be_bytes(*b"vide")) {
return None;
}
let (
first_sample_data_len,
first_sample_checksum,
first_sample_preview_len,
first_sample_preview,
) = ppc_qt_sample_payload_summary(data, self.first_chunk_offset, self.first_sample_size);
Some(PpcQuickTimeVideoTrackRecord {
media_time_scale: self.media_time_scale,
media_duration: self.media_duration,
sample_count: self.sample_count,
first_sample_duration: self.first_sample_duration,
first_sample_size: self.first_sample_size,
first_chunk_offset: self.first_chunk_offset,
first_sample_data_len,
first_sample_checksum,
first_sample_preview_len,
first_sample_preview,
first_samples_per_chunk: self.first_samples_per_chunk,
sample_description_id: self.sample_description_id,
codec: self.codec,
})
}
fn into_audio_track(self, data: &[u8]) -> Option<PpcQuickTimeAudioTrackRecord> {
if !self.is_complete_for(u32::from_be_bytes(*b"soun"))
|| self.audio_channel_count == 0
|| self.audio_sample_size_bits == 0
|| self.audio_sample_rate_fixed == 0
{
return None;
}
let (
first_sample_data_len,
first_sample_checksum,
first_sample_preview_len,
first_sample_preview,
) = ppc_qt_sample_payload_summary(data, self.first_chunk_offset, self.first_sample_size);
Some(PpcQuickTimeAudioTrackRecord {
media_time_scale: self.media_time_scale,
media_duration: self.media_duration,
sample_count: self.sample_count,
first_sample_duration: self.first_sample_duration,
first_sample_size: self.first_sample_size,
first_chunk_offset: self.first_chunk_offset,
first_sample_data_len,
first_sample_checksum,
first_sample_preview_len,
first_sample_preview,
first_samples_per_chunk: self.first_samples_per_chunk,
sample_description_id: self.sample_description_id,
codec: self.codec,
channel_count: self.audio_channel_count,
sample_size_bits: self.audio_sample_size_bits,
sample_rate_fixed: self.audio_sample_rate_fixed,
})
}
}
#[derive(Default)]
struct PpcQuickTimeAudioDecodeInfo {
handler_subtype: u32,
sample_count: u32,
codec: u32,
channel_count: u16,
sample_size_bits: u16,
sample_rate_fixed: u32,
stsc_entries: Vec<PpcQuickTimeStscEntry>,
chunk_offsets: Vec<u64>,
}
#[derive(Default)]
struct PpcQuickTimeMusicDecodeInfo {
handler_subtype: u32,
media_time_scale: u32,
media_duration: u64,
sample_durations: Vec<u32>,
sample_sizes: Vec<u32>,
stsc_entries: Vec<PpcQuickTimeStscEntry>,
chunk_offsets: Vec<u64>,
sample_descriptions: Vec<Vec<PpcQuickTimeMusicPart>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcQuickTimeMusicPart {
part: u16,
instrument_number: u32,
gm_number: u32,
}
#[derive(Default)]
struct PpcQuickTimeVideoSampleTableInfo {
handler_subtype: u32,
media_time_scale: u32,
media_duration: u64,
codec: u32,
sample_durations: Vec<u32>,
sample_sizes: Vec<u32>,
stsc_entries: Vec<PpcQuickTimeStscEntry>,
chunk_offsets: Vec<u64>,
}
impl PpcQuickTimeVideoSampleTableInfo {
fn is_complete(&self) -> bool {
self.handler_subtype == u32::from_be_bytes(*b"vide")
&& self.media_time_scale != 0
&& self.media_duration != 0
&& self.codec != 0
&& !self.sample_sizes.is_empty()
&& !self.stsc_entries.is_empty()
&& !self.chunk_offsets.is_empty()
}
}
impl PpcQuickTimeAudioDecodeInfo {
fn is_complete(&self) -> bool {
self.handler_subtype == u32::from_be_bytes(*b"soun")
&& self.sample_count != 0
&& self.codec != 0
&& self.channel_count != 0
&& self.sample_rate_fixed != 0
&& !self.stsc_entries.is_empty()
&& !self.chunk_offsets.is_empty()
}
}
impl PpcQuickTimeMusicDecodeInfo {
fn is_complete(&self) -> bool {
self.handler_subtype == u32::from_be_bytes(*b"musi")
&& self.media_time_scale != 0
&& self.media_duration != 0
&& self.sample_durations.len() == self.sample_sizes.len()
&& !self.sample_sizes.is_empty()
&& !self.stsc_entries.is_empty()
&& !self.chunk_offsets.is_empty()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct PpcQuickTimeStscEntry {
first_chunk: u32,
samples_per_chunk: u32,
sample_description_id: u32,
}
fn ppc_qt_scan_movie_video_track(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeVideoTrackRecord> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
if let Some(track) = ppc_qt_parse_video_track(data, content_start, atom_end, depth + 1)
{
return Some(track);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(track) =
ppc_qt_scan_movie_video_track(data, content_start, atom_end, depth + 1)
{
return Some(track);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_parse_video_track(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeVideoTrackRecord> {
let mut info = PpcQuickTimeTrackSampleInfo::default();
ppc_qt_collect_track_sample_info(data, start, end, depth, &mut info)?;
info.into_video_track(data)
}
fn ppc_qt_scan_movie_video_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeVideoSampleTableRecord> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
if let Some(samples) =
ppc_qt_parse_video_track_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(samples) =
ppc_qt_scan_movie_video_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_parse_video_track_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeVideoSampleTableRecord> {
let mut info = PpcQuickTimeVideoSampleTableInfo::default();
ppc_qt_collect_video_sample_table_info(data, start, end, depth, &mut info)?;
if !info.is_complete() {
return None;
}
ppc_qt_build_video_sample_table(data, &info)
}
fn ppc_qt_scan_movie_audio_track(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeAudioTrackRecord> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
if let Some(track) = ppc_qt_parse_audio_track(data, content_start, atom_end, depth + 1)
{
return Some(track);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(track) =
ppc_qt_scan_movie_audio_track(data, content_start, atom_end, depth + 1)
{
return Some(track);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_parse_audio_track(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeAudioTrackRecord> {
let mut info = PpcQuickTimeTrackSampleInfo::default();
ppc_qt_collect_track_sample_info(data, start, end, depth, &mut info)?;
info.into_audio_track(data)
}
fn ppc_qt_movie_audio_samples(data: &[u8]) -> Option<PpcDecodedAiffData> {
ppc_qt_scan_movie_audio_samples(data, 0, data.len(), 0)
.or_else(|| ppc_qt_scan_movie_music_samples(data, 0, data.len(), 0))
}
fn ppc_qt_scan_movie_music_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcDecodedAiffData> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
let mut info = PpcQuickTimeMusicDecodeInfo::default();
ppc_qt_collect_music_decode_info(data, content_start, atom_end, depth + 1, &mut info)?;
if info.is_complete() {
return ppc_qt_synthesize_music_track(data, &info);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(samples) =
ppc_qt_scan_movie_music_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_scan_movie_audio_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcDecodedAiffData> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
if let Some(samples) =
ppc_qt_parse_audio_track_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(samples) =
ppc_qt_scan_movie_audio_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_parse_audio_track_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcDecodedAiffData> {
let mut info = PpcQuickTimeAudioDecodeInfo::default();
ppc_qt_collect_audio_decode_info(data, start, end, depth, &mut info)?;
if !info.is_complete() {
return None;
}
ppc_qt_decode_audio_chunks(data, &info)
}
fn ppc_qt_sample_payload_summary(data: &[u8], offset: u64, size: u32) -> (u32, u32, u8, [u8; 16]) {
let mut preview = [0; 16];
let Ok(offset) = usize::try_from(offset) else {
return (0, 0, 0, preview);
};
let Ok(size) = usize::try_from(size) else {
return (0, 0, 0, preview);
};
let Some(end) = offset.checked_add(size) else {
return (0, 0, 0, preview);
};
let Some(sample) = data.get(offset..end) else {
return (0, 0, 0, preview);
};
let preview_len = sample.len().min(preview.len());
preview[..preview_len].copy_from_slice(&sample[..preview_len]);
let checksum = sample
.iter()
.fold(0u32, |acc, byte| acc.wrapping_add(u32::from(*byte)));
(
u32::try_from(sample.len()).unwrap_or(u32::MAX),
checksum,
u8::try_from(preview_len).unwrap_or(u8::MAX),
preview,
)
}
fn ppc_qt_collect_track_sample_info(
data: &[u8],
start: usize,
end: usize,
depth: u8,
info: &mut PpcQuickTimeTrackSampleInfo,
) -> Option<()> {
if depth > 8 || start >= end || end > data.len() {
return Some(());
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"hdlr" {
if let Some(subtype) = ppc_qt_hdlr_subtype(data, content_start, atom_end) {
if subtype == u32::from_be_bytes(*b"vide")
|| subtype == u32::from_be_bytes(*b"soun")
{
info.handler_subtype = subtype;
}
}
} else if atom_type == b"mdhd" {
if let Some((time_scale, duration)) =
ppc_qt_mvhd_duration(data, content_start, atom_end)
{
info.media_time_scale = time_scale;
info.media_duration = duration;
}
} else if atom_type == b"stsd" {
if let Some(codec) = ppc_qt_stsd_first_codec(data, content_start, atom_end) {
info.codec = codec;
}
if let Some((channel_count, sample_size_bits, sample_rate_fixed)) =
ppc_qt_stsd_first_sound_description(data, content_start, atom_end)
{
info.audio_channel_count = channel_count;
info.audio_sample_size_bits = sample_size_bits;
info.audio_sample_rate_fixed = sample_rate_fixed;
}
} else if atom_type == b"stts" {
if let Some((sample_count, first_sample_duration)) =
ppc_qt_stts_sample_summary(data, content_start, atom_end)
{
info.sample_count = sample_count;
info.first_sample_duration = first_sample_duration;
}
} else if atom_type == b"stsc" {
if let Some((samples_per_chunk, sample_description_id)) =
ppc_qt_stsc_first_chunk(data, content_start, atom_end)
{
info.first_samples_per_chunk = samples_per_chunk;
info.sample_description_id = sample_description_id;
}
} else if atom_type == b"stsz" {
if let Some((sample_count, first_sample_size)) =
ppc_qt_stsz_sample_summary(data, content_start, atom_end)
{
if info.sample_count == 0 {
info.sample_count = sample_count;
}
info.first_sample_size = first_sample_size;
}
} else if atom_type == b"stco" {
if let Some(first_chunk_offset) =
ppc_qt_stco_first_offset(data, content_start, atom_end)
{
info.first_chunk_offset = first_chunk_offset;
}
} else if atom_type == b"co64" {
if let Some(first_chunk_offset) =
ppc_qt_co64_first_offset(data, content_start, atom_end)
{
info.first_chunk_offset = first_chunk_offset;
}
} else if ppc_qt_is_container_atom(atom_type) {
ppc_qt_collect_track_sample_info(data, content_start, atom_end, depth + 1, info)?;
}
if atom_end == end {
break;
}
offset = atom_end;
}
Some(())
}
fn ppc_qt_collect_video_sample_table_info(
data: &[u8],
start: usize,
end: usize,
depth: u8,
info: &mut PpcQuickTimeVideoSampleTableInfo,
) -> Option<()> {
if depth > 8 || start >= end || end > data.len() {
return Some(());
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"hdlr" {
if let Some(subtype) = ppc_qt_hdlr_subtype(data, content_start, atom_end) {
if subtype == u32::from_be_bytes(*b"vide") {
info.handler_subtype = subtype;
}
}
} else if atom_type == b"mdhd" {
if let Some((time_scale, duration)) =
ppc_qt_mvhd_duration(data, content_start, atom_end)
{
info.media_time_scale = time_scale;
info.media_duration = duration;
}
} else if atom_type == b"stsd" {
if let Some(codec) = ppc_qt_stsd_first_codec(data, content_start, atom_end) {
info.codec = codec;
}
} else if atom_type == b"stts" {
if let Some(sample_durations) =
ppc_qt_stts_sample_durations(data, content_start, atom_end)
{
info.sample_durations = sample_durations;
}
} else if atom_type == b"stsc" {
if let Some(entries) = ppc_qt_stsc_entries(data, content_start, atom_end) {
info.stsc_entries = entries;
}
} else if atom_type == b"stsz" {
if let Some(sample_sizes) = ppc_qt_stsz_sample_sizes(data, content_start, atom_end) {
info.sample_sizes = sample_sizes;
}
} else if atom_type == b"stco" {
if let Some(offsets) = ppc_qt_stco_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if atom_type == b"co64" {
if let Some(offsets) = ppc_qt_co64_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if ppc_qt_is_container_atom(atom_type) {
ppc_qt_collect_video_sample_table_info(data, content_start, atom_end, depth + 1, info)?;
}
if atom_end == end {
break;
}
offset = atom_end;
}
Some(())
}
fn ppc_qt_collect_audio_decode_info(
data: &[u8],
start: usize,
end: usize,
depth: u8,
info: &mut PpcQuickTimeAudioDecodeInfo,
) -> Option<()> {
if depth > 8 || start >= end || end > data.len() {
return Some(());
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"hdlr" {
if let Some(subtype) = ppc_qt_hdlr_subtype(data, content_start, atom_end) {
if subtype == u32::from_be_bytes(*b"soun") {
info.handler_subtype = subtype;
}
}
} else if atom_type == b"stsd" {
if let Some(codec) = ppc_qt_stsd_first_codec(data, content_start, atom_end) {
info.codec = codec;
}
if let Some((channel_count, sample_size_bits, sample_rate_fixed)) =
ppc_qt_stsd_first_sound_description(data, content_start, atom_end)
{
info.channel_count = channel_count;
info.sample_size_bits = sample_size_bits;
info.sample_rate_fixed = sample_rate_fixed;
}
} else if atom_type == b"stts" {
if let Some((sample_count, _first_sample_duration)) =
ppc_qt_stts_sample_summary(data, content_start, atom_end)
{
info.sample_count = sample_count;
}
} else if atom_type == b"stsz" {
if let Some((sample_count, _first_sample_size)) =
ppc_qt_stsz_sample_summary(data, content_start, atom_end)
{
if info.sample_count == 0 {
info.sample_count = sample_count;
}
}
} else if atom_type == b"stsc" {
if let Some(entries) = ppc_qt_stsc_entries(data, content_start, atom_end) {
info.stsc_entries = entries;
}
} else if atom_type == b"stco" {
if let Some(offsets) = ppc_qt_stco_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if atom_type == b"co64" {
if let Some(offsets) = ppc_qt_co64_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if ppc_qt_is_container_atom(atom_type) {
ppc_qt_collect_audio_decode_info(data, content_start, atom_end, depth + 1, info)?;
}
if atom_end == end {
break;
}
offset = atom_end;
}
Some(())
}
fn ppc_qt_collect_music_decode_info(
data: &[u8],
start: usize,
end: usize,
depth: u8,
info: &mut PpcQuickTimeMusicDecodeInfo,
) -> Option<()> {
if depth > 8 || start >= end || end > data.len() {
return Some(());
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"hdlr" {
if let Some(subtype) = ppc_qt_hdlr_subtype(data, content_start, atom_end) {
if subtype == u32::from_be_bytes(*b"musi") {
info.handler_subtype = subtype;
}
}
} else if atom_type == b"mdhd" {
if let Some((time_scale, duration)) =
ppc_qt_mvhd_duration(data, content_start, atom_end)
{
info.media_time_scale = time_scale;
info.media_duration = duration;
}
} else if atom_type == b"stsd" {
if let Some(sample_descriptions) =
ppc_qt_music_sample_descriptions(data, content_start, atom_end)
{
info.sample_descriptions = sample_descriptions;
}
} else if atom_type == b"stts" {
if let Some(sample_durations) =
ppc_qt_stts_sample_durations(data, content_start, atom_end)
{
info.sample_durations = sample_durations;
}
} else if atom_type == b"stsz" {
if let Some(sample_sizes) = ppc_qt_stsz_sample_sizes(data, content_start, atom_end) {
info.sample_sizes = sample_sizes;
}
} else if atom_type == b"stsc" {
if let Some(entries) = ppc_qt_stsc_entries(data, content_start, atom_end) {
info.stsc_entries = entries;
}
} else if atom_type == b"stco" {
if let Some(offsets) = ppc_qt_stco_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if atom_type == b"co64" {
if let Some(offsets) = ppc_qt_co64_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if ppc_qt_is_container_atom(atom_type) {
ppc_qt_collect_music_decode_info(data, content_start, atom_end, depth + 1, info)?;
}
if atom_end == end {
break;
}
offset = atom_end;
}
Some(())
}
fn ppc_qt_music_sample_descriptions(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<Vec<Vec<PpcQuickTimeMusicPart>>> {
let entry_count = usize::try_from(ppc_read_be_u32_from_slice(data, content_start + 4)?).ok()?;
let maximum_entries = atom_end.checked_sub(content_start.checked_add(8)?)? / 16;
if entry_count > maximum_entries {
return None;
}
let mut entry_offset = content_start.checked_add(8)?;
let mut sample_descriptions = Vec::with_capacity(entry_count);
for _ in 0..entry_count {
let entry_size = usize::try_from(ppc_read_be_u32_from_slice(data, entry_offset)?).ok()?;
let entry_end = entry_offset.checked_add(entry_size)?;
if entry_size < 20 || entry_end > atom_end {
return None;
}
if data.get(entry_offset + 4..entry_offset + 8)? != b"musi" {
return None;
}
let mut parts = Vec::new();
let mut event_offset = entry_offset + 20;
while event_offset.checked_add(8)? <= entry_end {
let head = ppc_read_be_u32_from_slice(data, event_offset)?;
if head == 0 {
event_offset += 4;
continue;
}
if head >> 28 != 15 {
break;
}
let word_count = usize::try_from(head & 0xffff).ok()?;
let byte_count = word_count.checked_mul(4)?;
let event_end = event_offset.checked_add(byte_count)?;
if word_count < 2 || event_end > entry_end {
return None;
}
let tail = ppc_read_be_u32_from_slice(data, event_end - 4)?;
if tail >> 30 != 3 || tail & 0xffff != head & 0xffff {
return None;
}
let subtype = (tail >> 16) & 0x0fff;
if subtype == 1 && word_count >= 23 {
let request = event_offset + 4;
parts.push(PpcQuickTimeMusicPart {
part: ((head >> 16) & 0x0fff) as u16,
instrument_number: ppc_read_be_u32_from_slice(data, request + 76)?,
gm_number: ppc_read_be_u32_from_slice(data, request + 80)?,
});
}
event_offset = event_end;
}
sample_descriptions.push(parts);
entry_offset = entry_end;
}
Some(sample_descriptions)
}
fn ppc_qt_is_container_atom(atom_type: &[u8]) -> bool {
atom_type == b"moov"
|| atom_type == b"trak"
|| atom_type == b"mdia"
|| atom_type == b"minf"
|| atom_type == b"stbl"
|| atom_type == b"edts"
}
fn ppc_qt_hdlr_subtype(data: &[u8], content_start: usize, atom_end: usize) -> Option<u32> {
let subtype_offset = content_start.checked_add(8)?;
if subtype_offset.checked_add(4)? > atom_end {
return None;
}
Some(u32::from_be_bytes(
data.get(subtype_offset..subtype_offset + 4)?
.try_into()
.ok()?,
))
}
fn ppc_qt_stsd_first_codec(data: &[u8], content_start: usize, atom_end: usize) -> Option<u32> {
if content_start.checked_add(16)? > atom_end {
return None;
}
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 {
return None;
}
let entry_start = content_start + 8;
let entry_size = usize::try_from(u32::from_be_bytes(
data.get(entry_start..entry_start + 4)?.try_into().ok()?,
))
.ok()?;
if entry_size < 8 || entry_start.checked_add(entry_size)? > atom_end {
return None;
}
Some(u32::from_be_bytes(
data.get(entry_start + 4..entry_start + 8)?
.try_into()
.ok()?,
))
}
fn ppc_qt_stsd_first_sound_description(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(u16, u16, u32)> {
if content_start.checked_add(16)? > atom_end {
return None;
}
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 {
return None;
}
let entry_start = content_start + 8;
let entry_size = usize::try_from(u32::from_be_bytes(
data.get(entry_start..entry_start + 4)?.try_into().ok()?,
))
.ok()?;
if entry_size < 36 || entry_start.checked_add(entry_size)? > atom_end {
return None;
}
let channel_count = u16::from_be_bytes(
data.get(entry_start + 24..entry_start + 26)?
.try_into()
.ok()?,
);
let sample_size_bits = u16::from_be_bytes(
data.get(entry_start + 26..entry_start + 28)?
.try_into()
.ok()?,
);
let sample_rate_fixed = u32::from_be_bytes(
data.get(entry_start + 32..entry_start + 36)?
.try_into()
.ok()?,
);
(channel_count != 0 && sample_size_bits != 0 && sample_rate_fixed != 0).then_some((
channel_count,
sample_size_bits,
sample_rate_fixed,
))
}
fn ppc_qt_stts_sample_summary(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(u32, u32)> {
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 1_000_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(8)?)? > atom_end {
return None;
}
let mut sample_count = 0u32;
let mut first_sample_duration = 0u32;
for entry in 0..entry_count {
let entry_start = table_start + entry * 8;
let count = u32::from_be_bytes(data.get(entry_start..entry_start + 4)?.try_into().ok()?);
let duration = u32::from_be_bytes(
data.get(entry_start + 4..entry_start + 8)?
.try_into()
.ok()?,
);
if count != 0 && duration != 0 && first_sample_duration == 0 {
first_sample_duration = duration;
}
sample_count = sample_count.saturating_add(count);
}
(sample_count != 0 && first_sample_duration != 0)
.then_some((sample_count, first_sample_duration))
}
fn ppc_qt_stsc_first_chunk(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(u32, u32)> {
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 || content_start.checked_add(20)? > atom_end {
return None;
}
let first_chunk = u32::from_be_bytes(
data.get(content_start + 8..content_start + 12)?
.try_into()
.ok()?,
);
let samples_per_chunk = u32::from_be_bytes(
data.get(content_start + 12..content_start + 16)?
.try_into()
.ok()?,
);
let sample_description_id = u32::from_be_bytes(
data.get(content_start + 16..content_start + 20)?
.try_into()
.ok()?,
);
(first_chunk != 0 && samples_per_chunk != 0 && sample_description_id != 0)
.then_some((samples_per_chunk, sample_description_id))
}
fn ppc_qt_stsc_entries(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<Vec<PpcQuickTimeStscEntry>> {
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 100_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(12)?)? > atom_end {
return None;
}
let mut entries: Vec<PpcQuickTimeStscEntry> = Vec::with_capacity(entry_count);
for entry in 0..entry_count {
let entry_start = table_start + entry * 12;
let first_chunk =
u32::from_be_bytes(data.get(entry_start..entry_start + 4)?.try_into().ok()?);
let samples_per_chunk = u32::from_be_bytes(
data.get(entry_start + 4..entry_start + 8)?
.try_into()
.ok()?,
);
let sample_description_id = u32::from_be_bytes(
data.get(entry_start + 8..entry_start + 12)?
.try_into()
.ok()?,
);
if first_chunk == 0
|| samples_per_chunk == 0
|| sample_description_id == 0
|| entries
.last()
.is_some_and(|previous| previous.first_chunk >= first_chunk)
{
return None;
}
entries.push(PpcQuickTimeStscEntry {
first_chunk,
samples_per_chunk,
sample_description_id,
});
}
Some(entries)
}
fn ppc_qt_stsz_sample_summary(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(u32, u32)> {
if content_start.checked_add(12)? > atom_end {
return None;
}
let sample_size = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
let sample_count = u32::from_be_bytes(
data.get(content_start + 8..content_start + 12)?
.try_into()
.ok()?,
);
if sample_count == 0 {
return None;
}
if sample_size != 0 {
return Some((sample_count, sample_size));
}
if content_start.checked_add(16)? > atom_end {
return None;
}
let first_size = u32::from_be_bytes(
data.get(content_start + 12..content_start + 16)?
.try_into()
.ok()?,
);
(first_size != 0).then_some((sample_count, first_size))
}
fn ppc_qt_stsz_sample_sizes(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<Vec<u32>> {
if content_start.checked_add(12)? > atom_end {
return None;
}
let sample_size = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
let sample_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 8..content_start + 12)?
.try_into()
.ok()?,
))
.ok()?;
if sample_count == 0 || sample_count > 1_000_000 {
return None;
}
if sample_size != 0 {
return Some(vec![sample_size; sample_count]);
}
let table_start = content_start.checked_add(12)?;
if table_start.checked_add(sample_count.checked_mul(4)?)? > atom_end {
return None;
}
let mut sizes = Vec::with_capacity(sample_count);
for index in 0..sample_count {
let offset = table_start + index * 4;
let size = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
if size == 0 {
return None;
}
sizes.push(size);
}
Some(sizes)
}
fn ppc_qt_stts_sample_durations(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<Vec<u32>> {
if content_start.checked_add(8)? > atom_end {
return None;
}
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 1_000_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(8)?)? > atom_end {
return None;
}
let mut durations = Vec::new();
for index in 0..entry_count {
let offset = table_start + index * 8;
let sample_count = usize::try_from(u32::from_be_bytes(
data.get(offset..offset + 4)?.try_into().ok()?,
))
.ok()?;
let sample_duration =
u32::from_be_bytes(data.get(offset + 4..offset + 8)?.try_into().ok()?);
if sample_count == 0 || sample_duration == 0 {
return None;
}
let new_len = durations.len().checked_add(sample_count)?;
if new_len > 1_000_000 {
return None;
}
durations.resize(new_len, sample_duration);
}
(!durations.is_empty()).then_some(durations)
}
fn ppc_qt_stco_first_offset(data: &[u8], content_start: usize, atom_end: usize) -> Option<u64> {
if content_start.checked_add(12)? > atom_end {
return None;
}
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 {
return None;
}
Some(u64::from(u32::from_be_bytes(
data.get(content_start + 8..content_start + 12)?
.try_into()
.ok()?,
)))
}
fn ppc_qt_stco_offsets(data: &[u8], content_start: usize, atom_end: usize) -> Option<Vec<u64>> {
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 1_000_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(4)?)? > atom_end {
return None;
}
let mut offsets = Vec::with_capacity(entry_count);
for entry in 0..entry_count {
let entry_start = table_start + entry * 4;
offsets.push(u64::from(u32::from_be_bytes(
data.get(entry_start..entry_start + 4)?.try_into().ok()?,
)));
}
Some(offsets)
}
fn ppc_qt_co64_first_offset(data: &[u8], content_start: usize, atom_end: usize) -> Option<u64> {
if content_start.checked_add(16)? > atom_end {
return None;
}
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 {
return None;
}
Some(u64::from_be_bytes(
data.get(content_start + 8..content_start + 16)?
.try_into()
.ok()?,
))
}
fn ppc_qt_co64_offsets(data: &[u8], content_start: usize, atom_end: usize) -> Option<Vec<u64>> {
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 1_000_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(8)?)? > atom_end {
return None;
}
let mut offsets = Vec::with_capacity(entry_count);
for entry in 0..entry_count {
let entry_start = table_start + entry * 8;
offsets.push(u64::from_be_bytes(
data.get(entry_start..entry_start + 8)?.try_into().ok()?,
));
}
Some(offsets)
}
fn ppc_qt_union_bounds(
lhs: Option<(i16, i16, i16, i16)>,
rhs: Option<(i16, i16, i16, i16)>,
) -> Option<(i16, i16, i16, i16)> {
match (lhs, rhs) {
(Some((top, left, bottom, right)), Some((rhs_top, rhs_left, rhs_bottom, rhs_right))) => {
Some((
top.min(rhs_top),
left.min(rhs_left),
bottom.max(rhs_bottom),
right.max(rhs_right),
))
}
(Some(bounds), None) | (None, Some(bounds)) => Some(bounds),
(None, None) => None,
}
}
fn ppc_qt_tkhd_bounds(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(i16, i16, i16, i16)> {
let version = *data.get(content_start)?;
let dimensions_offset = match version {
0 => content_start.checked_add(76)?,
1 => content_start.checked_add(88)?,
_ => return None,
};
if dimensions_offset.checked_add(8)? > atom_end {
return None;
}
let width_fixed = u32::from_be_bytes(
data.get(dimensions_offset..dimensions_offset + 4)?
.try_into()
.ok()?,
);
let height_fixed = u32::from_be_bytes(
data.get(dimensions_offset + 4..dimensions_offset + 8)?
.try_into()
.ok()?,
);
let width = width_fixed >> 16;
let height = height_fixed >> 16;
if width == 0 || height == 0 || width > 8192 || height > 8192 {
return None;
}
Some((
0,
0,
i16::try_from(height).ok()?,
i16::try_from(width).ok()?,
))
}
fn ppc_qt_mvhd_duration(data: &[u8], content_start: usize, atom_end: usize) -> Option<(u32, u64)> {
let version = *data.get(content_start)?;
let (time_scale_offset, duration_offset, duration_size) = match version {
0 => (
content_start.checked_add(12)?,
content_start.checked_add(16)?,
4usize,
),
1 => (
content_start.checked_add(20)?,
content_start.checked_add(24)?,
8usize,
),
_ => return None,
};
if time_scale_offset.checked_add(4)? > atom_end
|| duration_offset.checked_add(duration_size)? > atom_end
{
return None;
}
let time_scale = u32::from_be_bytes(
data.get(time_scale_offset..time_scale_offset + 4)?
.try_into()
.ok()?,
);
let duration = if duration_size == 4 {
u64::from(u32::from_be_bytes(
data.get(duration_offset..duration_offset + 4)?
.try_into()
.ok()?,
))
} else {
u64::from_be_bytes(
data.get(duration_offset..duration_offset + 8)?
.try_into()
.ok()?,
)
};
if time_scale == 0 || duration == 0 {
return None;
}
Some((time_scale, duration))
}
fn ppc_qt_movie_tasks_until_done(time_scale: u32, duration: u64) -> u32 {
if time_scale == 0 || duration == 0 {
return PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE;
}
let numerator = duration
.saturating_mul(PPC_QT_MOVIE_TASKS_PER_SECOND)
.saturating_add(u64::from(time_scale).saturating_sub(1));
let tasks = numerator / u64::from(time_scale);
u32::try_from(tasks.max(1)).unwrap_or(u32::MAX)
}
fn ppc_qt_draw_pict_source_to_16bpp(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
data: &[u8],
) -> bool {
let Some((_pict_offset, (top, left, bottom, right))) =
ppc_qt_pict_record_offset_and_bounds(data)
else {
return false;
};
let natural_width = u32::try_from(i32::from(right) - i32::from(left)).unwrap_or(0);
let natural_height = u32::try_from(i32::from(bottom) - i32::from(top)).unwrap_or(0);
if natural_width == 0 || natural_height == 0 {
return false;
}
let dst_bottom = i16::try_from(natural_height.min(front_buffer.height)).unwrap_or(i16::MAX);
let dst_right = i16::try_from(natural_width.min(front_buffer.width)).unwrap_or(i16::MAX);
ppc_draw_pict_bytes_to_16bpp(
memory,
front_buffer,
data,
(0, 0, dst_bottom, dst_right),
&TrapDispatcher::standard_mac_8bpp_clut(),
0,
false,
)
}
fn ppc_qt_new_movie_from_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
let movie_out_ptr = cpu.gpr[3];
let res_id_ptr = cpu.gpr[5];
let data_ref_was_changed_ptr = cpu.gpr[8];
if movie_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, movie_out_ptr, 4) {
return PPC_PARAM_ERR;
}
if res_id_ptr != 0 && !ppc_memory_can_write_bytes(memory, res_id_ptr, 2) {
return PPC_PARAM_ERR;
}
if data_ref_was_changed_ptr != 0
&& !ppc_memory_can_write_bytes(memory, data_ref_was_changed_ptr, 1)
{
return PPC_PARAM_ERR;
}
// Inside Macintosh: QuickTime (1993), pp. 4-5–4-6: NewMovieFromFile
// returns NIL in the movie output when it cannot create the movie.
if memory.write_u32_be(movie_out_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
let requested_res_id = if res_id_ptr == 0 {
None
} else {
Some(memory.read_u16_be(res_id_ptr).unwrap_or(0) as i16)
};
if res_id_ptr != 0 && memory.write_u16_be(res_id_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
ppc_qt_stop_movie_audio(sound);
let ref_num = cpu.gpr[4] as i16;
if ref_num != 0 && ref_num == quicktime.movie_file_ref_num {
let mut selected_data = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(&quicktime.movie_file_path))
.map(|file| file.data.to_vec())
.unwrap_or_else(|| quicktime.movie_file_data.clone());
let Some(selected_res_id) = ppc_qt_append_movie_resource(
&mut selected_data,
vfs_resource_files,
vfs_resources,
&quicktime.movie_file_path,
requested_res_id,
) else {
return PPC_RES_NOT_FOUND_ERR;
};
quicktime.movie_file_data = selected_data;
ppc_qt_refresh_open_movie_metadata(quicktime);
if res_id_ptr != 0
&& memory
.write_u16_be(res_id_ptr, selected_res_id as u16)
.is_none()
{
return PPC_PARAM_ERR;
}
if let Some(bounds) = quicktime.movie_file_bounds {
quicktime.movie_box = bounds;
}
quicktime.movie_tasks_until_done = quicktime.movie_file_tasks_until_done;
quicktime.movie_video_track = quicktime.movie_file_video_track;
quicktime.movie_video_samples = quicktime.movie_file_video_samples.clone();
quicktime.movie_audio_track = quicktime.movie_file_audio_track;
} else {
quicktime.movie_tasks_until_done = PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE;
quicktime.movie_video_track = None;
quicktime.movie_video_samples = None;
quicktime.movie_audio_track = None;
}
if memory.write_u32_be(movie_out_ptr, PPC_QT_MOVIE).is_none() {
return PPC_PARAM_ERR;
}
if data_ref_was_changed_ptr != 0 && memory.write_u8(data_ref_was_changed_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
quicktime.movie_started = false;
quicktime.movie_task_count = 0;
quicktime.movie_disposed = false;
quicktime.movie_at_beginning = true;
ppc_qt_reset_movie_video_decode_cache(quicktime);
PPC_NO_ERR
}
fn ppc_qt_open_movie_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
quicktime: &mut PpcQuickTimeState,
) -> i16 {
let spec_ptr = cpu.gpr[3];
let ref_num_out_ptr = cpu.gpr[4];
if ref_num_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, ref_num_out_ptr, 2) {
return PPC_PARAM_ERR;
}
let mut movie_file_path = String::new();
let mut movie_file_data = Vec::new();
let mut movie_file_bounds = None;
let mut movie_file_time_scale = 0;
let mut movie_file_duration = 0;
let mut movie_file_tasks_until_done = PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE;
let mut movie_file_video_track = None;
let mut movie_file_video_samples = None;
let mut movie_file_audio_track = None;
if spec_ptr != 0 {
if let Ok(path) =
ppc_existing_path_for_fsspec(memory, vfs_directories, vfs_files, &[], spec_ptr)
{
if let Some(file) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&path))
{
movie_file_path = path;
movie_file_data = file.data.to_vec();
movie_file_bounds = ppc_qt_movie_bounds(&movie_file_data);
movie_file_video_track = ppc_qt_movie_first_video_track(&movie_file_data);
movie_file_video_samples = ppc_qt_movie_video_samples(&movie_file_data);
movie_file_audio_track = ppc_qt_movie_first_audio_track(&movie_file_data);
if let Some((time_scale, duration)) = ppc_qt_movie_duration(&movie_file_data) {
movie_file_time_scale = time_scale;
movie_file_duration = duration;
movie_file_tasks_until_done =
ppc_qt_movie_tasks_until_done(time_scale, duration);
}
}
}
}
if memory
.write_u16_be(ref_num_out_ptr, PPC_FIRST_FILE_REF_NUM as u16)
.is_none()
{
return PPC_PARAM_ERR;
}
quicktime.movie_file_open_count = quicktime.movie_file_open_count.saturating_add(1);
quicktime.movie_file_ref_num = PPC_FIRST_FILE_REF_NUM;
quicktime.movie_file_path = movie_file_path;
quicktime.movie_file_data = movie_file_data;
quicktime.movie_file_bounds = movie_file_bounds;
quicktime.movie_file_time_scale = movie_file_time_scale;
quicktime.movie_file_duration = movie_file_duration;
quicktime.movie_file_tasks_until_done = movie_file_tasks_until_done;
quicktime.movie_file_video_track = movie_file_video_track;
quicktime.movie_file_video_samples = movie_file_video_samples;
quicktime.movie_file_audio_track = movie_file_audio_track;
if qt_trace_enabled() {
let video = quicktime
.movie_file_video_samples
.as_ref()
.map(|samples| {
format!(
"{} samples={} duration={}",
format_ppc_fourcc(samples.codec),
samples.sample_count,
samples.media_duration
)
})
.unwrap_or_else(|| "none".to_string());
eprintln!(
"[QT-TRACE] OpenMovieFile path='{}' data_len={} bounds={:?} time_scale={} duration={} tasks_until_done={} video={}",
quicktime.movie_file_path,
quicktime.movie_file_data.len(),
quicktime.movie_file_bounds,
quicktime.movie_file_time_scale,
quicktime.movie_file_duration,
quicktime.movie_file_tasks_until_done,
video
);
}
PPC_NO_ERR
}
fn ppc_qt_append_movie_resource(
movie_file_data: &mut Vec<u8>,
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
path: &str,
requested_res_id: Option<i16>,
) -> Option<i16> {
// Inside Macintosh: QuickTime (1993), pp. 4-3–4-6.
let data_movie_range = ppc_qt_top_level_atom_offsets(movie_file_data, b"moov");
if data_movie_range.is_some() && !matches!(requested_res_id, Some(1..=i16::MAX)) {
return requested_res_id
.map_or(true, |res_id| res_id == 0 || res_id == -1)
.then_some(-1);
}
if requested_res_id == Some(-1) {
return None;
}
let moov_type = u32::from_be_bytes(*b"moov");
let resource = vfs_resources
.iter()
.filter(|resource| {
resource.path.eq_ignore_ascii_case(path) && resource.res_type == moov_type
})
.find(|resource| requested_res_id.map_or(true, |id| id == 0 || resource.res_id == id))
.map(|resource| (resource.res_id, resource.data.clone()))
.or_else(|| {
let raw_data = vfs_resource_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(path))?
.raw_data
.as_ref()?;
let fork = ResourceFork::parse(raw_data)?;
fork.resources()
.values()
.filter(|resource| resource.res_type == *b"moov")
.filter(|resource| requested_res_id.map_or(true, |id| id == 0 || resource.id == id))
.min_by_key(|resource| resource.id)
.map(|resource| (resource.id, resource.data.clone()))
});
let Some((res_id, resource_data)) = resource else {
return None;
};
if let Some((atom_type, _, atom_end)) =
ppc_qt_atom_range(&resource_data, 0, resource_data.len())
{
if atom_type == b"moov" && atom_end == resource_data.len() {
if let Some((start, end)) = data_movie_range {
movie_file_data.drain(start..end);
}
movie_file_data.extend_from_slice(&resource_data);
return Some(res_id);
}
}
None
}
fn ppc_qt_top_level_atom_offsets(data: &[u8], expected_type: &[u8; 4]) -> Option<(usize, usize)> {
let mut offset = 0usize;
while offset.checked_add(8)? <= data.len() {
let (atom_type, _, atom_end) = ppc_qt_atom_range(data, offset, data.len())?;
if atom_type == expected_type {
return Some((offset, atom_end));
}
if atom_end == data.len() {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_refresh_open_movie_metadata(quicktime: &mut PpcQuickTimeState) {
quicktime.movie_file_bounds = None;
quicktime.movie_file_time_scale = 0;
quicktime.movie_file_duration = 0;
quicktime.movie_file_tasks_until_done = PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE;
quicktime.movie_file_video_track = None;
quicktime.movie_file_video_samples = None;
quicktime.movie_file_audio_track = None;
quicktime.movie_file_bounds = ppc_qt_movie_bounds(&quicktime.movie_file_data);
quicktime.movie_file_video_track = ppc_qt_movie_first_video_track(&quicktime.movie_file_data);
quicktime.movie_file_video_samples = ppc_qt_movie_video_samples(&quicktime.movie_file_data);
quicktime.movie_file_audio_track = ppc_qt_movie_first_audio_track(&quicktime.movie_file_data);
if let Some((time_scale, duration)) = ppc_qt_movie_duration(&quicktime.movie_file_data) {
quicktime.movie_file_time_scale = time_scale;
quicktime.movie_file_duration = duration;
quicktime.movie_file_tasks_until_done = ppc_qt_movie_tasks_until_done(time_scale, duration);
}
}
#[cfg(test)]
fn ppc_qt_top_level_atom<'a>(data: &'a [u8], expected_type: &[u8; 4]) -> Option<&'a [u8]> {
let mut offset = 0usize;
while offset.checked_add(8)? <= data.len() {
let (atom_type, _, atom_end) = ppc_qt_atom_range(data, offset, data.len())?;
if atom_type == expected_type {
return data.get(offset..atom_end);
}
if atom_end == data.len() {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_close_movie_file(cpu: &mut PpcCpu, quicktime: &mut PpcQuickTimeState) -> i16 {
let ref_num = cpu.gpr[3] as i16;
if ref_num == 0 {
return PPC_PARAM_ERR;
}
quicktime.movie_file_close_count = quicktime.movie_file_close_count.saturating_add(1);
quicktime.movie_file_last_closed_ref_num = ref_num;
if quicktime.movie_file_ref_num == ref_num {
quicktime.movie_file_ref_num = 0;
}
PPC_NO_ERR
}
fn ppc_qt_set_movie_gworld(cpu: &mut PpcCpu, quicktime: &mut PpcQuickTimeState) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_gworld = cpu.gpr[4];
quicktime.movie_gdevice = cpu.gpr[5];
PPC_NO_ERR
}
fn ppc_qt_set_movie_box(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
quicktime: &mut PpcQuickTimeState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
let box_ptr = cpu.gpr[4];
let Some(rect) = ppc_read_rect(memory, box_ptr) else {
return PPC_PARAM_ERR;
};
quicktime.movie_box = rect;
quicktime.movie_set_box_count = quicktime.movie_set_box_count.saturating_add(1);
PPC_NO_ERR
}
fn ppc_qt_get_movie_box(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
quicktime: &PpcQuickTimeState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
if cpu.gpr[4] == 0 || !ppc_memory_can_write_bytes(memory, cpu.gpr[4], 8) {
return PPC_PARAM_ERR;
}
let (top, left, bottom, right) = quicktime.movie_box;
if ppc_write_rect(memory, cpu.gpr[4], top, left, bottom, right).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_qt_go_to_beginning_of_movie(
cpu: &mut PpcCpu,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_beginning_count = quicktime.movie_beginning_count.saturating_add(1);
quicktime.movie_at_beginning = true;
quicktime.movie_started = false;
quicktime.movie_task_count = 0;
ppc_qt_reset_movie_video_decode_cache(quicktime);
ppc_qt_stop_movie_audio(sound);
PPC_NO_ERR
}
fn ppc_qt_go_to_end_of_movie(
cpu: &mut PpcCpu,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_at_beginning = false;
quicktime.movie_started = false;
quicktime.movie_task_count = quicktime.movie_tasks_until_done.max(1);
ppc_qt_reset_movie_video_decode_cache(quicktime);
ppc_qt_stop_movie_audio(sound);
PPC_NO_ERR
}
fn ppc_qt_get_movie_duration(cpu: &mut PpcCpu, quicktime: &PpcQuickTimeState) -> (i16, u32) {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return (PPC_PARAM_ERR, 0);
}
let duration = if quicktime.movie_file_duration > 0 {
quicktime.movie_file_duration as u32
} else {
600
};
(PPC_NO_ERR, duration)
}
fn ppc_qt_load_movie_into_ram(cpu: &mut PpcCpu, quicktime: &PpcQuickTimeState) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_qt_start_movie(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_started = true;
quicktime.movie_at_beginning = false;
let audio_started = ppc_qt_start_movie_audio(quicktime, sound);
let cache_before = quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index);
let drawn = ppc_qt_draw_movie_frame(memory, gworlds, current_gworld, quicktime, 0x21);
if qt_trace_enabled() {
let cache_after = quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index);
eprintln!(
"[QT-TRACE] StartMovie path='{}' task_count={} drawn={} decoded={} audio={} cache_before={:?} cache_after={:?}",
quicktime.movie_file_path,
quicktime.movie_task_count,
drawn,
cache_after.is_some() && cache_after != cache_before,
audio_started,
cache_before,
cache_after
);
}
PPC_NO_ERR
}
fn ppc_qt_stop_movie(
cpu: &mut PpcCpu,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_started = false;
ppc_qt_stop_movie_audio(sound);
PPC_NO_ERR
}
fn ppc_qt_movies_task(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_task_count = quicktime.movie_task_count.saturating_add(1);
if quicktime.movie_started {
quicktime.movie_at_beginning = false;
let cache_before = quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index);
let drawn = ppc_qt_draw_movie_frame(
memory,
gworlds,
current_gworld,
quicktime,
0x30u32.saturating_add(quicktime.movie_task_count),
);
if qt_trace_enabled() {
let cache_after = quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index);
eprintln!(
"[QT-TRACE] MoviesTask path='{}' task_count={} drawn={} decoded={} cache_before={:?} cache_after={:?}",
quicktime.movie_file_path,
quicktime.movie_task_count,
drawn,
cache_after.is_some() && cache_after != cache_before,
cache_before,
cache_after
);
}
if quicktime.movie_task_count >= quicktime.movie_tasks_until_done.max(1) {
quicktime.movie_started = false;
ppc_qt_stop_movie_audio(sound);
}
}
PPC_NO_ERR
}
fn ppc_qt_is_movie_done(cpu: &mut PpcCpu, quicktime: &PpcQuickTimeState) -> (i16, bool) {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return (PPC_PARAM_ERR, true);
}
(
PPC_NO_ERR,
!quicktime.movie_started
|| quicktime.movie_task_count >= quicktime.movie_tasks_until_done.max(1),
)
}
fn ppc_qt_dispose_movie(
cpu: &mut PpcCpu,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE {
return PPC_PARAM_ERR;
}
quicktime.movie_started = false;
quicktime.movie_disposed = true;
quicktime.movie_video_track = None;
quicktime.movie_video_samples = None;
quicktime.movie_video_decode_cache = None;
quicktime.movie_audio_track = None;
ppc_qt_stop_movie_audio(sound);
PPC_NO_ERR
}
fn ppc_qt_reset_movie_video_decode_cache(quicktime: &mut PpcQuickTimeState) {
quicktime.movie_video_decode_cache = None;
}
fn ppc_qt_start_movie_audio(quicktime: &PpcQuickTimeState, sound: &mut PpcSoundState) -> bool {
ppc_qt_stop_movie_audio(sound);
let Some(decoded_sound) = ppc_qt_decode_movie_audio_samples(quicktime) else {
return false;
};
let Some(file_playback_index) = u32::try_from(sound.file_playbacks.len()).ok() else {
return false;
};
let summary = decoded_sound.summary;
let samples = decoded_sound.samples;
if qt_trace_enabled() {
let non_silent = samples.iter().filter(|sample| **sample != 0x80).count();
let first_non_silent = samples.iter().position(|sample| *sample != 0x80);
let last_non_silent = samples.iter().rposition(|sample| *sample != 0x80);
eprintln!(
"[QT-TRACE] MovieAudio samples={} non_silent={} first={:?} last={:?} rate={}",
samples.len(),
non_silent,
first_non_silent,
last_non_silent,
summary.sample_rate_fixed
);
}
sound.manager.play_file_buffer(
PPC_QT_MOVIE,
samples.clone(),
summary.sample_rate_fixed,
None,
);
sound
.decoded_file_playbacks
.push(PpcDecodedAiffPlaybackRecord {
file_playback_index,
channel: PPC_QT_MOVIE,
sample_rate_fixed: summary.sample_rate_fixed,
samples,
});
sound.file_playbacks.push(PpcSoundFilePlaybackRecord {
channel: PPC_QT_MOVIE,
ref_num: quicktime.movie_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: Some(summary),
});
true
}
fn ppc_qt_stop_movie_audio(sound: &mut PpcSoundState) {
sound.manager.quiet_channel(PPC_QT_MOVIE);
}
fn ppc_qt_decode_movie_audio_samples(quicktime: &PpcQuickTimeState) -> Option<PpcDecodedAiffData> {
if let Some(decoded) = ppc_qt_movie_audio_samples(&quicktime.movie_file_data) {
return Some(decoded);
}
let track = quicktime.movie_audio_track?;
let sample_count = track.sample_count.min(track.first_samples_per_chunk);
let offset = usize::try_from(track.first_chunk_offset).ok()?;
let frames = usize::try_from(sample_count).ok()?;
let channels = usize::from(track.channel_count);
let samples = match track.codec {
codec if codec == u32::from_be_bytes(*b"ima4") => ppc_qt_decode_ima4_movie_audio_samples(
&quicktime.movie_file_data,
offset,
frames,
channels,
)?,
_ => ppc_qt_decode_pcm_movie_audio_samples(
&quicktime.movie_file_data,
offset,
frames,
channels,
usize::from(track.sample_size_bits),
track.codec,
)?,
};
ppc_decoded_sound_data(samples, track.sample_rate_fixed)
}
fn ppc_qt_build_video_sample_table(
data: &[u8],
info: &PpcQuickTimeVideoSampleTableInfo,
) -> Option<PpcQuickTimeVideoSampleTableRecord> {
let mut sample_index = 0usize;
let mut media_start_time = 0u64;
let mut samples = Vec::with_capacity(info.sample_sizes.len());
for (chunk_index, chunk_offset) in info.chunk_offsets.iter().copied().enumerate() {
if sample_index >= info.sample_sizes.len() {
break;
}
let chunk_number = u32::try_from(chunk_index).ok()?.saturating_add(1);
let samples_per_chunk = usize::try_from(ppc_qt_samples_per_chunk_for_chunk(
&info.stsc_entries,
chunk_number,
)?)
.ok()?;
let mut sample_offset = chunk_offset;
for _ in 0..samples_per_chunk {
if sample_index >= info.sample_sizes.len() {
break;
}
let size = info.sample_sizes[sample_index];
let duration = ppc_qt_video_sample_duration(info, sample_index)?;
let (data_len, checksum, preview_len, preview) =
ppc_qt_sample_payload_summary(data, sample_offset, size);
samples.push(PpcQuickTimeVideoSampleRecord {
offset: sample_offset,
size,
media_start_time,
duration,
data_len,
checksum,
preview_len,
preview,
});
sample_offset = sample_offset.checked_add(u64::from(size))?;
media_start_time = media_start_time.checked_add(u64::from(duration))?;
sample_index += 1;
}
}
if samples.len() != info.sample_sizes.len() {
return None;
}
Some(PpcQuickTimeVideoSampleTableRecord {
media_time_scale: info.media_time_scale,
media_duration: info.media_duration,
sample_count: u32::try_from(samples.len()).ok()?,
codec: info.codec,
samples,
})
}
fn ppc_qt_video_sample_duration(
info: &PpcQuickTimeVideoSampleTableInfo,
sample_index: usize,
) -> Option<u32> {
if let Some(duration) = info.sample_durations.get(sample_index).copied() {
if duration != 0 {
return Some(duration);
}
}
let sample_count = u64::try_from(info.sample_sizes.len()).ok()?;
if sample_count == 0 || info.media_duration == 0 {
return None;
}
u32::try_from((info.media_duration / sample_count).max(1)).ok()
}
fn ppc_qt_decode_audio_chunks(
data: &[u8],
info: &PpcQuickTimeAudioDecodeInfo,
) -> Option<PpcDecodedAiffData> {
let mut remaining_frames = usize::try_from(info.sample_count).ok()?;
let mut samples = Vec::with_capacity(remaining_frames);
for (chunk_index, chunk_offset) in info.chunk_offsets.iter().copied().enumerate() {
if remaining_frames == 0 {
break;
}
let chunk_number = u32::try_from(chunk_index).ok()?.saturating_add(1);
let samples_per_chunk = usize::try_from(ppc_qt_samples_per_chunk_for_chunk(
&info.stsc_entries,
chunk_number,
)?)
.ok()?;
let frames = remaining_frames.min(samples_per_chunk);
let offset = usize::try_from(chunk_offset).ok()?;
let mut chunk_samples = match info.codec {
codec if codec == u32::from_be_bytes(*b"ima4") => {
ppc_qt_decode_ima4_movie_audio_samples(
data,
offset,
frames,
usize::from(info.channel_count),
)?
}
_ => ppc_qt_decode_pcm_movie_audio_samples(
data,
offset,
frames,
usize::from(info.channel_count),
usize::from(info.sample_size_bits),
info.codec,
)?,
};
remaining_frames -= chunk_samples.len();
samples.append(&mut chunk_samples);
}
if samples.is_empty() {
return None;
}
ppc_decoded_sound_data(samples, info.sample_rate_fixed)
}
fn ppc_qt_synthesize_music_track(
data: &[u8],
info: &PpcQuickTimeMusicDecodeInfo,
) -> Option<PpcDecodedAiffData> {
const SAMPLE_RATE: u32 = 22_050;
const MAX_MUSIC_SECONDS: u64 = 600;
let total_samples = info
.media_duration
.checked_mul(u64::from(SAMPLE_RATE))?
.checked_div(u64::from(info.media_time_scale))?
.min(u64::from(SAMPLE_RATE) * MAX_MUSIC_SECONDS);
let mut mixed = vec![0i32; usize::try_from(total_samples).ok()?];
let mut sample_index = 0usize;
let mut sample_start_time = 0u64;
let mut parts = Vec::<PpcQuickTimeMusicPartState>::new();
for (chunk_index, chunk_offset) in info.chunk_offsets.iter().copied().enumerate() {
if sample_index >= info.sample_sizes.len() {
break;
}
let chunk_number = u32::try_from(chunk_index).ok()?.saturating_add(1);
let chunk_description = ppc_qt_stsc_entry_for_chunk(&info.stsc_entries, chunk_number)?;
let samples_per_chunk = usize::try_from(chunk_description.samples_per_chunk).ok()?;
if let Some(description_index) = usize::try_from(chunk_description.sample_description_id)
.ok()?
.checked_sub(1)
{
let description = info.sample_descriptions.get(description_index)?;
for requested in description {
ppc_qt_music_part_state(&mut parts, requested.part).instrument =
ppc_qt_music_instrument(*requested);
}
}
let mut sample_offset = usize::try_from(chunk_offset).ok()?;
for _ in 0..samples_per_chunk {
let sample_size = usize::try_from(*info.sample_sizes.get(sample_index)?).ok()?;
let sample_end = sample_offset.checked_add(sample_size)?;
let sample = data.get(sample_offset..sample_end)?;
ppc_qt_synthesize_music_events(
sample,
info.media_time_scale,
sample_start_time,
&mut mixed,
SAMPLE_RATE,
&mut parts,
)?;
sample_offset = sample_end;
sample_start_time = sample_start_time
.checked_add(u64::from(*info.sample_durations.get(sample_index)?))?;
sample_index += 1;
if sample_index >= info.sample_sizes.len() {
break;
}
}
}
if sample_index != info.sample_sizes.len() {
return None;
}
if !mixed.iter().any(|sample| *sample != 0) {
return None;
}
let samples = mixed
.into_iter()
.map(|sample| (sample + 128).clamp(0, 255) as u8)
.collect::<Vec<_>>();
ppc_decoded_sound_data(samples, SAMPLE_RATE << 16)
}
fn ppc_qt_synthesize_music_events(
data: &[u8],
media_time_scale: u32,
sample_start_time: u64,
mixed: &mut [i32],
sample_rate: u32,
parts: &mut Vec<PpcQuickTimeMusicPartState>,
) -> Option<()> {
// QuickTime Music Architecture (1997), pp. 19-30.
let mut offset = 0usize;
let mut local_time = 0u64;
let mut reserved_end_marker_seen = false;
while offset.checked_add(4)? <= data.len() {
let word = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
let short_type = (word >> 29) & 0x7;
match short_type {
0 => {
local_time = local_time.checked_add(u64::from(word & 0x00ff_ffff))?;
offset += 4;
}
1 => {
let part = (word >> 24) & 0x1f;
let pitch = ((word >> 18) & 0x3f) + 32;
let velocity = (word >> 11) & 0x7f;
let duration = word & 0x7ff;
let state = *ppc_qt_music_part_state(parts, part as u16);
ppc_qt_mix_music_note(
mixed,
sample_start_time.checked_add(local_time)?,
duration,
pitch as f64,
velocity,
state,
media_time_scale,
sample_rate,
)?;
offset += 4;
}
2 => {
let part = ((word >> 24) & 0x1f) as u16;
let controller = ((word >> 16) & 0xff) as u16;
let value = word as u16 as i16;
ppc_qt_apply_music_controller(
ppc_qt_music_part_state(parts, part),
controller,
value,
);
offset += 4;
}
3 => {
if ((word >> 16) & 0xff) == 0 {
if word & 0xffff == 0 {
return (offset + 4 == data.len()).then_some(());
}
reserved_end_marker_seen = true;
}
offset += 4;
}
_ => {
let extended_type = word >> 28;
if extended_type == 9 {
let tail =
u32::from_be_bytes(data.get(offset + 4..offset + 8)?.try_into().ok()?);
if tail >> 30 != 2 {
return None;
}
let part = (word >> 16) & 0x0fff;
let pitch_bits = word & 0xffff;
let pitch = if pitch_bits < 128 {
f64::from(pitch_bits)
} else {
f64::from(pitch_bits) / 256.0
};
let velocity = (tail >> 22) & 0x7f;
let duration = tail & 0x003f_ffff;
let state = *ppc_qt_music_part_state(parts, part as u16);
ppc_qt_mix_music_note(
mixed,
sample_start_time.checked_add(local_time)?,
duration,
pitch,
velocity,
state,
media_time_scale,
sample_rate,
)?;
offset += 8;
} else if extended_type == 10 {
let tail =
u32::from_be_bytes(data.get(offset + 4..offset + 8)?.try_into().ok()?);
if tail >> 30 != 2 {
return None;
}
let part = ((word >> 16) & 0x0fff) as u16;
ppc_qt_apply_music_controller(
ppc_qt_music_part_state(parts, part),
(word & 0xffff) as u16,
tail as u16 as i16,
);
offset += 8;
} else if extended_type == 15 {
let word_count = usize::try_from(word & 0xffff).ok()?;
if word_count < 2 {
return None;
}
let event_end = offset.checked_add(word_count.checked_mul(4)?)?;
let tail = u32::from_be_bytes(
data.get(event_end.checked_sub(4)?..event_end)?
.try_into()
.ok()?,
);
if tail >> 30 != 3 || tail & 0xffff != word & 0xffff {
return None;
}
offset = event_end;
} else {
let tail =
u32::from_be_bytes(data.get(offset + 4..offset + 8)?.try_into().ok()?);
if tail >> 30 != 2 {
return None;
}
offset += 8;
}
}
}
}
(offset == data.len() && !reserved_end_marker_seen).then_some(())
}
#[derive(Debug, Clone, Copy)]
struct PpcQuickTimeMusicPartState {
part: u16,
instrument: u32,
volume: i16,
pitch_bend: i16,
sustain: bool,
}
fn ppc_qt_music_part_state(
parts: &mut Vec<PpcQuickTimeMusicPartState>,
part: u16,
) -> &mut PpcQuickTimeMusicPartState {
if let Some(index) = parts.iter().position(|state| state.part == part) {
return &mut parts[index];
}
parts.push(PpcQuickTimeMusicPartState {
part,
instrument: 1,
volume: i16::MAX,
pitch_bend: 0,
sustain: false,
});
parts.last_mut().unwrap()
}
fn ppc_qt_music_instrument(part: PpcQuickTimeMusicPart) -> u32 {
if (1..=128).contains(&part.instrument_number)
|| (16_384..=16_512).contains(&part.instrument_number)
{
part.instrument_number
} else if (1..=128).contains(&part.gm_number) || (16_384..=16_512).contains(&part.gm_number) {
part.gm_number
} else {
1
}
}
fn ppc_qt_apply_music_controller(
state: &mut PpcQuickTimeMusicPartState,
controller: u16,
value: i16,
) {
match controller {
7 => state.volume = value.max(0),
32 => state.pitch_bend = value,
64 => state.sustain = value > 0,
_ => {}
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_qt_mix_music_note(
mixed: &mut [i32],
start_time: u64,
duration: u32,
pitch: f64,
velocity: u32,
state: PpcQuickTimeMusicPartState,
media_time_scale: u32,
sample_rate: u32,
) -> Option<()> {
// QuickTime Musical Instruments playback uses most of the signed 8-bit
// output range. Keep headroom for overlapping notes while matching that
// mixer level instead of leaving each synthesized part near silence.
const OUTPUT_GAIN: i32 = 6;
if duration == 0 || velocity == 0 || media_time_scale == 0 {
return Some(());
}
let start = start_time
.checked_mul(u64::from(sample_rate))?
.checked_div(u64::from(media_time_scale))?;
let length = u64::from(duration)
.checked_mul(u64::from(sample_rate))?
.checked_div(u64::from(media_time_scale))?
.max(1);
let start = usize::try_from(start).ok()?.min(mixed.len());
let end = usize::try_from(u64::try_from(start).ok()?.checked_add(length)?)
.ok()?
.min(mixed.len());
if !pitch.is_finite() {
return Some(());
}
let pitch_fixed = (pitch * 256.0) as i32 + i32::from(state.pitch_bend);
let phase_step = ppc_qt_music_phase_step(pitch_fixed, sample_rate)?;
let note_len = end.saturating_sub(start);
let mut phase = 0u32;
let instrument = state.instrument;
let drum = (16_384..=16_512).contains(&instrument);
let family = instrument.saturating_sub(1).min(127) / 8;
let mut noise = (start_time as u32)
.wrapping_mul(0x9e37_79b9)
.wrapping_add((pitch_fixed as u32).rotate_left(13))
.wrapping_add(instrument);
for (index, destination) in mixed[start..end].iter_mut().enumerate() {
let position = (phase >> 16) as i32;
noise ^= noise << 13;
noise ^= noise >> 17;
noise ^= noise << 5;
let triangle = if position < 32_768 {
position * 2 - 32_768
} else {
98_303 - position * 2
};
let saw = position - 32_768;
let square = if position < 32_768 { 24_576 } else { -24_576 };
let random = (noise >> 16) as i16 as i32;
let waveform = if drum {
match pitch.round() as i32 {
35 | 36 => triangle * 3 / 4 + square / 4,
38 | 40 => random * 3 / 4 + triangle / 4,
42 | 44 | 46 | 49 | 51 | 52 | 55 | 57 | 59 => random,
_ => random / 2 + triangle / 2,
}
} else {
match family {
0 => triangle * 3 / 4 + saw / 4,
1 => triangle / 2 + square / 2,
2 => square * 3 / 4 + triangle / 4,
3 => saw / 2 + triangle / 2,
4 => square / 2 + saw / 2,
5 | 6 => triangle * 3 / 4 + square / 4,
7 | 8 => saw * 3 / 4 + square / 4,
9 => triangle,
10 => saw,
11 => triangle * 3 / 4 + saw / 4,
12 => saw / 2 + random / 2,
13 => triangle / 2 + saw / 2,
14 => random / 2 + square / 2,
_ => random,
}
};
let edge_envelope = index.min(note_len.saturating_sub(index + 1)).min(63) as i32 + 1;
let decay_envelope = match family {
0 | 1 | 3 | 14 => i32::try_from(note_len.saturating_sub(index)).unwrap_or(i32::MAX),
_ => i32::try_from(note_len).unwrap_or(i32::MAX),
}
.max(1);
let volume = i32::from(state.volume).clamp(0, i32::from(i16::MAX));
let amplitude = waveform * velocity as i32 * edge_envelope / (127 * 64 * 4096) * volume
/ i32::from(i16::MAX)
* decay_envelope
/ i32::try_from(note_len.max(1)).unwrap_or(i32::MAX)
* OUTPUT_GAIN;
*destination = destination.saturating_add(amplitude);
phase = phase.wrapping_add(phase_step);
}
Some(())
}
fn ppc_qt_music_phase_step(pitch_fixed: i32, sample_rate: u32) -> Option<u32> {
const STEPS_22_050: [u32; 128] = [
1592507, 1687203, 1787529, 1893821, 2006434, 2125742, 2252146, 2386065, 2527948, 2678268,
2837526, 3006254, 3185015, 3374406, 3575058, 3787642, 4012867, 4251485, 4504291, 4772130,
5055896, 5356535, 5675051, 6012507, 6370030, 6748811, 7150117, 7575285, 8025735, 8502970,
9008582, 9544261, 10111792, 10713070, 11350103, 12025015, 12740059, 13497623, 14300233,
15150569, 16051469, 17005939, 18017165, 19088521, 20223584, 21426141, 22700205, 24050030,
25480119, 26995246, 28600467, 30301139, 32102938, 34011878, 36034330, 38177043, 40447168,
42852281, 45400411, 48100060, 50960238, 53990491, 57200933, 60602278, 64205876, 68023757,
72068660, 76354085, 80894335, 85704563, 90800821, 96200119, 101920476, 107980983,
114401866, 121204555, 128411753, 136047513, 144137319, 152708170, 161788671, 171409126,
181601643, 192400238, 203840952, 215961966, 228803732, 242409110, 256823506, 272095026,
288274639, 305416341, 323577341, 342818251, 363203285, 384800477, 407681904, 431923931,
457607465, 484818220, 513647012, 544190053, 576549277, 610832681, 647154683, 685636503,
726406571, 769600953, 815363807, 863847862, 915214929, 969636441, 1027294024, 1088380105,
1153098554, 1221665363, 1294309365, 1371273005, 1452813141, 1539201906, 1630727614,
1727695724, 1830429858, 1939272882, 2054588048, 2176760211, 2306197109, 2443330725,
];
if sample_rate == 0 {
return None;
}
let pitch_fixed = pitch_fixed.clamp(0, 127 * 256);
let note = usize::try_from(pitch_fixed / 256).ok()?;
let fraction = u64::try_from(pitch_fixed % 256).ok()?;
let first = u64::from(STEPS_22_050[note]);
let second = u64::from(*STEPS_22_050.get(note + 1).unwrap_or(&STEPS_22_050[note]));
let interpolated = first.checked_add(second.saturating_sub(first) * fraction / 256)?;
u32::try_from(
interpolated
.checked_mul(22_050)?
.checked_div(u64::from(sample_rate))?,
)
.ok()
}
fn ppc_qt_stsc_entry_for_chunk(
entries: &[PpcQuickTimeStscEntry],
chunk_number: u32,
) -> Option<PpcQuickTimeStscEntry> {
for (index, entry) in entries.iter().copied().enumerate() {
let next_first_chunk = entries
.get(index + 1)
.map(|next| next.first_chunk)
.unwrap_or(u32::MAX);
if chunk_number >= entry.first_chunk && chunk_number < next_first_chunk {
return Some(entry);
}
}
None
}
fn ppc_qt_samples_per_chunk_for_chunk(
entries: &[PpcQuickTimeStscEntry],
chunk_number: u32,
) -> Option<u32> {
let mut result = None;
for (index, entry) in entries.iter().enumerate() {
let next_first_chunk = entries
.get(index + 1)
.map(|next| next.first_chunk)
.unwrap_or(u32::MAX);
if chunk_number >= entry.first_chunk && chunk_number < next_first_chunk {
result = Some(entry.samples_per_chunk);
break;
}
}
result
}
fn ppc_qt_decode_pcm_movie_audio_samples(
data: &[u8],
data_start: usize,
frames: usize,
channels: usize,
sample_size_bits: usize,
codec: u32,
) -> Option<Vec<u8>> {
if frames == 0 || channels == 0 {
return None;
}
let bytes_per_sample = match sample_size_bits {
8 => 1usize,
16 => 2usize,
_ => return None,
};
let frame_bytes = channels.checked_mul(bytes_per_sample)?;
let byte_count = frames.checked_mul(frame_bytes)?;
let raw = data.get(data_start..data_start.checked_add(byte_count)?)?;
let mut samples = Vec::with_capacity(frames);
for frame in 0..frames {
let mut accum = 0i32;
let frame_start = frame.checked_mul(frame_bytes)?;
for channel in 0..channels {
let offset = frame_start.checked_add(channel.checked_mul(bytes_per_sample)?)?;
let sample = match (codec, sample_size_bits) {
(codec, 8) if codec == u32::from_be_bytes(*b"raw ") => raw[offset] as i32 - 128,
(codec, 8) if codec == u32::from_be_bytes(*b"twos") => raw[offset] as i8 as i32,
(codec, 16) if codec == u32::from_be_bytes(*b"twos") => {
i16::from_be_bytes([raw[offset], raw[offset + 1]]) as i32 >> 8
}
_ => return None,
};
accum += sample;
}
samples.push((accum / channels as i32 + 128).clamp(0, 255) as u8);
}
Some(samples)
}
fn ppc_qt_decode_ima4_movie_audio_samples(
data: &[u8],
data_start: usize,
frames: usize,
channels: usize,
) -> Option<Vec<u8>> {
const FRAMES_PER_PACKET: usize = 64;
const BYTES_PER_CHANNEL_PACKET: usize = 34;
if frames == 0 || channels == 0 {
return None;
}
let packets = frames
.checked_add(FRAMES_PER_PACKET - 1)?
.checked_div(FRAMES_PER_PACKET)?;
let packet_bytes = channels.checked_mul(BYTES_PER_CHANNEL_PACKET)?;
let byte_count = packets.checked_mul(packet_bytes)?;
let raw = data.get(data_start..data_start.checked_add(byte_count)?)?;
let mut samples = Vec::with_capacity(frames);
for packet in 0..packets {
let packet_start = packet.checked_mul(packet_bytes)?;
let mut decoded_channels = Vec::with_capacity(channels);
for channel in 0..channels {
let block_start =
packet_start.checked_add(channel.checked_mul(BYTES_PER_CHANNEL_PACKET)?)?;
decoded_channels.push(ppc_qt_decode_ima4_channel_packet(
raw.get(block_start..block_start + BYTES_PER_CHANNEL_PACKET)?,
)?);
}
let frames_this_packet = (frames - samples.len()).min(FRAMES_PER_PACKET);
for frame in 0..frames_this_packet {
let mut accum = 0i32;
for channel_samples in &decoded_channels {
accum += i32::from(channel_samples[frame]);
}
let mono = (((accum / channels as i32) >> 8) + 128).clamp(0, 255) as u8;
samples.push(mono);
}
}
Some(samples)
}
fn ppc_qt_decode_ima4_channel_packet(packet: &[u8]) -> Option<[i16; 64]> {
const STEP_TABLE: [i32; 89] = [
7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60,
66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371,
408, 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878,
2066, 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845,
8630, 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086,
29794, 32767,
];
const INDEX_TABLE: [i32; 16] = [-1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8];
if packet.len() != 34 {
return None;
}
let header = u16::from_be_bytes([packet[0], packet[1]]);
let mut predictor = i32::from((header & 0xff80) as i16);
let mut step_index = usize::from(header & 0x007f).min(STEP_TABLE.len() - 1);
let mut decoded = [0i16; 64];
let mut output_index = 0usize;
for byte in packet.iter().copied().skip(2) {
for nibble in [byte & 0x0f, byte >> 4] {
let step = STEP_TABLE[step_index];
let mut diff = step >> 3;
if (nibble & 0x01) != 0 {
diff += step >> 2;
}
if (nibble & 0x02) != 0 {
diff += step >> 1;
}
if (nibble & 0x04) != 0 {
diff += step;
}
if (nibble & 0x08) != 0 {
predictor -= diff;
} else {
predictor += diff;
}
predictor = predictor.clamp(i32::from(i16::MIN), i32::from(i16::MAX));
let next_index = step_index as i32 + INDEX_TABLE[usize::from(nibble)];
step_index = next_index.clamp(0, (STEP_TABLE.len() - 1) as i32) as usize;
decoded[output_index] = predictor as i16;
output_index += 1;
}
}
Some(decoded)
}
struct PpcQuickTimeCinepakDecoder {
width: usize,
height: usize,
frame: Vec<u8>,
strips: Vec<PpcQuickTimeCinepakStripState>,
}
struct PpcQuickTimeDecodedVideoFrame {
width: usize,
height: usize,
rgb: Vec<u8>,
}
impl PpcQuickTimeCinepakDecoder {
const MAX_STRIPS: usize = 32;
fn new(width: usize, height: usize) -> Option<Self> {
if width == 0 || height == 0 || width > 4096 || height > 4096 {
return None;
}
let pixel_bytes = width.checked_mul(height)?.checked_mul(3)?;
Some(Self {
width,
height,
frame: vec![0; pixel_bytes],
strips: vec![PpcQuickTimeCinepakStripState::default(); Self::MAX_STRIPS],
})
}
fn decode_sample(&mut self, sample: &[u8]) -> Option<()> {
if sample.len() < 10 {
return None;
}
let frame_flags = sample[0];
let encoded_size = ppc_qt_read_u24(sample, 1)?;
if encoded_size < 10 || encoded_size > sample.len() {
return None;
}
let width = usize::from(u16::from_be_bytes([sample[4], sample[5]]));
let height = usize::from(u16::from_be_bytes([sample[6], sample[7]]));
if width != self.width || height != self.height {
return None;
}
let strip_count =
usize::from(u16::from_be_bytes([sample[8], sample[9]])).min(Self::MAX_STRIPS);
let mut offset = 10usize;
let end = encoded_size;
let mut y_cursor = 0usize;
for strip_index in 0..strip_count {
if offset.checked_add(12)? > end {
return None;
}
let strip_id = sample[offset];
if strip_id != 0x10 && strip_id != 0x11 {
return None;
}
let strip_size = ppc_qt_read_u24(sample, offset + 1)?;
if strip_size < 12 {
return None;
}
let raw_y1 = usize::from(u16::from_be_bytes([sample[offset + 4], sample[offset + 5]]));
let x1 = usize::from(u16::from_be_bytes([sample[offset + 6], sample[offset + 7]]));
let raw_y2 = usize::from(u16::from_be_bytes([sample[offset + 8], sample[offset + 9]]));
let x2 = usize::from(u16::from_be_bytes([
sample[offset + 10],
sample[offset + 11],
]));
let (y1, y2) = if raw_y1 == 0 {
(y_cursor, y_cursor.checked_add(raw_y2)?)
} else {
(raw_y1, raw_y2)
};
if x1 >= x2 || y1 >= y2 || x1 >= self.width || y1 >= self.height {
return None;
}
offset += 12;
let strip_payload_size = strip_size - 12;
let strip_end = offset.checked_add(strip_payload_size)?;
if strip_end > end {
return None;
}
if strip_index > 0 && (frame_flags & 0x01) == 0 {
self.strips[strip_index] = self.strips[strip_index - 1].clone();
}
ppc_qt_decode_cinepak_strip(
&mut self.frame,
self.width,
self.height,
&mut self.strips[strip_index],
sample.get(offset..strip_end)?,
(x1, y1, x2.min(self.width), y2.min(self.height)),
)?;
offset = strip_end;
y_cursor = y2;
}
Some(())
}
fn decoded_frame(&self) -> PpcQuickTimeDecodedVideoFrame {
PpcQuickTimeDecodedVideoFrame {
width: self.width,
height: self.height,
rgb: self.frame.clone(),
}
}
fn from_cache(cache: &PpcQuickTimeVideoDecodeCacheRecord) -> Option<Self> {
if cache.width == 0
|| cache.height == 0
|| cache.rgb.len() != cache.width.checked_mul(cache.height)?.checked_mul(3)?
|| cache.cinepak_strips.len() != Self::MAX_STRIPS
{
return None;
}
Some(Self {
width: cache.width,
height: cache.height,
frame: cache.rgb.clone(),
strips: cache.cinepak_strips.clone(),
})
}
fn cache_record(&self, codec: u32, sample_index: usize) -> PpcQuickTimeVideoDecodeCacheRecord {
PpcQuickTimeVideoDecodeCacheRecord {
codec,
width: self.width,
height: self.height,
sample_index,
rgb: self.frame.clone(),
cinepak_strips: self.strips.clone(),
}
}
}
fn ppc_qt_read_u24(data: &[u8], offset: usize) -> Option<usize> {
let bytes = data.get(offset..offset.checked_add(3)?)?;
Some((usize::from(bytes[0]) << 16) | (usize::from(bytes[1]) << 8) | usize::from(bytes[2]))
}
fn ppc_qt_decode_current_movie_video_frame(
quicktime: &mut PpcQuickTimeState,
) -> Option<PpcQuickTimeDecodedVideoFrame> {
let samples = quicktime.movie_video_samples.clone()?;
if samples.codec != u32::from_be_bytes(*b"cvid") || samples.samples.is_empty() {
return None;
}
let sample_index = ppc_qt_movie_timed_sample_index(quicktime, &samples)?;
let first_sample = ppc_qt_movie_video_sample_bytes(&quicktime.movie_file_data, &samples, 0)?;
if first_sample.len() < 10 {
return None;
}
let width = usize::from(u16::from_be_bytes([first_sample[4], first_sample[5]]));
let height = usize::from(u16::from_be_bytes([first_sample[6], first_sample[7]]));
let mut start_index = 0usize;
let mut decoder = if let Some(cache) = quicktime
.movie_video_decode_cache
.as_ref()
.filter(|cache| {
cache.codec == samples.codec
&& cache.width == width
&& cache.height == height
&& cache.sample_index <= sample_index
})
.and_then(PpcQuickTimeCinepakDecoder::from_cache)
{
start_index = quicktime
.movie_video_decode_cache
.as_ref()?
.sample_index
.saturating_add(1);
cache
} else {
PpcQuickTimeCinepakDecoder::new(width, height)?
};
for index in start_index..=sample_index {
let sample = ppc_qt_movie_video_sample_bytes(&quicktime.movie_file_data, &samples, index)?;
decoder.decode_sample(sample)?;
}
let frame = decoder.decoded_frame();
quicktime.movie_video_decode_cache = Some(decoder.cache_record(samples.codec, sample_index));
Some(frame)
}
fn ppc_qt_movie_video_sample_bytes<'a>(
data: &'a [u8],
samples: &PpcQuickTimeVideoSampleTableRecord,
index: usize,
) -> Option<&'a [u8]> {
let sample = samples.samples.get(index)?;
let offset = usize::try_from(sample.offset).ok()?;
let size = usize::try_from(sample.size).ok()?;
data.get(offset..offset.checked_add(size)?)
}
fn ppc_qt_decode_cinepak_strip(
frame: &mut [u8],
width: usize,
height: usize,
strip: &mut PpcQuickTimeCinepakStripState,
data: &[u8],
bounds: (usize, usize, usize, usize),
) -> Option<()> {
let mut offset = 0usize;
while offset.checked_add(4)? <= data.len() {
let chunk_id = data[offset];
let chunk_size = ppc_qt_read_u24(data, offset + 1)?;
if chunk_size < 4 {
return None;
}
offset += 4;
let payload_size = chunk_size - 4;
let payload_end = offset.checked_add(payload_size)?;
let payload = data.get(offset..payload_end)?;
match chunk_id {
0x20 | 0x21 | 0x24 | 0x25 => {
ppc_qt_decode_cinepak_codebook(&mut strip.v4_codebook, chunk_id, payload);
}
0x22 | 0x23 | 0x26 | 0x27 => {
ppc_qt_decode_cinepak_codebook(&mut strip.v1_codebook, chunk_id, payload);
}
0x30 | 0x31 | 0x32 => {
ppc_qt_decode_cinepak_vectors(
frame, width, height, strip, chunk_id, payload, bounds,
)?;
return Some(());
}
_ => {}
}
offset = payload_end;
}
None
}
fn ppc_qt_decode_cinepak_codebook(codebook: &mut [[u8; 12]; 256], chunk_id: u8, data: &[u8]) {
let entry_len = if (chunk_id & 0x04) != 0 { 4 } else { 6 };
let flagged = (chunk_id & 0x01) != 0;
let mut offset = 0usize;
let mut flags = 0u32;
let mut mask = 0u32;
for entry in codebook.iter_mut() {
if flagged {
mask >>= 1;
if mask == 0 {
let Some(flag_bytes) = data.get(offset..offset.saturating_add(4)) else {
break;
};
flags = u32::from_be_bytes([
flag_bytes[0],
flag_bytes[1],
flag_bytes[2],
flag_bytes[3],
]);
offset += 4;
mask = 0x8000_0000;
}
if (flags & mask) == 0 {
continue;
}
}
let Some(raw) = data.get(offset..offset.saturating_add(entry_len)) else {
break;
};
offset += entry_len;
let y = [raw[0], raw[1], raw[2], raw[3]];
if entry_len == 4 {
for (index, luma) in y.iter().copied().enumerate() {
let base = index * 3;
entry[base] = luma;
entry[base + 1] = luma;
entry[base + 2] = luma;
}
} else {
let u = raw[4] as i8 as i32;
let v = raw[5] as i8 as i32;
for (index, luma) in y.iter().copied().enumerate() {
let luma = i32::from(luma);
let base = index * 3;
entry[base] = luma.saturating_add(v.saturating_mul(2)).clamp(0, 255) as u8;
entry[base + 1] = luma.saturating_sub(u / 2).saturating_sub(v).clamp(0, 255) as u8;
entry[base + 2] = luma.saturating_add(u.saturating_mul(2)).clamp(0, 255) as u8;
}
}
}
}
fn ppc_qt_decode_cinepak_vectors(
frame: &mut [u8],
width: usize,
height: usize,
strip: &PpcQuickTimeCinepakStripState,
chunk_id: u8,
data: &[u8],
(x1, y1, x2, y2): (usize, usize, usize, usize),
) -> Option<()> {
let mut offset = 0usize;
let mut flags = 0u32;
let mut mask = 0u32;
for y in (y1..y2).step_by(4) {
for x in (x1..x2).step_by(4) {
let should_decode = if (chunk_id & 0x01) != 0 {
ppc_qt_next_cinepak_flag(data, &mut offset, &mut flags, &mut mask)?
} else {
true
};
if !should_decode {
continue;
}
let use_v1 = if (chunk_id & 0x02) != 0 {
true
} else {
!ppc_qt_next_cinepak_flag(data, &mut offset, &mut flags, &mut mask)?
};
if use_v1 {
let index = usize::from(*data.get(offset)?);
offset += 1;
ppc_qt_put_cinepak_v1_block(frame, width, height, x, y, &strip.v1_codebook[index])?;
} else {
let indices = data.get(offset..offset.checked_add(4)?)?;
offset += 4;
ppc_qt_put_cinepak_v4_block(
frame,
width,
height,
x,
y,
[
&strip.v4_codebook[usize::from(indices[0])],
&strip.v4_codebook[usize::from(indices[1])],
&strip.v4_codebook[usize::from(indices[2])],
&strip.v4_codebook[usize::from(indices[3])],
],
)?;
}
}
}
Some(())
}
fn ppc_qt_next_cinepak_flag(
data: &[u8],
offset: &mut usize,
flags: &mut u32,
mask: &mut u32,
) -> Option<bool> {
*mask >>= 1;
if *mask == 0 {
let flag_bytes = data.get(*offset..(*offset).checked_add(4)?)?;
*flags = u32::from_be_bytes([flag_bytes[0], flag_bytes[1], flag_bytes[2], flag_bytes[3]]);
*offset = (*offset).checked_add(4)?;
*mask = 0x8000_0000;
}
Some((*flags & *mask) != 0)
}
fn ppc_qt_put_cinepak_v1_block(
frame: &mut [u8],
width: usize,
height: usize,
x: usize,
y: usize,
codebook: &[u8; 12],
) -> Option<()> {
for dy in 0..4usize {
for dx in 0..4usize {
let codebook_index = ((dy / 2) * 2) + (dx / 2);
let color_offset = codebook_index.checked_mul(3)?;
ppc_qt_write_cinepak_rgb(
frame,
width,
height,
x.checked_add(dx)?,
y.checked_add(dy)?,
[
codebook[color_offset],
codebook[color_offset + 1],
codebook[color_offset + 2],
],
)?;
}
}
Some(())
}
fn ppc_qt_put_cinepak_v4_block(
frame: &mut [u8],
width: usize,
height: usize,
x: usize,
y: usize,
codebooks: [&[u8; 12]; 4],
) -> Option<()> {
for dy in 0..4usize {
for dx in 0..4usize {
let codebook_index = if dy >= 2 { 2 } else { 0 } + if dx >= 2 { 1 } else { 0 };
let pixel_index = ((dy % 2) * 2) + (dx % 2);
let color_offset = pixel_index.checked_mul(3)?;
let codebook = codebooks[codebook_index];
ppc_qt_write_cinepak_rgb(
frame,
width,
height,
x.checked_add(dx)?,
y.checked_add(dy)?,
[
codebook[color_offset],
codebook[color_offset + 1],
codebook[color_offset + 2],
],
)?;
}
}
Some(())
}
fn ppc_qt_write_cinepak_rgb(
frame: &mut [u8],
width: usize,
height: usize,
x: usize,
y: usize,
rgb: [u8; 3],
) -> Option<()> {
if x >= width || y >= height {
return Some(());
}
let offset = y.checked_mul(width)?.checked_add(x)?.checked_mul(3)?;
let pixel = frame.get_mut(offset..offset.checked_add(3)?)?;
pixel.copy_from_slice(&rgb);
Some(())
}
fn ppc_qt_draw_movie_frame(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
salt: u32,
) -> bool {
let gworld = if quicktime.movie_gworld != 0 {
quicktime.movie_gworld
} else {
current_gworld
};
let Some(front_buffer) = ppc_live_front_buffer_for_gworld(memory, gworlds, gworld) else {
return false;
};
if ppc_qt_draw_decoded_movie_frame(memory, front_buffer, quicktime) {
return true;
}
ppc_qt_draw_visible_16bpp_frame(
memory,
front_buffer,
ppc_qt_movie_frame_salt(quicktime, salt),
)
}
fn ppc_qt_draw_decoded_movie_frame(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
quicktime: &mut PpcQuickTimeState,
) -> bool {
if front_buffer.depth != 16
|| front_buffer.base_addr == 0
|| front_buffer.width == 0
|| front_buffer.height == 0
|| front_buffer.row_bytes < front_buffer.width.saturating_mul(2)
{
return false;
}
let Some(frame) = ppc_qt_decode_current_movie_video_frame(quicktime) else {
return false;
};
let (top, left, bottom, right) = quicktime.movie_box;
let box_width = i32::from(right) - i32::from(left);
let box_height = i32::from(bottom) - i32::from(top);
if box_width <= 0 || box_height <= 0 {
return false;
}
let dst_left = i32::from(left).max(0).min(front_buffer.width as i32);
let dst_top = i32::from(top).max(0).min(front_buffer.height as i32);
let dst_right = i32::from(right).max(0).min(front_buffer.width as i32);
let dst_bottom = i32::from(bottom).max(0).min(front_buffer.height as i32);
if dst_left >= dst_right || dst_top >= dst_bottom {
return false;
}
let mut wrote_any = false;
for dst_y in dst_top..dst_bottom {
let src_y = usize::try_from(
((dst_y - i32::from(top)) as i64)
.saturating_mul(frame.height as i64)
.checked_div(i64::from(box_height))
.unwrap_or(0)
.clamp(0, frame.height.saturating_sub(1) as i64),
)
.unwrap_or(0);
for dst_x in dst_left..dst_right {
let src_x = usize::try_from(
((dst_x - i32::from(left)) as i64)
.saturating_mul(frame.width as i64)
.checked_div(i64::from(box_width))
.unwrap_or(0)
.clamp(0, frame.width.saturating_sub(1) as i64),
)
.unwrap_or(0);
let Some(rgb_offset) = src_y
.checked_mul(frame.width)
.and_then(|base| base.checked_add(src_x))
.and_then(|pixel| pixel.checked_mul(3))
else {
continue;
};
let Some(rgb) = frame.rgb.get(rgb_offset..rgb_offset.saturating_add(3)) else {
continue;
};
let pixel = ppc_qt_rgb555_from_u8(rgb[0], rgb[1], rgb[2]);
if ppc_q3_write_software_pixel(memory, front_buffer, (dst_x, dst_y), pixel) {
wrote_any = true;
}
}
}
wrote_any
}
fn ppc_qt_rgb555_from_u8(red: u8, green: u8, blue: u8) -> u16 {
fn component(value: u8) -> u16 {
((u16::from(value) * 31) + 127) / 255
}
(component(red) << 10) | (component(green) << 5) | component(blue)
}
fn ppc_qt_movie_frame_salt(quicktime: &PpcQuickTimeState, fallback_salt: u32) -> u32 {
if let Some(samples) = &quicktime.movie_video_samples {
if !samples.samples.is_empty() {
let sample_index = ppc_qt_movie_timed_sample_index(quicktime, samples).unwrap_or(0);
let sample = &samples.samples[sample_index];
return 0x70u32
.saturating_add(u32::try_from(sample_index).unwrap_or(u32::MAX))
.saturating_add(sample.size & 0x0f)
.saturating_add((sample.offset as u32) & 0x0f)
.saturating_add(sample.checksum & 0x0f)
.saturating_add(u32::from(sample.preview[0] & 0x0f))
.saturating_add(samples.codec.rotate_left(7) & 0x0f);
}
}
let Some(track) = quicktime.movie_video_track else {
return fallback_salt;
};
let sample_index = ppc_qt_movie_sample_index(
quicktime,
usize::try_from(track.sample_count.max(1)).unwrap_or(usize::MAX),
)
.and_then(|index| u32::try_from(index).ok())
.unwrap_or(u32::MAX);
0x70u32
.saturating_add(sample_index)
.saturating_add(track.first_sample_size & 0x0f)
.saturating_add((track.first_chunk_offset as u32) & 0x0f)
.saturating_add(track.first_sample_checksum & 0x0f)
.saturating_add(u32::from(track.first_sample_preview[0] & 0x0f))
.saturating_add(track.codec.rotate_left(7) & 0x0f)
}
fn ppc_qt_movie_sample_index(quicktime: &PpcQuickTimeState, sample_count: usize) -> Option<usize> {
if sample_count == 0 {
return None;
}
let sample_count_u64 = u64::try_from(sample_count).ok()?;
usize::try_from(
u64::from(quicktime.movie_task_count)
.saturating_mul(sample_count_u64)
.checked_div(u64::from(quicktime.movie_tasks_until_done.max(1)))
.unwrap_or(0)
.min(sample_count_u64.saturating_sub(1)),
)
.ok()
}
fn ppc_qt_movie_timed_sample_index(
quicktime: &PpcQuickTimeState,
samples: &PpcQuickTimeVideoSampleTableRecord,
) -> Option<usize> {
if samples.samples.is_empty() {
return None;
}
let media_duration = samples.media_duration.max(1);
let movie_time = u64::from(quicktime.movie_task_count)
.saturating_mul(media_duration)
.checked_div(u64::from(quicktime.movie_tasks_until_done.max(1)))
.unwrap_or(0)
.min(media_duration.saturating_sub(1));
samples
.samples
.iter()
.position(|sample| {
let sample_end = sample
.media_start_time
.saturating_add(u64::from(sample.duration));
movie_time >= sample.media_start_time && movie_time < sample_end
})
.or_else(|| samples.samples.len().checked_sub(1))
}
fn ppc_qt_draw_visible_16bpp_frame(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
salt: u32,
) -> bool {
if front_buffer.depth != 16
|| front_buffer.base_addr == 0
|| front_buffer.width == 0
|| front_buffer.height == 0
|| front_buffer.row_bytes < front_buffer.width.saturating_mul(2)
{
return false;
}
let x_denom = front_buffer.width.saturating_sub(1).max(1);
let y_denom = front_buffer.height.saturating_sub(1).max(1);
let mut wrote_any = false;
for y in 0..front_buffer.height {
for x in 0..front_buffer.width {
let red = ((x.saturating_mul(31)) / x_denom) as u16;
let green = ((y.saturating_mul(31)) / y_denom) as u16;
let blue = ((x ^ y ^ salt) & 0x1f) as u16;
let pixel = (red << 10) | (green << 5) | blue;
if ppc_q3_write_software_pixel(memory, front_buffer, (x as i32, y as i32), pixel) {
wrote_any = true;
}
}
}
wrote_any
}
fn ppc_gestalt(cpu: &mut PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let selector = cpu.gpr[3];
let response_ptr = cpu.gpr[4];
if response_ptr == 0 {
return PPC_PARAM_ERR;
}
let Some((response, err)) = ppc_gestalt_response(selector) else {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Gestalt({:?}) -> gestaltUndefSelectorErr",
ppc_res_type_text(selector)
);
}
if memory.write_u32_be(response_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
return PPC_GESTALT_UNDEF_SELECTOR_ERR;
};
if memory.write_u32_be(response_ptr, response).is_none() {
return PPC_PARAM_ERR;
}
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Gestalt({:?}) -> ${response:08X} err={err}",
ppc_res_type_text(selector)
);
}
err
}
fn ppc_gestalt_response(selector: u32) -> Option<(u32, i16)> {
match &selector.to_be_bytes() {
b"vers" => Some((0x0001, PPC_NO_ERR)),
b"sysv" => Some((
u32::from(REFERENCE_MACHINE_PROFILE.system_version_bcd),
PPC_NO_ERR,
)),
b"ostt" => Some((crate::trap::dispatch::OS_TRAP_TABLE_BASE, PPC_NO_ERR)),
b"tbtt" => Some((crate::trap::dispatch::TOOLBOX_TRAP_TABLE_BASE, PPC_NO_ERR)),
b"evnt" => Some((0x0001, PPC_NO_ERR)),
b"cput" => Some((
REFERENCE_POWERPC_EXECUTION_CAPABILITIES.native_cpu_type,
PPC_NO_ERR,
)),
b"proc" => Some((
REFERENCE_POWERPC_EXECUTION_CAPABILITIES.processor_type,
PPC_NO_ERR,
)),
b"mach" => Some((
u32::from(REFERENCE_MACHINE_PROFILE.gestalt_machine_type),
PPC_NO_ERR,
)),
// Match the 68K toolbox profile: System 7 Color QuickDraw 1.3.
// Reporting only the original 32-Bit QuickDraw release makes native
// PPC applications select obsolete monochrome-GWorld fallbacks.
b"qd " => Some((0x0230, PPC_NO_ERR)),
b"qdrw" => Some((0x000F, PPC_NO_ERR)),
b"ram " => Some((REFERENCE_MACHINE_PROFILE.ram_size_bytes, PPC_NO_ERR)),
b"fpu " => Some((
REFERENCE_POWERPC_EXECUTION_CAPABILITIES.fpu_type,
PPC_NO_ERR,
)),
b"mmu " => Some((
REFERENCE_POWERPC_EXECUTION_CAPABILITIES.mmu_type,
PPC_NO_ERR,
)),
b"snd " => Some((0x1CFB, PPC_NO_ERR)),
b"tmgr" => Some((2, PPC_NO_ERR)),
b"dplv" => Some((0x0002_0006, PPC_NO_ERR)),
b"dply" => Some((0x0000_0007, PPC_NO_ERR)),
b"alis" => Some((1, PPC_NO_ERR)),
b"fs " => Some(((1 << 0) | (1 << 1), PPC_NO_ERR)),
b"fold" => Some((1, PPC_NO_ERR)),
b"qtim" => Some((PPC_QUICKTIME_VERSION, PPC_NO_ERR)),
b"drag" => Some((0, PPC_NO_ERR)),
b"os " => Some((0x00FF, PPC_NO_ERR)),
b"powr" => Some((0, PPC_NO_ERR)),
b"appr" => Some((1, PPC_NO_ERR)),
b"addr" => Some((0b111, PPC_NO_ERR)),
b"sdev" => Some((0, PPC_NO_ERR)),
b"stdf" => Some((1, PPC_NO_ERR)),
b"help" => Some((1, PPC_NO_ERR)),
b"vm " => Some((0, PPC_NO_ERR)),
b"cfrg" => Some((1, PPC_NO_ERR)),
b"mixd" => Some((1, PPC_NO_ERR)),
b"qd3d" => Some((1, PPC_NO_ERR)),
b"q3v " => Some((PPC_QD3D_VERSION, PPC_NO_ERR)),
b"a/ux" => Some((0, PPC_GESTALT_UNDEF_SELECTOR_ERR)),
_ => None,
}
}
pub(super) fn ppc_main_screen_buffer_size() -> u32 {
ppc_row_bytes(PPC_MAIN_SCREEN_WIDTH, PPC_MAIN_SCREEN_STORAGE_DEPTH).unwrap()
* PPC_MAIN_SCREEN_HEIGHT
}
pub(super) fn ppc_main_screen_row_bytes() -> u32 {
ppc_row_bytes(PPC_MAIN_SCREEN_WIDTH, PPC_MAIN_PIXEL_DEPTH).unwrap()
}
fn ppc_seed_main_gworld(memory: &mut PpcSectionMem) -> PpcGWorldRecord {
let row_bytes = ppc_main_screen_row_bytes();
let _ = ppc_seed_main_color_table(memory);
let _ = memory.write_u32_be(PPC_GRAY_RGN_HANDLE, PPC_GRAY_RGN);
let _ = memory.write_u32_be(PPC_GRAY_RGN_ADDR, PPC_GRAY_RGN_HANDLE);
let _ = memory.write_u16_be(PPC_GRAY_RGN, 10);
// Macintosh Toolbox Essentials (1992), pp. 3-112 and 4-16: GrayRgn is
// the desktop area below the menu bar, whose live height is MBarHeight.
let menu_bar_height = u32::from(memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap_or(20))
.min(PPC_MAIN_SCREEN_HEIGHT) as i16;
let _ = ppc_write_rect(
memory,
PPC_GRAY_RGN + 2,
menu_bar_height,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
);
let _ = memory.write_u32_be(PPC_MAIN_DCE_HANDLE, PPC_MAIN_DCE);
let _ = memory.write_u16_be(PPC_MAIN_DCE + 24, 0);
let _ = memory.write_u32_be(PPC_MAIN_DCE + 42, PPC_MAIN_SCREEN_BASE);
let _ = memory.write_u32_be(PPC_MAIN_PIXMAP_HANDLE, PPC_MAIN_PIXMAP);
let _ = ppc_write_pixmap(
memory,
PPC_MAIN_PIXMAP,
PPC_MAIN_SCREEN_BASE,
row_bytes,
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
PPC_MAIN_PIXEL_DEPTH,
);
let _ = memory.write_u32_be(PPC_MAIN_PIXMAP + 42, PPC_MAIN_CTABLE_HANDLE);
let _ = ppc_write_gworld_port(
memory,
PPC_MAIN_GWORLD,
PPC_MAIN_PIXMAP_HANDLE,
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
);
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 2-38--2-42:
// every open graphics port owns valid visible and clipping regions.
let _ = memory.write_u32_be(PPC_MAIN_VIS_RGN_HANDLE, PPC_MAIN_VIS_RGN);
let _ = memory.write_u32_be(PPC_MAIN_CLIP_RGN_HANDLE, PPC_MAIN_CLIP_RGN);
let _ = memory.write_u32_be(
PPC_MAIN_GWORLD + PPC_CGRAF_PORT_VIS_RGN_OFFSET,
PPC_MAIN_VIS_RGN_HANDLE,
);
let _ = memory.write_u32_be(
PPC_MAIN_GWORLD + PPC_CGRAF_PORT_CLIP_RGN_OFFSET,
PPC_MAIN_CLIP_RGN_HANDLE,
);
let _ = ppc_write_rgn_bbox(
memory,
PPC_MAIN_VIS_RGN_HANDLE,
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
);
let _ = ppc_write_rgn_bbox(
memory,
PPC_MAIN_CLIP_RGN_HANDLE,
i16::MIN,
i16::MIN,
i16::MAX,
i16::MAX,
);
let _ = memory.write_u32_be(PPC_MAIN_GDEVICE, PPC_MAIN_GDEVICE_RECORD);
let _ = ppc_write_gdevice(
memory,
PPC_MAIN_GDEVICE_RECORD,
PPC_MAIN_PIXMAP_HANDLE,
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
);
let record = PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_MAIN_GWORLD,
pixmap_handle: PPC_MAIN_PIXMAP_HANDLE,
pixmap: PPC_MAIN_PIXMAP,
base_addr: PPC_MAIN_SCREEN_BASE,
gdevice: PPC_MAIN_GDEVICE,
width: PPC_MAIN_SCREEN_WIDTH,
height: PPC_MAIN_SCREEN_HEIGHT,
depth: PPC_MAIN_PIXEL_DEPTH,
row_bytes,
pixels_locked: false,
pixels_no_purge: true,
};
let front_buffer = PpcFrontBuffer {
base_addr: record.base_addr,
row_bytes: record.row_bytes,
width: record.width,
height: record.height,
depth: record.depth,
};
let fallback = TrapDispatcher::standard_mac_indexed_clut(front_buffer.depth as u16)
.map(|(clut, _)| clut)
.unwrap_or_else(TrapDispatcher::standard_mac_8bpp_clut);
let clut = ppc_read_ctable_clut(memory, PPC_MAIN_CTABLE_HANDLE, &fallback).unwrap_or(fallback);
let entry_count = ppc_indexed_depth_entry_count(front_buffer.depth).unwrap_or(256);
let black = u16::from(ppc_rgb_color_to_index_in_clut(
ppc_standard_desktop_color(std::slice::from_ref(&record), 0, 0),
&clut,
entry_count,
));
let white = u16::from(ppc_rgb_color_to_index_in_clut(
ppc_standard_desktop_color(std::slice::from_ref(&record), 1, 0),
&clut,
entry_count,
));
for v in i32::from(menu_bar_height)..PPC_MAIN_SCREEN_HEIGHT as i32 {
if front_buffer.depth == 8 {
let row = (0..PPC_MAIN_SCREEN_WIDTH as i32)
.map(|h| {
if crate::window_manager::standard_desktop_pattern_is_ink(h, v) {
black as u8
} else {
white as u8
}
})
.collect::<Vec<_>>();
let _ = memory.write_bytes(
front_buffer.base_addr + v as u32 * front_buffer.row_bytes,
&row,
);
} else {
for h in 0..PPC_MAIN_SCREEN_WIDTH as i32 {
let pixel = if crate::window_manager::standard_desktop_pattern_is_ink(h, v) {
black
} else {
white
};
let _ = ppc_quickdraw_write_raw_pixel(memory, front_buffer, (h, v), pixel);
}
}
}
record
}
fn ppc_init_graf(memory: &mut PpcSectionMem, gworlds: &[PpcGWorldRecord], global_ptr: u32) -> bool {
// InitGraf receives the address of QDGlobals.thePort. In the classic
// reverse layout, randSeed begins 126 bytes before that pointer and the
// 14-byte screenBits record begins 122 bytes before it.
let Some(globals_base) = global_ptr.checked_sub(126) else {
return false;
};
if !ppc_memory_can_write_bytes(memory, globals_base, 130) {
return false;
}
let Some(front_buffer) = ppc_front_buffer_for_gworld(gworlds, PPC_MAIN_GWORLD) else {
return false;
};
let white = [0x00; 8];
let black = [0xff; 8];
let gray = [0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55];
let lt_gray = [0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22];
let dk_gray = [0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd];
let (arrow_data, arrow_mask, arrow_hot_v, arrow_hot_h) = TrapDispatcher::default_arrow_cursor();
let arrow = global_ptr - 108;
let screen_bits = global_ptr - 122;
memory.write_u32_be(globals_base, 1).is_some()
&& memory
.write_u32_be(screen_bits, front_buffer.base_addr)
.is_some()
&& memory
.write_u16_be(screen_bits + 4, front_buffer.row_bytes as u16 & 0x3fff)
.is_some()
&& ppc_write_rect(
memory,
screen_bits + 6,
0,
0,
ppc_u32_to_i16_saturating(front_buffer.height),
ppc_u32_to_i16_saturating(front_buffer.width),
)
.is_some()
&& memory.write_bytes(arrow, &arrow_data).is_some()
&& memory.write_bytes(arrow + 32, &arrow_mask).is_some()
&& memory
.write_u16_be(arrow + 64, arrow_hot_v as u16)
.is_some()
&& memory
.write_u16_be(arrow + 66, arrow_hot_h as u16)
.is_some()
&& memory.write_bytes(global_ptr - 40, &dk_gray).is_some()
&& memory.write_bytes(global_ptr - 32, <_gray).is_some()
&& memory.write_bytes(global_ptr - 24, &gray).is_some()
&& memory.write_bytes(global_ptr - 16, &black).is_some()
&& memory.write_bytes(global_ptr - 8, &white).is_some()
&& memory.write_u32_be(global_ptr, PPC_MAIN_GWORLD).is_some()
}
fn ppc_seed_main_color_table(memory: &mut PpcSectionMem) -> Option<()> {
memory.write_u32_be(PPC_MAIN_CTABLE_HANDLE, PPC_MAIN_CTABLE)?;
memory.write_u32_be(PPC_MAIN_CTABLE, PPC_MAIN_PIXEL_DEPTH)?;
memory.write_u16_be(PPC_MAIN_CTABLE + 4, 0x8000)?;
memory.write_u16_be(PPC_MAIN_CTABLE + 6, 255)?;
for (index, [red, green, blue]) in TrapDispatcher::standard_mac_8bpp_clut()
.into_iter()
.enumerate()
{
let entry = PPC_MAIN_CTABLE.checked_add(8 + index as u32 * 8)?;
memory.write_u16_be(entry, index as u16)?;
memory.write_u16_be(entry + 2, red)?;
memory.write_u16_be(entry + 4, green)?;
memory.write_u16_be(entry + 6, blue)?;
}
// Imaging With QuickDraw (1994), pp. 4-46 and 5-14: an indexed main
// device PixMap owns a 256-entry ColorTable whose ctFlags device bit is
// set and whose RGB entries mirror the hardware CLUT.
Some(())
}
fn ppc_seed_dsp_back_gworld(memory: &mut PpcSectionMem) -> PpcGWorldRecord {
let row_bytes = ppc_main_screen_row_bytes();
let _ = memory.write_u32_be(PPC_DSP_BACK_PIXMAP_HANDLE, PPC_DSP_BACK_PIXMAP);
let _ = ppc_write_pixmap(
memory,
PPC_DSP_BACK_PIXMAP,
PPC_DSP_BACK_SCREEN_BASE,
row_bytes,
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
PPC_MAIN_PIXEL_DEPTH,
);
let _ = memory.write_u32_be(PPC_DSP_BACK_PIXMAP + 42, PPC_MAIN_CTABLE_HANDLE);
let _ = ppc_write_gworld_port(
memory,
PPC_DSP_BACK_GWORLD,
PPC_DSP_BACK_PIXMAP_HANDLE,
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
);
let _ = memory.write_u32_be(PPC_DSP_BACK_VIS_RGN_HANDLE, PPC_DSP_BACK_VIS_RGN);
let _ = memory.write_u32_be(PPC_DSP_BACK_CLIP_RGN_HANDLE, PPC_DSP_BACK_CLIP_RGN);
let _ = memory.write_u32_be(
PPC_DSP_BACK_GWORLD + PPC_CGRAF_PORT_VIS_RGN_OFFSET,
PPC_DSP_BACK_VIS_RGN_HANDLE,
);
let _ = memory.write_u32_be(
PPC_DSP_BACK_GWORLD + PPC_CGRAF_PORT_CLIP_RGN_OFFSET,
PPC_DSP_BACK_CLIP_RGN_HANDLE,
);
let _ = ppc_write_rgn_bbox(
memory,
PPC_DSP_BACK_VIS_RGN_HANDLE,
0,
0,
PPC_MAIN_SCREEN_HEIGHT as i16,
PPC_MAIN_SCREEN_WIDTH as i16,
);
let _ = ppc_write_rgn_bbox(
memory,
PPC_DSP_BACK_CLIP_RGN_HANDLE,
i16::MIN,
i16::MIN,
i16::MAX,
i16::MAX,
);
PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port: PPC_DSP_BACK_GWORLD,
pixmap_handle: PPC_DSP_BACK_PIXMAP_HANDLE,
pixmap: PPC_DSP_BACK_PIXMAP,
base_addr: PPC_DSP_BACK_SCREEN_BASE,
gdevice: PPC_MAIN_GDEVICE,
width: PPC_MAIN_SCREEN_WIDTH,
height: PPC_MAIN_SCREEN_HEIGHT,
depth: PPC_MAIN_PIXEL_DEPTH,
row_bytes,
pixels_locked: false,
pixels_no_purge: true,
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_open_port(
cpu: &PpcCpu,
allocator: &mut PpcProcessAllocatorView<'_>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
gworlds: &mut Vec<PpcGWorldRecord>,
current_gdevice: u32,
) -> bool {
let port = cpu.gpr[3];
if port == 0 || !ppc_memory_can_write_bytes(memory, port, PPC_GRAF_PORT_SIZE) {
*last_mem_error = PPC_PARAM_ERR;
return false;
}
let pixmap_handle = memory
.read_u32_be(current_gdevice)
.and_then(|gdevice| memory.read_u32_be(gdevice.checked_add(22)?))
.unwrap_or(PPC_MAIN_PIXMAP_HANDLE);
let bits = ppc_read_pixmap_handle_bits(memory, pixmap_handle).unwrap_or(PpcPixMapBits {
base_addr: PPC_MAIN_SCREEN_BASE,
row_bytes: ppc_main_screen_row_bytes(),
top: 0,
left: 0,
bottom: PPC_MAIN_SCREEN_HEIGHT as i16,
right: PPC_MAIN_SCREEN_WIDTH as i16,
width: PPC_MAIN_SCREEN_WIDTH,
height: PPC_MAIN_SCREEN_HEIGHT,
depth: PPC_MAIN_PIXEL_DEPTH,
});
let vis_rgn = ppc_allocator_view_new_rgn(
Some(allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
let clip_rgn = ppc_allocator_view_new_rgn(
Some(allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
if vis_rgn == 0 || clip_rgn == 0 {
return false;
}
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 2-38--2-40:
// OpenPort copies screenBits into the caller-owned GrafPort, creates its
// visible and clipping regions, and makes the new port current.
let cleared = vec![0; PPC_GRAF_PORT_SIZE as usize];
if memory.write_bytes(port, &cleared).is_none()
|| memory.write_u32_be(port + 2, bits.base_addr).is_none()
|| memory
.write_u16_be(port + 6, bits.row_bytes as u16 & 0x3fff)
.is_none()
|| ppc_write_rect(
memory,
port + 8,
bits.top,
bits.left,
bits.bottom,
bits.right,
)
.is_none()
|| ppc_write_rect(
memory,
port + 16,
bits.top,
bits.left,
bits.bottom,
bits.right,
)
.is_none()
|| memory.write_u32_be(port + 24, vis_rgn).is_none()
|| memory
.write_u32_be(port + PPC_CGRAF_PORT_CLIP_RGN_OFFSET, clip_rgn)
.is_none()
|| ppc_write_rgn_bbox(
memory,
vis_rgn,
bits.top,
bits.left,
bits.bottom,
bits.right,
)
.is_none()
|| ppc_write_rgn_bbox(memory, clip_rgn, i16::MIN, i16::MIN, i16::MAX, i16::MAX).is_none()
|| memory.write_bytes(port + 32, &[0xff; 8]).is_none()
|| memory
.write_u16_be(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET, 1)
.is_none()
|| memory
.write_u16_be(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2, 1)
.is_none()
|| memory
.write_u16_be(
port + PPC_CGRAF_PORT_PN_MODE_OFFSET,
PPC_QD_PEN_MODE_PAT_COPY as u16,
)
.is_none()
|| memory
.write_u16_be(
port + PPC_CGRAF_PORT_TX_MODE_OFFSET,
PPC_QD_TEXT_MODE_SRC_OR as u16,
)
.is_none()
{
*last_mem_error = PPC_PARAM_ERR;
return false;
}
gworlds.retain(|gworld| gworld.port != port);
gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle,
pixmap: memory.read_u32_be(pixmap_handle).unwrap_or(PPC_MAIN_PIXMAP),
base_addr: bits.base_addr,
gdevice: current_gdevice,
width: bits.width,
height: bits.height,
depth: bits.depth,
row_bytes: bits.row_bytes,
pixels_locked: false,
pixels_no_purge: true,
});
*last_mem_error = PPC_NO_ERR;
true
}
fn ppc_open_cport(
cpu: &PpcCpu,
allocator: &mut PpcProcessAllocatorView<'_>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
gworlds: &mut Vec<PpcGWorldRecord>,
current_gdevice: u32,
) -> bool {
let port = cpu.gpr[3];
if port == 0 || !ppc_memory_can_write_bytes(memory, port, PPC_CGRAF_PORT_SIZE) {
*last_mem_error = PPC_PARAM_ERR;
return false;
}
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 4-64--4-66:
// OpenCPort allocates its port PixMap and initializes it from the current
// GDevice's PixMap, including its bounds, row bytes, depth, and base.
let screen_pixmap_handle = memory
.read_u32_be(current_gdevice)
.and_then(|gdevice| memory.read_u32_be(gdevice.checked_add(22)?));
let screen_color_table = screen_pixmap_handle
.and_then(|pixmap_handle| memory.read_u32_be(pixmap_handle))
.and_then(|pixmap| memory.read_u32_be(pixmap.checked_add(42)?))
.filter(|handle| *handle != 0)
.unwrap_or(PPC_MAIN_CTABLE_HANDLE);
let screen_bits = screen_pixmap_handle
.and_then(|pixmap_handle| ppc_read_pixmap_handle_bits(memory, pixmap_handle));
let bits = screen_bits.unwrap_or(PpcPixMapBits {
base_addr: PPC_MAIN_SCREEN_BASE,
row_bytes: ppc_main_screen_row_bytes(),
top: 0,
left: 0,
bottom: PPC_MAIN_SCREEN_HEIGHT as i16,
right: PPC_MAIN_SCREEN_WIDTH as i16,
width: PPC_MAIN_SCREEN_WIDTH,
height: PPC_MAIN_SCREEN_HEIGHT,
depth: PPC_MAIN_PIXEL_DEPTH,
});
if bits.row_bytes == 0 || !matches!(bits.depth, 1 | 2 | 4 | 8 | 16 | 32) {
*last_mem_error = PPC_PARAM_ERR;
return false;
}
if !ppc_heap_can_alloc_sequence(memory, *heap_cursor, heap_limit, &[PPC_PIXMAP_SIZE, 4]) {
*last_mem_error = PPC_MEM_FULL_ERR;
return false;
}
let pixmap = allocator.reserve_bytes(memory, heap_cursor, PPC_PIXMAP_SIZE, true);
let pixmap_handle = allocator.reserve_bytes(memory, heap_cursor, 4, true);
let vis_rgn = ppc_allocator_view_new_rgn(
Some(allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
let clip_rgn = ppc_allocator_view_new_rgn(
Some(allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
if pixmap == 0
|| pixmap_handle == 0
|| vis_rgn == 0
|| clip_rgn == 0
|| memory.write_u32_be(pixmap_handle, pixmap).is_none()
|| ppc_write_pixmap(
memory,
pixmap,
bits.base_addr,
bits.row_bytes,
bits.top,
bits.left,
bits.bottom,
bits.right,
bits.depth,
)
.is_none()
|| memory
.write_u32_be(
pixmap + 42,
if bits.depth <= 8 {
screen_color_table
} else {
0
},
)
.is_none()
|| ppc_write_gworld_port(
memory,
port,
pixmap_handle,
bits.top,
bits.left,
bits.bottom,
bits.right,
)
.is_none()
|| memory.write_u32_be(port + 24, vis_rgn).is_none()
|| memory
.write_u32_be(port + PPC_CGRAF_PORT_CLIP_RGN_OFFSET, clip_rgn)
.is_none()
|| ppc_write_rgn_bbox(
memory,
vis_rgn,
bits.top,
bits.left,
bits.bottom,
bits.right,
)
.is_none()
|| ppc_write_rgn_bbox(memory, clip_rgn, i16::MIN, i16::MIN, i16::MAX, i16::MAX).is_none()
{
*last_mem_error = PPC_PARAM_ERR;
return false;
}
let (width, height) = ppc_rect_dimensions(bits.top, bits.left, bits.bottom, bits.right);
gworlds.retain(|gworld| gworld.port != port);
gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle,
pixmap,
base_addr: bits.base_addr,
gdevice: current_gdevice,
width,
height,
depth: bits.depth,
row_bytes: bits.row_bytes,
pixels_locked: false,
pixels_no_purge: true,
});
*last_mem_error = PPC_NO_ERR;
true
}
fn ppc_close_cport(
port: u32,
gworlds: &mut Vec<PpcGWorldRecord>,
current_gworld: &mut u32,
current_gdevice: &mut u32,
) {
// Inside Macintosh: Imaging With QuickDraw (1994), p. 4-67: CloseCPort
// releases the structures owned by a CGrafPort while leaving caller-owned
// port storage and the display device's color table intact.
gworlds.retain(|gworld| {
matches!(gworld.port, PPC_MAIN_GWORLD | PPC_DSP_BACK_GWORLD) || gworld.port != port
});
if *current_gworld == port {
*current_gworld = PPC_MAIN_GWORLD;
*current_gdevice = PPC_MAIN_GDEVICE;
}
}
fn ppc_set_port_bits(
memory: &mut PpcSectionMem,
current_port: u32,
bits_or_pixmap: u32,
color: bool,
) {
if current_port == 0 || bits_or_pixmap == 0 {
return;
}
let is_color_port = memory
.read_u16_be(current_port.wrapping_add(6))
.is_some_and(|row_bytes| row_bytes & 0xc000 == 0xc000);
if color {
if is_color_port {
let _ = memory.write_u32_be(current_port + 2, bits_or_pixmap);
}
return;
}
if is_color_port || !ppc_memory_can_write_bytes(memory, bits_or_pixmap, 14) {
return;
}
if let Some(bitmap) = ppc_memory_read_bytes(memory, bits_or_pixmap, 14) {
// Imaging With QuickDraw (1994), pp. 2-50 and 4-86--4-87:
// SetPortBits copies the complete 14-byte BitMap into a basic port;
// SetPortPix instead replaces the PixMap handle of a color port.
let _ = memory.write_bytes(current_port + 2, &bitmap);
}
}
fn ppc_color_table_bytes(seed: u32, colors: &[[u16; 3]]) -> Option<Vec<u8>> {
let last_index = colors.len().checked_sub(1)?;
let last_index = u16::try_from(last_index).ok()?;
let mut bytes = Vec::with_capacity(8usize.checked_add(colors.len().checked_mul(8)?)?);
bytes.extend_from_slice(&seed.to_be_bytes());
bytes.extend_from_slice(&0u16.to_be_bytes());
bytes.extend_from_slice(&last_index.to_be_bytes());
for (index, [red, green, blue]) in colors.iter().copied().enumerate() {
bytes.extend_from_slice(&u16::try_from(index).ok()?.to_be_bytes());
bytes.extend_from_slice(&red.to_be_bytes());
bytes.extend_from_slice(&green.to_be_bytes());
bytes.extend_from_slice(&blue.to_be_bytes());
}
Some(bytes)
}
fn ppc_default_color_table_bytes(depth: u32) -> Option<Vec<u8>> {
let colors = match depth {
1 => vec![[0xffff, 0xffff, 0xffff], [0, 0, 0]],
2 => vec![
[0xffff, 0xffff, 0xffff],
[0xaaaa, 0xaaaa, 0xaaaa],
[0x5555, 0x5555, 0x5555],
[0, 0, 0],
],
4 => TrapDispatcher::standard_mac_4bpp_gworld_clut()[..16].to_vec(),
8 => TrapDispatcher::standard_mac_8bpp_clut().to_vec(),
_ => return None,
};
ppc_color_table_bytes(depth, &colors)
}
fn ppc_copy_color_table_bytes(memory: &mut PpcSectionMem, handle: u32) -> Option<Vec<u8>> {
let table = memory.read_u32_be(handle).filter(|table| *table != 0)?;
let last_index = usize::from(memory.read_u16_be(table.checked_add(6)?)?);
if last_index >= 256 {
return None;
}
let size = 8u32.checked_add(
u32::try_from(last_index.checked_add(1)?)
.ok()?
.checked_mul(8)?,
)?;
ppc_memory_read_bytes(memory, table, size)
}
#[derive(Clone)]
struct PpcGWorldClut {
colors: [[u16; 3]; 256],
valid: [bool; 256],
}
fn ppc_color_table_clut_from_bytes(bytes: &[u8]) -> Option<PpcGWorldClut> {
let flags = u16::from_be_bytes(bytes.get(4..6)?.try_into().ok()?);
let last_entry = usize::from(u16::from_be_bytes(bytes.get(6..8)?.try_into().ok()?));
let entry_count = last_entry.checked_add(1)?.min(256);
let mut clut = [[0; 3]; 256];
let mut valid = [false; 256];
for slot in 0..entry_count {
let offset = 8usize.checked_add(slot.checked_mul(8)?)?;
let entry = bytes.get(offset..offset.checked_add(8)?)?;
let value = usize::from(u16::from_be_bytes(entry.get(0..2)?.try_into().ok()?));
let index = if flags & 0x8000 != 0 { slot } else { value };
if index >= clut.len() {
continue;
}
valid[index] = true;
clut[index] = [
u16::from_be_bytes(entry.get(2..4)?.try_into().ok()?),
u16::from_be_bytes(entry.get(4..6)?.try_into().ok()?),
u16::from_be_bytes(entry.get(6..8)?.try_into().ok()?),
];
}
Some(PpcGWorldClut {
colors: clut,
valid,
})
}
#[allow(clippy::too_many_arguments)]
fn ppc_new_gworld(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
gworlds: &mut Vec<PpcGWorldRecord>,
gworld_allocations: &mut HashMap<u32, PpcGWorldAllocationRecord>,
current_gdevice: u32,
) -> i16 {
let gworld_out_ptr = cpu.gpr[3];
let requested_depth = cpu.gpr[4] as u16 as i16;
let bounds_ptr = cpu.gpr[5];
let requested_ctab = cpu.gpr[6];
let requested_gdevice = cpu.gpr[7];
let flags = cpu.gpr[8];
if gworld_out_ptr == 0 || bounds_ptr == 0 {
*last_mem_error = PPC_PARAM_ERR;
return PPC_PARAM_ERR;
}
let Some((requested_top, requested_left, requested_bottom, requested_right)) =
ppc_read_rect(memory, bounds_ptr)
else {
*last_mem_error = PPC_PARAM_ERR;
return PPC_PARAM_ERR;
};
let (width, height) = ppc_rect_dimensions(
requested_top,
requested_left,
requested_bottom,
requested_right,
);
const NO_NEW_DEVICE: u32 = 1 << 1;
// Imaging With QuickDraw (1994), pp. 6-16--6-20: literal depths are
// exactly 0, 1, 2, 4, 8, 16, and 32. A zero depth rescans screen devices
// even when noNewDevice is present; this single-display runtime selects
// the physical main device for both the source PixMap and attachment.
let uses_explicit_gdevice =
flags & NO_NEW_DEVICE != 0 && requested_gdevice != 0 && requested_depth != 0;
if !matches!(requested_depth, 0 | 1 | 2 | 4 | 8 | 16 | 32) {
*last_mem_error = PPC_C_DEPTH_ERR;
return PPC_C_DEPTH_ERR;
}
let selected_gdevice = if uses_explicit_gdevice {
requested_gdevice
} else if requested_depth == 0 {
PPC_MAIN_GDEVICE
} else {
current_gdevice
};
let device_pixmap = ppc_current_gdevice_record(memory, selected_gdevice)
.and_then(|device| memory.read_u32_be(device.checked_add(22)?))
.filter(|handle| *handle != 0)
.and_then(|handle| memory.read_u32_be(handle))
.filter(|pixmap| *pixmap != 0);
if uses_explicit_gdevice && device_pixmap.is_none() {
*last_mem_error = PPC_PARAM_ERR;
return PPC_PARAM_ERR;
}
let device_depth = device_pixmap
.and_then(|pixmap| memory.read_u16_be(pixmap + 32))
.map(u32::from)
.filter(|depth| *depth != 0);
if (uses_explicit_gdevice || requested_depth == 0) && device_depth.is_none() {
*last_mem_error = PPC_C_DEPTH_ERR;
return PPC_C_DEPTH_ERR;
}
let depth = if uses_explicit_gdevice || requested_depth == 0 {
device_depth.unwrap_or(PPC_MAIN_PIXEL_DEPTH)
} else {
requested_depth as u32
};
if !matches!(depth, 1 | 2 | 4 | 8 | 16 | 32) {
*last_mem_error = PPC_C_DEPTH_ERR;
return PPC_C_DEPTH_ERR;
}
let Some(row_bytes) = ppc_row_bytes(width, depth).filter(|row_bytes| *row_bytes <= 0x3fff)
else {
*last_mem_error = PPC_PARAM_ERR;
return PPC_PARAM_ERR;
};
let Some(buffer_size) = row_bytes.checked_mul(height) else {
return PPC_PARAM_ERR;
};
// QuickDraw owns a PixMap's pixel storage separately from the PixMap
// record itself. Keep a trailing scanline in that storage allocation so
// classic renderers that finish with aligned stores at the logical image
// boundary cannot overwrite the following PixMap metadata.
let Some(pixel_allocation_size) = buffer_size.checked_add(row_bytes.max(64)) else {
return PPC_PARAM_ERR;
};
let ctable_bytes = if depth <= 8 {
if requested_depth == 0 || uses_explicit_gdevice {
ppc_gdevice_ctable_handle(memory, selected_gdevice)
.and_then(|handle| ppc_copy_color_table_bytes(memory, handle))
} else if requested_ctab != 0 {
ppc_copy_color_table_bytes(memory, requested_ctab)
} else {
ppc_default_color_table_bytes(depth)
}
} else {
None
};
if depth <= 8 && ctable_bytes.is_none() {
*last_mem_error = PPC_PARAM_ERR;
return PPC_PARAM_ERR;
}
let has_positive_bounds = requested_bottom > requested_top && requested_right > requested_left;
let (top, left, bottom, right) = if !has_positive_bounds {
(
0,
0,
ppc_u32_to_i16_saturating(height),
ppc_u32_to_i16_saturating(width),
)
} else {
(
requested_top,
requested_left,
requested_bottom,
requested_right,
)
};
if !ppc_memory_can_write_bytes(memory, gworld_out_ptr, 4) {
*last_mem_error = PPC_PARAM_ERR;
return PPC_PARAM_ERR;
}
let raw_allocation_size = [
pixel_allocation_size,
PPC_PIXMAP_SIZE,
4,
PPC_CGRAF_PORT_SIZE,
]
.into_iter()
.try_fold(0u32, |total, size| {
total.checked_add(ppc_allocation_size(size)?)
});
let Some(raw_allocation_size) = raw_allocation_size else {
*last_mem_error = PPC_MEM_FULL_ERR;
return PPC_MEM_FULL_ERR;
};
// Imaging With QuickDraw (1994), pp. 6-12 and 6-16--6-20: an
// offscreen world owns a PixMap and associated ColorTable. noNewDevice
// reuses the requested GDevice record, not its mutable ColorTable handle;
// snapshot that table so later screen palette changes do not reinterpret
// pixels already rendered into the offscreen world.
let heap_cursor_before = *heap_cursor;
let native_manager_before = process_memory_manager.detached_clone();
let ctable_handle = ctable_bytes
.as_deref()
.map(|bytes| process_memory_manager.copy_bytes_to_new_native_handle(memory, bytes))
.unwrap_or(0);
// Keep all nonrelocatable GWorld storage in one tracked pointer block so
// DisposeGWorld can return a middle-of-heap allocation for later reuse.
// Allocate it after the relocatable color table so an otherwise-current
// world can still contract the bump heap when it is disposed.
let base_addr = if depth <= 8 && ctable_handle == 0 {
0
} else {
process_memory_manager.new_native_ptr(memory, raw_allocation_size, true)
};
let pixmap = base_addr.saturating_add(ppc_allocation_size(pixel_allocation_size).unwrap_or(0));
let pixmap_handle = pixmap.saturating_add(ppc_allocation_size(PPC_PIXMAP_SIZE).unwrap_or(0));
let port = pixmap_handle.saturating_add(ppc_allocation_size(4).unwrap_or(0));
if base_addr == 0
|| pixmap == 0
|| pixmap_handle == 0
|| (depth <= 8 && ctable_handle == 0)
|| port == 0
{
if ctable_handle != 0 {
let _ = memory.write_u32_be(ctable_handle, 0);
}
process_memory_manager.restore_native_snapshot(native_manager_before);
process_memory_manager.set_native_mem_error(PPC_MEM_FULL_ERR);
*heap_cursor = heap_cursor_before;
ppc_update_zone_free_bytes(memory, heap_cursor_before, heap_limit);
*last_mem_error = PPC_MEM_FULL_ERR;
return PPC_MEM_FULL_ERR;
}
if memory.write_u32_be(pixmap_handle, pixmap).is_none()
|| ppc_write_pixmap(
memory, pixmap, base_addr, row_bytes, top, left, bottom, right, depth,
)
.is_none()
|| memory.write_u32_be(pixmap + 42, ctable_handle).is_none()
|| ppc_write_gworld_port(memory, port, pixmap_handle, top, left, bottom, right).is_none()
|| memory.write_u32_be(gworld_out_ptr, port).is_none()
{
if ctable_handle != 0 {
let _ = memory.write_u32_be(ctable_handle, 0);
}
process_memory_manager.restore_native_snapshot(native_manager_before);
process_memory_manager.set_native_mem_error(PPC_PARAM_ERR);
*heap_cursor = heap_cursor_before;
ppc_update_zone_free_bytes(memory, heap_cursor_before, heap_limit);
*last_mem_error = PPC_PARAM_ERR;
return PPC_PARAM_ERR;
}
ppc_apply_process_native_allocator(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
);
if ctable_handle != 0 {
ppc_apply_process_native_handle(
process_memory_manager,
handles,
ctable_handle,
);
}
process_memory_manager.set_native_mem_error(PPC_NO_ERR);
*last_mem_error = PPC_NO_ERR;
gworlds.push(PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
port,
pixmap_handle,
pixmap,
base_addr,
gdevice: if uses_explicit_gdevice {
requested_gdevice
} else {
selected_gdevice
},
width,
height,
depth,
row_bytes,
pixels_locked: false,
pixels_no_purge: true,
});
gworld_allocations.insert(
port,
PpcGWorldAllocationRecord {
storage_ptr: base_addr,
pixel_ptr: base_addr,
origin_base: base_addr,
pixel_capacity: ppc_allocation_size(pixel_allocation_size)
.unwrap_or(pixel_allocation_size),
ctable_handle,
allocation_end: base_addr
.checked_add(ppc_allocation_size(raw_allocation_size).unwrap_or(0))
.filter(|end| *end == *heap_cursor)
.unwrap_or(0),
},
);
if ppc_gworld_trace_enabled() {
eprintln!(
"[PPC-GWORLD-TRACE] NewGWorld port=${:08X} out=${:08X} base=${:08X} pixmap=${:08X} handle=${:08X} ctable=${:08X} requested_depth={} requested_ctable=${:08X} requested_gdevice=${:08X} gdevice=${:08X} requested_bounds=({}, {}, {}, {}) bounds=({}, {}, {}, {}) size={}x{}x{} row_bytes={} flags=${:08X}",
port,
gworld_out_ptr,
base_addr,
pixmap,
pixmap_handle,
ctable_handle,
requested_depth,
requested_ctab,
requested_gdevice,
if uses_explicit_gdevice {
requested_gdevice
} else {
selected_gdevice
},
requested_top,
requested_left,
requested_bottom,
requested_right,
top,
left,
bottom,
right,
width,
height,
depth,
row_bytes,
cpu.gpr[8]
);
}
PPC_NO_ERR
}
#[allow(clippy::too_many_arguments)]
fn ppc_update_gworld(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
gworlds: &mut [PpcGWorldRecord],
gworld_allocations: &mut HashMap<u32, PpcGWorldAllocationRecord>,
current_gworld: &mut u32,
current_gdevice: &mut u32,
) -> u32 {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 6-23--6-26:
// UpdateGWorld leaves the old world intact on error, reports structural
// changes in its result flags, and preserves resized pixels only when the
// caller requests clipPix or stretchPix.
const MAP_PIX: u32 = 1 << 16;
const NEW_DEPTH: u32 = 1 << 17;
const ALIGN_PIX: u32 = 1 << 18;
const NEW_ROW_BYTES: u32 = 1 << 19;
const REALLOC_PIX: u32 = 1 << 20;
const KEEP_LOCAL: u32 = 1 << 3;
const CLIP_PIX: u32 = 1 << 28;
const STRETCH_PIX: u32 = 1 << 29;
const DITHER_PIX: u32 = 1 << 30;
const GW_FLAG_ERR: u32 = 1 << 31;
let gworld_ptr_ptr = cpu.gpr[3];
let requested_depth = cpu.gpr[4] as u16 as i16;
let bounds_ptr = cpu.gpr[5];
let requested_ctab = cpu.gpr[6];
let requested_gdevice = cpu.gpr[7];
let requested_flags = cpu.gpr[8];
let update_flags = requested_flags & (CLIP_PIX | STRETCH_PIX | DITHER_PIX);
let clip_requested = update_flags & CLIP_PIX != 0;
let stretch_requested = update_flags & STRETCH_PIX != 0;
let dither_requested = update_flags & DITHER_PIX != 0;
if requested_flags & !(KEEP_LOCAL | CLIP_PIX | STRETCH_PIX | DITHER_PIX) != 0
|| (clip_requested && stretch_requested)
|| (dither_requested && !clip_requested && !stretch_requested)
{
// Inside Macintosh Volume VI (1991), p. 21-16: the only legal pixel
// update sets are none, clip, stretch, clip+dither, and stretch+dither.
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
let updates_pixels = clip_requested || stretch_requested;
let Some(port) = (gworld_ptr_ptr != 0 && bounds_ptr != 0)
.then(|| memory.read_u32_be(gworld_ptr_ptr))
.flatten()
else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
let Some(record_index) = gworlds
.iter()
.position(|record| record.port == port && port != PPC_MAIN_GWORLD)
else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
let old = gworlds[record_index];
let Some((requested_top, requested_left, requested_bottom, requested_right)) =
ppc_read_rect(memory, bounds_ptr)
else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
if requested_bottom <= requested_top || requested_right <= requested_left {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
let device_pixmap_for = |memory: &mut PpcSectionMem, gdevice: u32| {
memory
.read_u32_be(gdevice)
.filter(|device| *device != 0)
.and_then(|device| memory.read_u32_be(device.checked_add(22)?))
.filter(|pixmap_handle| *pixmap_handle != 0)
.and_then(|pixmap_handle| memory.read_u32_be(pixmap_handle))
.filter(|pixmap| *pixmap != 0)
};
if requested_gdevice == 0 && !matches!(requested_depth, 0 | 1 | 2 | 4 | 8 | 16 | 32) {
*last_mem_error = PPC_C_DEPTH_ERR;
return GW_FLAG_ERR;
}
let selected_screen_gdevice = if requested_gdevice != 0 {
Some(requested_gdevice)
} else if requested_depth == 0 {
// Imaging With QuickDraw (1994), pp. 6-23--6-24: depth zero rescans
// intersecting screen devices. This single-screen runtime selects the
// physical main device for both the source PixMap and attachment.
Some(PPC_MAIN_GDEVICE)
} else {
None
};
let selected_screen_pixmap =
selected_screen_gdevice.and_then(|gdevice| device_pixmap_for(memory, gdevice));
if requested_gdevice != 0 && selected_screen_pixmap.is_none() {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
let device_depth = selected_screen_pixmap
.and_then(|pixmap| memory.read_u16_be(pixmap + 32))
.map(u32::from)
.filter(|depth| *depth != 0);
if (requested_gdevice != 0 || requested_depth == 0) && device_depth.is_none() {
*last_mem_error = PPC_C_DEPTH_ERR;
return GW_FLAG_ERR;
}
let depth = if requested_gdevice != 0 {
device_depth.unwrap_or(PPC_MAIN_PIXEL_DEPTH)
} else if requested_depth == 0 {
device_depth.unwrap_or(PPC_MAIN_PIXEL_DEPTH)
} else {
requested_depth as u32
};
if !matches!(depth, 1 | 2 | 4 | 8 | 16 | 32) {
*last_mem_error = PPC_C_DEPTH_ERR;
return GW_FLAG_ERR;
}
let (top, left, bottom, right) = (
requested_top,
requested_left,
requested_bottom,
requested_right,
);
let (width, height) = ppc_rect_dimensions(top, left, bottom, right);
let Some(row_bytes) = ppc_row_bytes(width, depth).filter(|row_bytes| *row_bytes <= 0x3fff)
else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
let Some(buffer_size) = row_bytes.checked_mul(height) else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
let Some(pixel_allocation_size) = buffer_size.checked_add(row_bytes.max(64)) else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
if !ppc_memory_can_write_bytes(memory, old.pixmap, PPC_PIXMAP_SIZE)
|| !ppc_memory_can_write_bytes(memory, old.port + 16, 8)
{
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
let old_bounds = ppc_read_rect(memory, old.pixmap + 6).unwrap_or((
0,
0,
ppc_u32_to_i16_saturating(old.height),
ppc_u32_to_i16_saturating(old.width),
));
let old_ctab = memory.read_u32_be(old.pixmap + 42).unwrap_or(0);
let desired_ctable_bytes = if depth <= 8 {
if requested_gdevice != 0 || requested_depth == 0 {
selected_screen_pixmap
.and_then(|pixmap| memory.read_u32_be(pixmap + 42))
.filter(|handle| *handle != 0)
.and_then(|handle| ppc_copy_color_table_bytes(memory, handle))
} else if requested_ctab != 0 {
ppc_copy_color_table_bytes(memory, requested_ctab)
} else {
ppc_default_color_table_bytes(depth)
}
} else {
None
};
if depth <= 8 && desired_ctable_bytes.is_none() {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
let old_ctable_bytes = (old_ctab != 0)
.then(|| ppc_copy_color_table_bytes(memory, old_ctab))
.flatten();
let ctable_changed = old_ctable_bytes != desired_ctable_bytes;
let dimensions_changed = width != old.width || height != old.height;
let maps_pixels = updates_pixels && depth <= 8 && ctable_changed;
let translates_pixels = updates_pixels && (depth != old.depth || maps_pixels);
let replaces_pixels = dimensions_changed
|| depth != old.depth
|| row_bytes != old.row_bytes
|| old.base_addr == 0
|| (ctable_changed && updates_pixels);
let preserves_pixels = old.base_addr != 0 && updates_pixels;
let dithers_pixels = dither_requested && preserves_pixels && translates_pixels && depth <= 8;
let replaces_ctable = depth <= 8 && (ctable_changed || old_ctab == 0);
let old_clut = if old.depth <= 8 && preserves_pixels && translates_pixels {
let Some(bytes) = old_ctable_bytes.as_deref() else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
let Some(clut) = ppc_color_table_clut_from_bytes(bytes) else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
Some(clut)
} else {
None
};
let new_clut = if depth <= 8 && preserves_pixels && translates_pixels {
let Some(bytes) = desired_ctable_bytes.as_deref() else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
let Some(clut) = ppc_color_table_clut_from_bytes(bytes) else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
Some(clut)
} else {
None
};
let allocation_before = gworld_allocations.get(&port).copied();
let old_pixel_capacity = allocation_before.map_or_else(
|| {
old.row_bytes
.checked_mul(old.height)
.and_then(ppc_allocation_size)
.unwrap_or(0)
},
|allocation| allocation.pixel_capacity,
);
let Some(required_pixel_capacity) = ppc_allocation_size(pixel_allocation_size) else {
*last_mem_error = PPC_MEM_FULL_ERR;
return GW_FLAG_ERR;
};
let stable_ctable_handle = allocation_before
.map(|allocation| allocation.ctable_handle)
.filter(|handle| *handle != 0)
.or_else(|| {
handles
.iter()
.any(|record| record.handle == old_ctab && old_ctab != 0)
.then_some(old_ctab)
});
let stable_ctable_record = stable_ctable_handle
.and_then(|handle| handles.iter().find(|record| record.handle == handle))
.copied();
let desired_ctable_size = desired_ctable_bytes
.as_ref()
.and_then(|bytes| u32::try_from(bytes.len()).ok())
.unwrap_or(0);
let stable_ctable_resize_allocation = if replaces_ctable {
if let Some(record) = stable_ctable_record {
let Some(size) = ppc_handle_resize_allocation_size(
memory,
record,
*heap_cursor,
heap_limit,
desired_ctable_size,
) else {
*last_mem_error = PPC_MEM_FULL_ERR;
return GW_FLAG_ERR;
};
size
} else {
0
}
} else {
0
};
let allocates_ctable_handle = replaces_ctable && stable_ctable_record.is_none();
let grows_pixel_storage_in_place = replaces_pixels
&& old.base_addr != 0
&& required_pixel_capacity > old_pixel_capacity
&& old.base_addr.checked_add(old_pixel_capacity) == Some(*heap_cursor)
&& ppc_heap_allocation_bounds(memory, old.base_addr, heap_limit, required_pixel_capacity)
.is_some_and(|(base, _)| base == old.base_addr)
&& stable_ctable_resize_allocation == 0
&& !allocates_ctable_handle;
let reuses_pixel_storage = replaces_pixels
&& old.base_addr != 0
&& (required_pixel_capacity <= old_pixel_capacity || grows_pixel_storage_in_place);
let allocates_pixel_storage = replaces_pixels && !reuses_pixel_storage;
let mut allocation_sizes = Vec::new();
if stable_ctable_resize_allocation != 0 {
allocation_sizes.push(stable_ctable_resize_allocation);
} else if allocates_ctable_handle {
allocation_sizes.push(4);
allocation_sizes.push(desired_ctable_size);
}
if grows_pixel_storage_in_place {
allocation_sizes.push(required_pixel_capacity - old_pixel_capacity);
} else if allocates_pixel_storage {
allocation_sizes.push(pixel_allocation_size);
}
if !allocation_sizes.is_empty()
&& !ppc_heap_can_alloc_sequence(memory, *heap_cursor, heap_limit, &allocation_sizes)
{
*last_mem_error = PPC_MEM_FULL_ERR;
return GW_FLAG_ERR;
}
let staged_pixels = if replaces_pixels {
let Ok(buffer_len) = usize::try_from(buffer_size) else {
*last_mem_error = PPC_MEM_FULL_ERR;
return GW_FLAG_ERR;
};
let staged = if preserves_pixels {
ppc_stage_update_gworld_pixels(
memory,
old,
row_bytes,
width,
height,
depth,
stretch_requested,
translates_pixels,
dithers_pixels,
old_clut.as_ref(),
new_clut.as_ref(),
)
} else {
let mut bytes = Vec::new();
if bytes.try_reserve_exact(buffer_len).is_err() {
None
} else {
bytes.resize(buffer_len, 0);
Some(bytes)
}
};
let Some(staged) = staged else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
Some(staged)
} else {
None
};
let Some(old_pixmap_snapshot) = ppc_memory_read_bytes(memory, old.pixmap, PPC_PIXMAP_SIZE)
else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
let Some(old_port_rect_snapshot) = ppc_memory_read_bytes(memory, old.port + 16, 8) else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
if !ppc_memory_can_write_bytes(memory, old.pixmap, PPC_PIXMAP_SIZE)
|| !ppc_memory_can_write_bytes(memory, old.port + 16, 8)
{
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
let vis_region_snapshot = memory
.read_u32_be(old.port + PPC_CGRAF_PORT_VIS_RGN_OFFSET)
.and_then(|handle| ppc_rgn_ptr(memory, handle))
.and_then(|ptr| ppc_memory_read_bytes(memory, ptr, 10).map(|bytes| (ptr, bytes)))
.filter(|(ptr, _)| ppc_memory_can_write_bytes(memory, *ptr, 10));
let new_gdevice = if requested_gdevice != 0 {
requested_gdevice
} else if requested_depth == 0 {
selected_screen_gdevice.unwrap_or(PPC_MAIN_GDEVICE)
} else if old.gdevice != 0 {
old.gdevice
} else {
*current_gdevice
};
let reused_pixel_snapshot = if reuses_pixel_storage {
let snapshot_size = if grows_pixel_storage_in_place {
old_pixel_capacity
} else {
buffer_size
};
if !ppc_memory_can_write_bytes(memory, old.base_addr, snapshot_size) {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
let Some(bytes) = ppc_memory_read_bytes(memory, old.base_addr, snapshot_size) else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
Some(bytes)
} else {
None
};
let stable_ctable_snapshot = if replaces_ctable {
if let Some(record) = stable_ctable_record {
let Some(master) = memory.read_u32_be(record.handle) else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
if master != record.ptr {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
let Some(bytes) = ppc_memory_read_bytes(memory, record.ptr, record.size) else {
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
};
if desired_ctable_size <= record.capacity
&& !ppc_memory_can_write_bytes(memory, record.ptr, desired_ctable_size)
{
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
Some((record, master, bytes))
} else {
None
}
} else {
None
};
// Allocate only after every source pixel, destination byte, metadata
// target, and allocation has been preflighted. Pixel bytes are staged on
// the host, and the world's private ColorTable keeps one stable handle;
// rollback restores both if an already-preflighted guest write fails.
let heap_cursor_before = *heap_cursor;
let native_manager_before = process_memory_manager.detached_clone();
let mut allocation_error = PPC_NO_ERR;
let mut owned_ctable_handle = stable_ctable_handle.unwrap_or(0);
let new_ctab = if depth > 8 {
0
} else if replaces_ctable {
if let Some(record) = stable_ctable_record {
let result = process_memory_manager.set_native_handle_size(
memory,
record.handle,
desired_ctable_size,
);
if result != PPC_NO_ERR {
allocation_error = result;
0
} else if let Some(table) = memory
.read_u32_be(record.handle)
.filter(|table| *table != 0)
{
if memory
.write_bytes(table, desired_ctable_bytes.as_deref().unwrap_or_default())
.is_none()
{
allocation_error = PPC_PARAM_ERR;
0
} else {
owned_ctable_handle = record.handle;
record.handle
}
} else {
allocation_error = PPC_PARAM_ERR;
0
}
} else {
let handle =
process_memory_manager.new_native_handle(memory, desired_ctable_size, false);
if handle == 0 {
allocation_error = PPC_MEM_FULL_ERR;
} else if process_memory_manager
.native_allocation(handle)
.and_then(|record| {
memory.write_bytes(
record.ptr,
desired_ctable_bytes.as_deref().unwrap_or_default(),
)
})
.is_none()
{
allocation_error = PPC_PARAM_ERR;
} else {
owned_ctable_handle = handle;
}
handle
}
} else {
old_ctab
};
let new_base = if allocation_error != PPC_NO_ERR || !replaces_pixels {
old.base_addr
} else if reuses_pixel_storage {
if grows_pixel_storage_in_place {
allocation_error = process_memory_manager.set_native_ptr_size(
memory,
old.base_addr,
pixel_allocation_size,
);
}
if allocation_error == PPC_NO_ERR
&& memory
.write_bytes(old.base_addr, staged_pixels.as_deref().unwrap_or_default())
.is_none()
{
allocation_error = PPC_PARAM_ERR;
}
old.base_addr
} else {
let base = process_memory_manager.new_native_ptr(memory, pixel_allocation_size, true);
if base == 0 {
allocation_error = PPC_MEM_FULL_ERR;
} else if memory
.write_bytes(base, staged_pixels.as_deref().unwrap_or_default())
.is_none()
{
allocation_error = PPC_PARAM_ERR;
}
base
};
if allocation_error != PPC_NO_ERR {
if let Some(bytes) = reused_pixel_snapshot.as_ref() {
let _ = memory.write_bytes(old.base_addr, bytes);
}
if let Some((record, master, bytes)) = stable_ctable_snapshot.as_ref() {
let _ = memory.write_u32_be(record.handle, *master);
let _ = memory.write_bytes(record.ptr, bytes);
}
process_memory_manager.restore_native_snapshot(native_manager_before);
*heap_cursor = heap_cursor_before;
ppc_update_zone_free_bytes(memory, heap_cursor_before, heap_limit);
*last_mem_error = allocation_error;
return GW_FLAG_ERR;
}
let mut result = 0;
if maps_pixels {
result |= MAP_PIX;
}
if translates_pixels && depth != old.depth {
result |= NEW_DEPTH;
}
if updates_pixels
&& width == old.width
&& height == old.height
&& old_bounds != (top, left, bottom, right)
{
result |= ALIGN_PIX;
}
if row_bytes != old.row_bytes {
result |= NEW_ROW_BYTES;
}
if allocates_pixel_storage {
result |= REALLOC_PIX;
}
if dimensions_changed {
if stretch_requested {
result |= STRETCH_PIX;
} else if clip_requested {
result |= CLIP_PIX;
}
}
if dithers_pixels {
result |= DITHER_PIX;
}
let (pixel_type, component_count, component_size) = match depth {
1 | 2 | 4 | 8 => (0, 1, depth as u16),
16 => (16, 3, 5),
32 => (16, 3, 8),
_ => unreachable!("validated GWorld depth"),
};
let mut write_ok = memory.write_u32_be(old.pixmap, new_base).is_some()
&& memory
.write_u16_be(old.pixmap + 4, (row_bytes as u16) | 0x8000)
.is_some()
&& ppc_write_rect(memory, old.pixmap + 6, top, left, bottom, right).is_some()
&& memory.write_u16_be(old.pixmap + 30, pixel_type).is_some()
&& memory.write_u16_be(old.pixmap + 32, depth as u16).is_some()
&& memory
.write_u16_be(old.pixmap + 34, component_count)
.is_some()
&& memory
.write_u16_be(old.pixmap + 36, component_size)
.is_some()
&& memory.write_u32_be(old.pixmap + 38, 0).is_some()
&& memory.write_u32_be(old.pixmap + 42, new_ctab).is_some()
&& ppc_write_rect(memory, old.port + 16, top, left, bottom, right).is_some();
if let Some((ptr, _)) = vis_region_snapshot.as_ref() {
write_ok &= memory.write_u16_be(*ptr, 10).is_some()
&& ppc_write_rect(memory, *ptr + 2, top, left, bottom, right).is_some();
}
if !write_ok {
let _ = memory.write_bytes(old.pixmap, &old_pixmap_snapshot);
let _ = memory.write_bytes(old.port + 16, &old_port_rect_snapshot);
if let Some((ptr, bytes)) = vis_region_snapshot.as_ref() {
let _ = memory.write_bytes(*ptr, bytes);
}
if let Some(bytes) = reused_pixel_snapshot.as_ref() {
let _ = memory.write_bytes(old.base_addr, bytes);
}
if let Some((record, master, bytes)) = stable_ctable_snapshot.as_ref() {
let _ = memory.write_u32_be(record.handle, *master);
let _ = memory.write_bytes(record.ptr, bytes);
}
process_memory_manager.restore_native_snapshot(native_manager_before);
*heap_cursor = heap_cursor_before;
ppc_update_zone_free_bytes(memory, heap_cursor_before, heap_limit);
*last_mem_error = PPC_PARAM_ERR;
return GW_FLAG_ERR;
}
if allocates_pixel_storage {
if let Some(previous) = allocation_before.filter(|previous| {
previous.pixel_ptr != 0 && previous.pixel_ptr != previous.storage_ptr
}) {
let _ = process_memory_manager.dispose_native_ptr(previous.pixel_ptr);
}
}
ppc_apply_process_native_allocator(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
);
if owned_ctable_handle != 0 {
ppc_apply_process_native_handle(
process_memory_manager,
handles,
owned_ctable_handle,
);
}
gworlds[record_index] = PpcGWorldRecord {
ui_theme: crate::ui_theme::UiThemeId::ClassicSystem7,
base_addr: new_base,
gdevice: new_gdevice,
width,
height,
depth,
row_bytes,
..old
};
let heap_grew = *heap_cursor != heap_cursor_before;
let pixel_capacity = if allocates_pixel_storage || grows_pixel_storage_in_place {
required_pixel_capacity
} else {
old_pixel_capacity
};
let allocation_after = if let Some(previous) = allocation_before {
if heap_grew {
PpcGWorldAllocationRecord {
storage_ptr: previous.storage_ptr,
pixel_ptr: new_base,
origin_base: if previous.allocation_end == heap_cursor_before {
previous.origin_base
} else {
heap_cursor_before
},
pixel_capacity,
ctable_handle: owned_ctable_handle,
allocation_end: *heap_cursor,
}
} else {
PpcGWorldAllocationRecord {
pixel_ptr: new_base,
pixel_capacity,
ctable_handle: owned_ctable_handle,
..previous
}
}
} else {
PpcGWorldAllocationRecord {
storage_ptr: 0,
pixel_ptr: new_base,
origin_base: if heap_grew { heap_cursor_before } else { 0 },
pixel_capacity,
ctable_handle: owned_ctable_handle,
allocation_end: if heap_grew { *heap_cursor } else { 0 },
}
};
gworld_allocations.insert(port, allocation_after);
if *current_gworld == port {
*current_gworld = port;
*current_gdevice = new_gdevice;
}
*last_mem_error = PPC_NO_ERR;
if ppc_gworld_trace_enabled() {
eprintln!(
"[PPC-GWORLD-TRACE] UpdateGWorld port=${port:08X} base=${:08X}->${new_base:08X} bounds=({}, {}, {}, {})->({}, {}, {}, {}) size={}x{}x{} row_bytes={} flags=${requested_flags:08X} result=${result:08X}",
old.base_addr,
old_bounds.0,
old_bounds.1,
old_bounds.2,
old_bounds.3,
top,
left,
bottom,
right,
width,
height,
depth,
row_bytes,
);
}
result
}
#[allow(clippy::too_many_arguments)]
fn ppc_stage_update_gworld_pixels(
memory: &mut PpcSectionMem,
old: PpcGWorldRecord,
new_row_bytes: u32,
new_width: u32,
new_height: u32,
new_depth: u32,
stretch: bool,
translate: bool,
dither: bool,
old_clut: Option<&PpcGWorldClut>,
new_clut: Option<&PpcGWorldClut>,
) -> Option<Vec<u8>> {
let buffer_size = new_row_bytes.checked_mul(new_height)?;
let buffer_len = usize::try_from(buffer_size).ok()?;
let mut pixels = Vec::new();
pixels.try_reserve_exact(buffer_len).ok()?;
pixels.resize(buffer_len, 0);
let error_width = usize::try_from(new_width).ok()?.checked_add(2)?;
let mut current_errors = Vec::new();
let mut next_errors = Vec::new();
if dither {
current_errors.try_reserve_exact(error_width).ok()?;
next_errors.try_reserve_exact(error_width).ok()?;
current_errors.resize(error_width, [0i32; 3]);
next_errors.resize(error_width, [0i32; 3]);
}
for dst_y in 0..new_height {
let src_y = if stretch {
u64::from(dst_y)
.checked_mul(u64::from(old.height))?
.checked_div(u64::from(new_height))? as u32
} else {
if dst_y >= old.height {
continue;
}
dst_y
};
for dst_x in 0..new_width {
let src_x = if stretch {
u64::from(dst_x)
.checked_mul(u64::from(old.width))?
.checked_div(u64::from(new_width))? as u32
} else {
if dst_x >= old.width {
continue;
}
dst_x
};
let raw = ppc_read_gworld_record_raw_pixel(memory, old, src_x, src_y)?;
let pixel = if dither {
let rgb = ppc_gworld_pixel_to_rgb(raw, old.depth, old_clut)?;
let error_index = usize::try_from(dst_x).ok()?.checked_add(1)?;
let error = *current_errors.get(error_index)?;
let adjusted = PpcRgbColor {
red: u16::try_from((i32::from(rgb.red) + error[0]).clamp(0, 0xffff)).ok()?,
green: u16::try_from((i32::from(rgb.green) + error[1]).clamp(0, 0xffff))
.ok()?,
blue: u16::try_from((i32::from(rgb.blue) + error[2]).clamp(0, 0xffff)).ok()?,
};
let pixel = ppc_gworld_rgb_to_pixel(adjusted, new_depth, new_clut)?;
let palette_index = usize::try_from(pixel).ok()?;
let palette = new_clut?;
let [red, green, blue] = *palette.colors.get(palette_index)?;
let quantization_error = [
i32::from(adjusted.red) - i32::from(red),
i32::from(adjusted.green) - i32::from(green),
i32::from(adjusted.blue) - i32::from(blue),
];
for component in 0..3 {
current_errors[error_index + 1][component] +=
quantization_error[component] * 7 / 16;
next_errors[error_index - 1][component] +=
quantization_error[component] * 3 / 16;
next_errors[error_index][component] += quantization_error[component] * 5 / 16;
next_errors[error_index + 1][component] += quantization_error[component] / 16;
}
pixel
} else if translate {
let rgb = ppc_gworld_pixel_to_rgb(raw, old.depth, old_clut)?;
ppc_gworld_rgb_to_pixel(rgb, new_depth, new_clut)?
} else {
raw
};
ppc_write_gworld_staged_pixel(
&mut pixels,
new_row_bytes,
new_width,
new_height,
new_depth,
dst_x,
dst_y,
pixel,
)?;
}
if dither {
std::mem::swap(&mut current_errors, &mut next_errors);
next_errors.fill([0; 3]);
}
}
Some(pixels)
}
fn ppc_read_gworld_record_raw_pixel(
memory: &mut PpcSectionMem,
record: PpcGWorldRecord,
x: u32,
y: u32,
) -> Option<u32> {
if x >= record.width || y >= record.height {
return None;
}
let row = record
.base_addr
.checked_add(y.checked_mul(record.row_bytes)?)?;
match record.depth {
1 | 2 | 4 => {
let bit_offset = x.checked_mul(record.depth)?;
let byte_offset = bit_offset / 8;
if byte_offset >= record.row_bytes {
return None;
}
let shift = 8u32
.checked_sub(record.depth)?
.checked_sub(bit_offset & 7)?;
let mask = (1u8 << record.depth) - 1;
memory
.read_u8(row.checked_add(byte_offset)?)
.map(|byte| u32::from((byte >> shift) & mask))
}
8 => {
if x >= record.row_bytes {
return None;
}
memory.read_u8(row.checked_add(x)?).map(u32::from)
}
16 => {
let byte_offset = x.checked_mul(2)?;
if byte_offset.checked_add(2)? > record.row_bytes {
return None;
}
memory
.read_u16_be(row.checked_add(byte_offset)?)
.map(u32::from)
}
32 => {
let byte_offset = x.checked_mul(4)?;
if byte_offset.checked_add(4)? > record.row_bytes {
return None;
}
memory.read_u32_be(row.checked_add(byte_offset)?)
}
_ => None,
}
}
fn ppc_gworld_pixel_to_rgb(
pixel: u32,
depth: u32,
clut: Option<&PpcGWorldClut>,
) -> Option<PpcRgbColor> {
// Imaging With QuickDraw (1994), pp. 4-13--4-16: indexed pixels name a
// ColorTable entry; 16-bit direct pixels use 5:5:5 RGB; 32-bit direct
// pixels store the high byte of each RGBColor component in 0x00RRGGBB.
match depth {
depth @ (1 | 2 | 4 | 8) => {
let index = usize::try_from(pixel).ok()?;
if index >= ppc_indexed_depth_entry_count(depth)? {
return None;
}
let clut = clut?;
if !clut.valid[index] {
return None;
}
let [red, green, blue] = clut.colors[index];
Some(PpcRgbColor { red, green, blue })
}
16 => {
let [red, green, blue] = ppc_rgb555_to_rgb16(pixel as u16);
Some(PpcRgbColor { red, green, blue })
}
32 => Some(PpcRgbColor {
red: (((pixel >> 16) & 0xff) as u16) * 0x0101,
green: (((pixel >> 8) & 0xff) as u16) * 0x0101,
blue: ((pixel & 0xff) as u16) * 0x0101,
}),
_ => None,
}
}
fn ppc_gworld_rgb_to_pixel(
color: PpcRgbColor,
depth: u32,
clut: Option<&PpcGWorldClut>,
) -> Option<u32> {
match depth {
depth @ (1 | 2 | 4 | 8) => {
let clut = clut?;
ppc_rgb_color_to_valid_index_in_clut(
color,
&clut.colors,
&clut.valid,
ppc_indexed_depth_entry_count(depth)?,
)
.map(u32::from)
}
16 => Some(u32::from(
((color.red >> 11) << 10) | ((color.green >> 11) << 5) | (color.blue >> 11),
)),
32 => Some(
(u32::from(color.red >> 8) << 16)
| (u32::from(color.green >> 8) << 8)
| u32::from(color.blue >> 8),
),
_ => None,
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_write_gworld_staged_pixel(
pixels: &mut [u8],
row_bytes: u32,
width: u32,
height: u32,
depth: u32,
x: u32,
y: u32,
pixel: u32,
) -> Option<()> {
if x >= width || y >= height {
return None;
}
let row = usize::try_from(y.checked_mul(row_bytes)?).ok()?;
match depth {
1 | 2 | 4 => {
let bit_offset = x.checked_mul(depth)?;
let byte_offset = usize::try_from(bit_offset / 8).ok()?;
if u32::try_from(byte_offset).ok()? >= row_bytes {
return None;
}
let shift = 8u32.checked_sub(depth)?.checked_sub(bit_offset & 7)?;
let value_mask = (1u8 << depth) - 1;
let field_mask = value_mask << shift;
let byte = pixels.get_mut(row.checked_add(byte_offset)?)?;
*byte = (*byte & !field_mask) | (((pixel as u8) & value_mask) << shift);
}
8 => {
if x >= row_bytes {
return None;
}
*pixels.get_mut(row.checked_add(usize::try_from(x).ok()?)?)? = pixel as u8;
}
16 => {
let byte_offset = x.checked_mul(2)?;
if byte_offset.checked_add(2)? > row_bytes {
return None;
}
let offset = row.checked_add(usize::try_from(byte_offset).ok()?)?;
pixels
.get_mut(offset..offset.checked_add(2)?)?
.copy_from_slice(&(pixel as u16).to_be_bytes());
}
32 => {
let byte_offset = x.checked_mul(4)?;
if byte_offset.checked_add(4)? > row_bytes {
return None;
}
let offset = row.checked_add(usize::try_from(byte_offset).ok()?)?;
pixels
.get_mut(offset..offset.checked_add(4)?)?
.copy_from_slice(&pixel.to_be_bytes());
}
_ => return None,
}
Some(())
}
pub(super) fn ppc_gworld_device(gworlds: &[PpcGWorldRecord], port: u32) -> Option<u32> {
gworlds
.iter()
.find(|gworld| gworld.port == port)
.map(|gworld| gworld.gdevice)
}
fn ppc_gworld_pixmap(memory: &mut PpcSectionMem, gworlds: &[PpcGWorldRecord], gworld: u32) -> u32 {
if let Some(record) = gworlds.iter().find(|record| record.port == gworld) {
return record.pixmap_handle;
}
if gworld == 0 {
return 0;
}
memory.read_u32_be(gworld + 2).unwrap_or(0)
}
fn ppc_pix_base_addr(memory: &mut PpcSectionMem, pixmap_handle: u32) -> u32 {
if pixmap_handle == 0 {
return 0;
}
let Some(pixmap) = memory.read_u32_be(pixmap_handle) else {
return 0;
};
if pixmap == 0 {
return 0;
}
memory.read_u32_be(pixmap).unwrap_or(0)
}
fn ppc_legacy_qd_color_to_rgb(color: u32) -> PpcRgbColor {
match color {
30 => PPC_RGB_WHITE,
33 => PPC_RGB_BLACK,
69 => PpcRgbColor {
red: 0xfc00,
green: 0xf37d,
blue: 0x052f,
},
137 => PpcRgbColor {
red: 0xf2d7,
green: 0x0856,
blue: 0x84ec,
},
205 => PpcRgbColor {
red: 0xdd6b,
green: 0x08c2,
blue: 0x06a2,
},
273 => PpcRgbColor {
red: 0x0241,
green: 0xab54,
blue: 0xeaff,
},
341 => PpcRgbColor {
red: 0,
green: 0x8000,
blue: 0x11b0,
},
409 => PpcRgbColor {
red: 0,
green: 0,
blue: 0xd400,
},
_ => PPC_RGB_BLACK,
}
}
pub(super) fn ppc_rgb_color_to_rgb555(color: PpcRgbColor) -> u16 {
fn component(value: u16) -> u16 {
(((u32::from(value) * 31) + 32_767) / 65_535) as u16
}
(component(color.red) << 10) | (component(color.green) << 5) | component(color.blue)
}
pub(super) fn ppc_fix_ratio(numerator: i16, denominator: i16) -> i32 {
// Inside Macintosh Volume I (1985), p. I-467: FixRatio returns the
// truncated signed 16.16 quotient and uses asymmetric saturation when the
// denominator is zero.
if denominator == 0 {
return if numerator < 0 {
i32::MIN + 1
} else {
i32::MAX
};
}
((i64::from(numerator) << 16) / i64::from(denominator)) as i32
}
pub(super) fn ppc_fix_mul(left: i32, right: i32) -> i32 {
// Inside Macintosh Volume I (1985), p. I-467: FixMul rounds its signed
// 32.32 intermediate to the nearest representable 16.16 value.
((i64::from(left) * i64::from(right) + 0x8000) >> 16) as i32
}
pub(super) fn ppc_fix_div(numerator: i32, denominator: i32) -> i32 {
// Operating System Utilities (1994), pp. 3-39--3-40: FixDiv divides two
// signed 16.16 values and returns a signed 16.16 quotient. Saturate when
// the quotient is not representable, including division by zero.
if denominator == 0 {
return if numerator < 0 { i32::MIN } else { i32::MAX };
}
((i64::from(numerator) << 16) / i64::from(denominator))
.clamp(i64::from(i32::MIN), i64::from(i32::MAX)) as i32
}
pub(super) fn ppc_long_to_fix(value: i32) -> i32 {
// Operating System Utilities (1994), p. 3-43: inputs outside the signed
// 16-bit integer range saturate to the extrema of Fixed.
if value > 0x7fff {
i32::MAX
} else if value < -0x8000 {
i32::MIN
} else {
value << 16
}
}
pub(super) fn ppc_fix_to_long(value: i32) -> i32 {
// Operating System Utilities (1994), p. 3-44: round to the nearest
// integer, with exact halves rounded away from zero.
let value = i64::from(value);
if value >= 0 {
((value + 0x8000) >> 16) as i32
} else {
-(((-value + 0x8000) >> 16) as i32)
}
}
pub(super) fn ppc_fix_round(value: i32) -> i16 {
// Inside Macintosh Volume I (1985), p. I-467: round to nearest integer,
// with exact halves rounded away from zero.
let value = i64::from(value);
let magnitude = (value.abs() + 0x8000) >> 16;
let rounded = if value < 0 { -magnitude } else { magnitude };
rounded as i16
}
const PPC_FIXMATH_PI_FIXED: f64 = 205_888.0;
fn ppc_fixed_radians(value: i32) -> f64 {
// Inside Macintosh Volume IV (1986), p. IV-64: FracSin and FracCos use
// P = 3.1416015625 (Fixed $00032440) rather than IEEE pi for reduction.
f64::from(value) * std::f64::consts::PI / PPC_FIXMATH_PI_FIXED
}
fn ppc_radians_to_fixed(value: f64) -> i32 {
// Inside Macintosh Volume IV (1986), p. IV-65: FixATan2 uses the same
// $0000C910 approximation to pi/4, hence $00032440 for pi.
(value * PPC_FIXMATH_PI_FIXED / std::f64::consts::PI)
.round()
.clamp(i32::MIN as f64, i32::MAX as f64) as i32
}
pub(super) fn ppc_fix_to_frac(value: i32) -> i32 {
// Operating System Utilities (1994), p. 3-44: shift left 14 bits with saturation.
(i64::from(value) << 14).clamp(i64::from(i32::MIN), i64::from(i32::MAX)) as i32
}
pub(super) fn ppc_frac_to_fix(value: i32) -> i32 {
// Operating System Utilities (1994), p. 3-44: shift right 14 bits with nearest rounding.
((i64::from(value) + (1 << 13)) >> 14).clamp(i64::from(i32::MIN), i64::from(i32::MAX)) as i32
}
pub(super) fn ppc_f64_to_frac(value: f64) -> u32 {
// Operating System Utilities (1994), p. 3-46: convert float to Fract with saturation.
(value * 1_073_741_824.0)
.round()
.clamp(i32::MIN as f64, i32::MAX as f64) as i32 as u32
}
pub(super) fn ppc_frac_sin(value: i32) -> i32 {
// Inside Macintosh Volume IV (1986), p. IV-64: sine of Fixed radians returned as Fract.
let sin_val = ppc_fixed_radians(value).sin();
(sin_val * 1_073_741_824.0)
.round()
.clamp(i32::MIN as f64, i32::MAX as f64) as i32
}
pub(super) fn ppc_frac_cos(value: i32) -> i32 {
// Inside Macintosh Volume IV (1986), p. IV-64: cosine of Fixed radians returned as Fract.
let cos_val = ppc_fixed_radians(value).cos();
(cos_val * 1_073_741_824.0)
.round()
.clamp(i32::MIN as f64, i32::MAX as f64) as i32
}
pub(super) fn ppc_frac_sqrt(value: u32) -> u32 {
// Operating System Utilities (1994), p. 3-41: unsigned Fract 0..4-2^-30 square root.
let val = (value as f64) / 1_073_741_824.0;
let sqrt_val = val.sqrt();
(sqrt_val * 1_073_741_824.0)
.round()
.clamp(0.0, 2_147_483_648.0) as u32
}
pub(super) fn ppc_frac_mul(x: i32, y: i32) -> i32 {
// Inside Macintosh Volume IV (1986), p. IV-63: add half a unit in
// magnitude, then chop toward zero.
let product = i64::from(x) * i64::from(y);
let magnitude = (product.abs() + (1i64 << 29)) >> 30;
let rounded = if product < 0 { -magnitude } else { magnitude };
rounded.clamp(i64::from(i32::MIN), i64::from(i32::MAX)) as i32
}
pub(super) fn ppc_frac_div(numerator: i32, denominator: i32) -> i32 {
// Inside Macintosh Volume I (1985), p. I-468: signed 2.30 quotient, saturating on divide-by-zero.
if denominator == 0 {
return if numerator >= 0 { i32::MAX } else { i32::MIN };
}
((i64::from(numerator) << 30) / i64::from(denominator))
.clamp(i64::from(i32::MIN), i64::from(i32::MAX)) as i32
}
pub(super) fn ppc_fix_atan2(x: i32, y: i32) -> i32 {
// Inside Macintosh Volume IV (1986), p. IV-65: arctangent of y/x in radians.
ppc_radians_to_fixed(f64::from(y).atan2(f64::from(x)))
}
fn ppc_read_wide(memory: &mut PpcSectionMem, address: u32) -> Option<i64> {
let high = memory.read_u32_be(address)? as i32;
let low = memory.read_u32_be(address.checked_add(4)?)?;
Some((i64::from(high) << 32) | i64::from(low))
}
fn ppc_write_wide(memory: &mut PpcSectionMem, address: u32, value: i64) -> Option<()> {
memory.write_u32_be(address, (value >> 32) as u32)?;
memory.write_u32_be(address.checked_add(4)?, value as u32)?;
Some(())
}
pub(super) fn ppc_wide_add(memory: &mut PpcSectionMem, target: u32, source: u32) -> u32 {
// QuickDraw GX Environment and Utilities (1994), p. 8-49: add source to
// target in place and return the target pointer.
if let (Some(target_value), Some(source_value)) =
(ppc_read_wide(memory, target), ppc_read_wide(memory, source))
{
let _ = ppc_write_wide(memory, target, target_value.wrapping_add(source_value));
}
target
}
pub(super) fn ppc_wide_subtract(memory: &mut PpcSectionMem, target: u32, source: u32) -> u32 {
// QuickDraw GX Environment and Utilities (1994), p. 8-50: subtract source
// from target in place and return the target pointer.
if let (Some(target_value), Some(source_value)) =
(ppc_read_wide(memory, target), ppc_read_wide(memory, source))
{
let _ = ppc_write_wide(memory, target, target_value.wrapping_sub(source_value));
}
target
}
pub(super) fn ppc_wide_negate(memory: &mut PpcSectionMem, target: u32) -> u32 {
// QuickDraw GX Environment and Utilities (1994), p. 8-50: replace target
// with its two's-complement negative and return the target pointer.
if let Some(value) = ppc_read_wide(memory, target) {
let _ = ppc_write_wide(memory, target, value.wrapping_neg());
}
target
}
fn ppc_round_wide_quotient(dividend: i128, divisor: i128) -> i128 {
let quotient = dividend / divisor;
let remainder = dividend % divisor;
let doubled_remainder = remainder.abs() * 2;
let divisor_magnitude = divisor.abs();
if doubled_remainder > divisor_magnitude
|| (doubled_remainder == divisor_magnitude && (dividend < 0) == (divisor < 0))
{
quotient
+ if (dividend < 0) == (divisor < 0) {
1
} else {
-1
}
} else {
quotient
}
}
pub(super) fn ppc_wide_shift(memory: &mut PpcSectionMem, target: u32, shift: i32) -> u32 {
// QuickDraw GX Environment and Utilities (1994), p. 8-51: positive shifts
// move right with rounding; negative shifts move left.
if let Some(value) = ppc_read_wide(memory, target) {
let shifted = if shift > 0 {
if shift >= 64 {
0
} else {
ppc_round_wide_quotient(i128::from(value), 1i128 << shift) as i64
}
} else if shift < 0 {
let magnitude = shift.unsigned_abs();
if magnitude >= 64 {
0
} else {
value.wrapping_shl(magnitude)
}
} else {
value
};
let _ = ppc_write_wide(memory, target, shifted);
}
target
}
pub(super) fn ppc_wide_multiply(
memory: &mut PpcSectionMem,
multiplicand: i32,
multiplier: i32,
target: u32,
) -> u32 {
// QuickDraw GX Environment and Utilities (1994), p. 8-51: store the exact
// signed 32-by-32-bit product in target and return the target pointer.
let product = i64::from(multiplicand) * i64::from(multiplier);
let _ = ppc_write_wide(memory, target, product);
target
}
pub(super) fn ppc_wide_divide(
memory: &mut PpcSectionMem,
dividend_ptr: u32,
divisor: i32,
remainder_ptr: u32,
) -> i32 {
// QuickDraw GX Environment and Utilities (1994), p. 8-52: return a
// signed-long quotient, optionally store the remainder, round when the
// remainder pointer is nil or -1, and pin overflow to an infinity.
let Some(dividend) = ppc_read_wide(memory, dividend_ptr) else {
return 0;
};
let no_remainder = remainder_ptr == 0 || remainder_ptr == u32::MAX;
let (quotient, remainder, quotient_is_negative) = if divisor == 0 {
(
if dividend < 0 { i128::MIN } else { i128::MAX },
i32::MIN,
dividend < 0,
)
} else {
let dividend = i128::from(dividend);
let divisor = i128::from(divisor);
let quotient = if no_remainder {
ppc_round_wide_quotient(dividend, divisor)
} else {
dividend / divisor
};
(
quotient,
(dividend % divisor) as i32,
(dividend < 0) != (divisor < 0),
)
};
let overflow = quotient < i128::from(i32::MIN) || quotient > i128::from(i32::MAX);
if overflow {
if remainder_ptr != 0 && remainder_ptr != u32::MAX {
let _ = memory.write_u32_be(remainder_ptr, i32::MIN as u32);
}
if remainder_ptr == u32::MAX || quotient_is_negative {
i32::MIN
} else {
i32::MAX
}
} else {
if remainder_ptr != 0 && remainder_ptr != u32::MAX {
let _ = memory.write_u32_be(remainder_ptr, remainder as u32);
}
quotient as i32
}
}
pub(super) fn ppc_wide_wide_divide(
memory: &mut PpcSectionMem,
dividend_ptr: u32,
divisor: i32,
remainder_ptr: u32,
) -> u32 {
// QuickDraw GX Environment and Utilities (1994), p. 8-52: replace the
// dividend with its wide quotient, optionally store the remainder, and
// round when the remainder pointer is nil or -1.
let Some(dividend) = ppc_read_wide(memory, dividend_ptr) else {
return dividend_ptr;
};
let no_remainder = remainder_ptr == 0 || remainder_ptr == u32::MAX;
let (quotient, remainder) = if divisor == 0 {
(if dividend < 0 { i64::MIN } else { i64::MAX }, i32::MIN)
} else {
let dividend = i128::from(dividend);
let divisor = i128::from(divisor);
let quotient = if no_remainder {
ppc_round_wide_quotient(dividend, divisor)
} else {
dividend / divisor
};
(quotient as i64, (dividend % divisor) as i32)
};
let _ = ppc_write_wide(memory, dividend_ptr, quotient);
if remainder_ptr != 0 && remainder_ptr != u32::MAX {
let _ = memory.write_u32_be(remainder_ptr, remainder as u32);
}
dividend_ptr
}
pub(super) fn ppc_wide_square_root(memory: &mut PpcSectionMem, source: u32) -> u32 {
// QuickDraw GX Environment and Utilities (1994), p. 8-53: interpret the
// complete source as an unsigned wide value and return its square root.
let Some(high) = memory.read_u32_be(source) else {
return 0;
};
let Some(low) = source
.checked_add(4)
.and_then(|address| memory.read_u32_be(address))
else {
return 0;
};
((u64::from(high) << 32) | u64::from(low)).isqrt() as u32
}
pub(super) fn ppc_wide_compare(memory: &mut PpcSectionMem, target: u32, source: u32) -> i16 {
// QuickDraw GX Environment and Utilities (1994), p. 8-54: return 1, -1,
// or 0 according to the ordering of the two wide values.
match (ppc_read_wide(memory, target), ppc_read_wide(memory, source)) {
(Some(target), Some(source)) => match target.cmp(&source) {
std::cmp::Ordering::Less => -1,
std::cmp::Ordering::Equal => 0,
std::cmp::Ordering::Greater => 1,
},
_ => 0,
}
}
fn ppc_sync_gworld_pen(memory: &mut PpcSectionMem, current_gworld: u32, h: i16, v: i16) {
if current_gworld == 0
|| !ppc_memory_can_write_bytes(memory, current_gworld + PPC_CGRAF_PORT_PN_LOC_OFFSET, 4)
{
return;
}
let _ = memory.write_u16_be(current_gworld + PPC_CGRAF_PORT_PN_LOC_OFFSET, v as u16);
let _ = memory.write_u16_be(current_gworld + PPC_CGRAF_PORT_PN_LOC_OFFSET + 2, h as u16);
}
fn ppc_gworld_pen(memory: &mut PpcSectionMem, current_gworld: u32) -> Option<(i16, i16)> {
let v = memory.read_u16_be(current_gworld.checked_add(PPC_CGRAF_PORT_PN_LOC_OFFSET)?)? as i16;
let h = memory.read_u16_be(
current_gworld
.checked_add(PPC_CGRAF_PORT_PN_LOC_OFFSET)?
.checked_add(2)?,
)? as i16;
Some((h, v))
}
fn ppc_set_pen_size(cpu: &PpcCpu, memory: &mut PpcSectionMem, current_gworld: u32) {
if current_gworld == 0
|| !ppc_memory_can_write_bytes(memory, current_gworld + PPC_CGRAF_PORT_PN_SIZE_OFFSET, 4)
{
return;
}
// Inside Macintosh: Imaging With QuickDraw (1994), p. 3-20: PenSize's
// parameters are horizontal width then vertical height, while Point fields
// are stored vertical first.
let _ = memory.write_u16_be(
current_gworld + PPC_CGRAF_PORT_PN_SIZE_OFFSET,
cpu.gpr[4] as u16,
);
let _ = memory.write_u16_be(
current_gworld + PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2,
cpu.gpr[3] as u16,
);
}
fn ppc_set_pen_normal(memory: &mut PpcSectionMem, current_gworld: u32) {
if current_gworld == 0
|| !ppc_memory_can_write_bytes(memory, current_gworld + PPC_CGRAF_PORT_PN_SIZE_OFFSET, 6)
{
return;
}
// Imaging With QuickDraw (1994), p. 3-23: PenNormal restores a 1x1
// black pen in patCopy mode without changing its location.
let _ = memory.write_u16_be(current_gworld + PPC_CGRAF_PORT_PN_SIZE_OFFSET, 1);
let _ = memory.write_u16_be(current_gworld + PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2, 1);
let _ = memory.write_u16_be(
current_gworld + PPC_CGRAF_PORT_PN_MODE_OFFSET,
PPC_QD_PEN_MODE_PAT_COPY as u16,
);
}
fn ppc_get_pen_state(memory: &mut PpcSectionMem, current_gworld: u32, state_ptr: u32) {
const PEN_STATE_SIZE: u32 = 18;
let Some(bytes) = ppc_memory_read_bytes(
memory,
current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_LOC_OFFSET),
PEN_STATE_SIZE,
) else {
return;
};
if ppc_memory_can_write_bytes(memory, state_ptr, PEN_STATE_SIZE) {
let _ = memory.write_bytes(state_ptr, &bytes);
}
}
fn ppc_set_pen_state(memory: &mut PpcSectionMem, current_gworld: u32, state_ptr: u32) {
const PEN_STATE_SIZE: u32 = 18;
let Some(bytes) = ppc_memory_read_bytes(memory, state_ptr, PEN_STATE_SIZE) else {
return;
};
if ppc_memory_can_write_bytes(
memory,
current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_LOC_OFFSET),
PEN_STATE_SIZE,
) {
// Imaging With QuickDraw (1994), pp. 3-37 and 3-43--3-44: PenState
// is the contiguous pnLoc, pnSize, pnMode, and 8-byte pnPat portion of
// the current graphics port, totaling 18 bytes.
let _ = memory.write_bytes(
current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_LOC_OFFSET),
&bytes,
);
}
}
fn ppc_sync_gworld_text(
memory: &mut PpcSectionMem,
current_gworld: u32,
text_mode: i16,
text_size: i16,
) {
if current_gworld == 0
|| !ppc_memory_can_write_bytes(memory, current_gworld + PPC_CGRAF_PORT_TX_MODE_OFFSET, 4)
{
return;
}
let _ = memory.write_u16_be(
current_gworld + PPC_CGRAF_PORT_TX_MODE_OFFSET,
text_mode as u16,
);
let _ = memory.write_u16_be(
current_gworld + PPC_CGRAF_PORT_TX_SIZE_OFFSET,
text_size as u16,
);
}
fn ppc_line_to(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
from: (i16, i16),
to: (i16, i16),
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
if memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_VIS_OFFSET))
.is_some_and(|visibility| (visibility as i16) < 0)
{
return false;
}
let front_buffer = surface.front_buffer;
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return false;
}
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let clip_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_CLIP_RGN_OFFSET))
.and_then(|clip_rgn| ppc_region_storage(memory, clip_rgn));
let vis_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_VIS_RGN_OFFSET))
.and_then(|vis_rgn| ppc_region_storage(memory, vis_rgn));
let (x0, y0) = surface.local_point((i32::from(from.0), i32::from(from.1)));
let (x1, y1) = surface.local_point((i32::from(to.0), i32::from(to.1)));
let pen_height = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET))
.unwrap_or(1),
);
let pen_width = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2))
.unwrap_or(1),
);
let mut wrote = false;
let mut paint_pen = |x: i32, y: i32| {
for py in y..y.saturating_add(pen_height) {
for px in x..x.saturating_add(pen_width) {
if ppc_local_point_in_port_regions(
surface,
(px, py),
vis_storage.as_deref(),
clip_storage.as_deref(),
) {
wrote |= ppc_quickdraw_write_raw_pixel(
memory,
front_buffer,
(px, py),
color_pixel,
);
}
}
}
};
if x0 == x1 {
let (top, bottom) = if y0 <= y1 { (y0, y1) } else { (y1, y0) };
for y in top..=bottom {
paint_pen(x0, y);
}
} else if y0 == y1 {
let (left, right) = if x0 <= x1 { (x0, x1) } else { (x1, x0) };
for x in left..=right {
paint_pen(x, y0);
}
} else {
let (sx, sy, ex, ey) = if y0 <= y1 {
(x0, y0, x1, y1)
} else {
(x1, y1, x0, y0)
};
let dh = (ex - sx).abs();
let dv = ey - sy;
let x_dir = if ex > sx { 1 } else { -1 };
if dv >= dh {
let slope = (((i64::from(ex - sx)) << 16) + i64::from(dv) / 2)
/ i64::from(dv);
let mut x_fixed = ((i64::from(sx)) << 16) | 0x8000;
x_fixed += slope >> 1;
for y in sy..=ey {
paint_pen((x_fixed >> 16) as i32, y);
x_fixed += slope;
}
} else {
let slope = (((i64::from(dv)) << 16) + i64::from(dh) / 2)
/ i64::from(dh);
let mut y_fixed = ((i64::from(sy)) << 16) | 0x8000;
y_fixed += slope >> 1;
let mut x = sx;
for _ in 0..=dh {
paint_pen(x, (y_fixed >> 16) as i32);
x += x_dir;
y_fixed += slope;
}
}
}
wrote
}
fn ppc_local_point_in_port_regions(
surface: PpcQuickDrawSurface,
(x, y): (i32, i32),
vis_storage: Option<&[u8]>,
clip_storage: Option<&[u8]>,
) -> bool {
let port_h = x + i32::from(surface.left);
let port_v = y + i32::from(surface.top);
let port_point = i16::try_from(port_h).ok().zip(i16::try_from(port_v).ok());
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 2-20--2-21 and
// 2-47--2-49: every QuickDraw primitive is constrained by the
// intersection of the current port's visRgn and clipRgn.
port_point.is_some_and(|(h, v)| {
vis_storage.is_none_or(|storage| ppc_point_in_region_storage(storage, v, h))
&& clip_storage.is_none_or(|storage| ppc_point_in_region_storage(storage, v, h))
})
}
fn ppc_draw_oval(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
rect_ptr: u32,
color: PpcRgbColor,
explicit_index: Option<u8>,
frame_only: bool,
) -> bool {
let Some(rect) = ppc_read_rect(memory, rect_ptr) else {
return false;
};
ppc_draw_oval_bounds(
memory,
gworlds,
current_gworld,
rect,
color,
explicit_index,
frame_only,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_draw_oval_bounds(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
rect: (i16, i16, i16, i16),
color: PpcRgbColor,
explicit_index: Option<u8>,
frame_only: bool,
) -> bool {
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
let (top, left, bottom, right) = surface.local_rect(rect);
let width = right - left;
let height = bottom - top;
if width <= 0 || height <= 0 || !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return false;
}
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let pen_height = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET))
.unwrap_or(1),
)
.max(1);
let pen_width = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2))
.unwrap_or(1),
)
.max(1);
let spans = TrapDispatcher::compute_oval_spans(width as i16, height as i16);
let inner_left = left + pen_width;
let inner_top = top + pen_height;
let inner_width = width - 2 * pen_width;
let inner_height = height - 2 * pen_height;
let inner_spans = TrapDispatcher::compute_oval_spans(
inner_width.max(0) as i16,
inner_height.max(0) as i16,
);
let clip_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_CLIP_RGN_OFFSET))
.and_then(|clip_rgn| ppc_region_storage(memory, clip_rgn));
let vis_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_VIS_RGN_OFFSET))
.and_then(|vis_rgn| ppc_region_storage(memory, vis_rgn));
let mut wrote = false;
for y in top.max(0)..bottom.min(front_buffer.height as i32) {
let row = (y - top) as usize;
let Some(&(span_left, span_right)) = spans.get(row) else {
continue;
};
let outer_left = left + i32::from(span_left);
let outer_right = left + i32::from(span_right);
for x in outer_left.max(0)..outer_right.min(front_buffer.width as i32) {
let inner = if frame_only && y >= inner_top && y < inner_top + inner_height {
let inner_row = (y - inner_top) as usize;
inner_spans.get(inner_row).is_some_and(|&(span_left, span_right)| {
x >= inner_left + i32::from(span_left)
&& x < inner_left + i32::from(span_right)
})
} else {
false
};
if (!frame_only || !inner)
&& ppc_local_point_in_port_regions(
surface,
(x, y),
vis_storage.as_deref(),
clip_storage.as_deref(),
)
{
wrote |= ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), color_pixel);
}
}
}
wrote
}
fn ppc_paint_arc(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
rect_ptr: u32,
start_angle: i16,
arc_angle: i16,
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
// Inside Macintosh: Imaging With QuickDraw, pp. 3-73–3-74: PaintArc
// paints the wedge inside the oval, with zero at 12 o'clock and positive
// angles proceeding clockwise.
let Some(rect) = ppc_read_rect(memory, rect_ptr) else {
return false;
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
let (top, left, bottom, right) = surface.local_rect(rect);
let width = right - left;
let height = bottom - top;
if width <= 0
|| height <= 0
|| arc_angle == 0
|| !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16)
{
return false;
}
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let mut a_start = start_angle as f64;
let mut a_extent = arc_angle as f64;
if a_extent < 0.0 {
a_start += a_extent;
a_extent = -a_extent;
}
if a_extent > 360.0 {
a_extent = 360.0;
}
a_start = a_start.rem_euclid(360.0);
let a_end = a_start + a_extent;
let cx = (left as f64 + right as f64) / 2.0;
let cy = (top as f64 + bottom as f64) / 2.0;
let rx = width as f64 / 2.0;
let ry = height as f64 / 2.0;
let mut wrote = false;
for y in top.max(0)..bottom.min(front_buffer.height as i32) {
for x in left.max(0)..right.min(front_buffer.width as i32) {
let dx = (x as f64 - cx + 0.5) / rx;
let dy = (y as f64 - cy + 0.5) / ry;
let dist_sq = dx * dx + dy * dy;
if dist_sq > 1.0 {
continue;
}
let angle = (-(y as f64 - cy + 0.5)).atan2(x as f64 - cx + 0.5);
let mut mac_angle = 90.0 - angle.to_degrees();
if mac_angle < 0.0 {
mac_angle += 360.0;
}
let in_arc = (mac_angle >= a_start && mac_angle < a_end)
|| (a_end > 360.0 && mac_angle + 360.0 < a_end);
if in_arc {
wrote |= ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), color_pixel);
}
}
}
wrote
}
fn ppc_paint_region(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
region_handle: u32,
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
let Some(storage) = ppc_region_storage(memory, region_handle) else {
return false;
};
let Some((top, _, bottom, _)) = ppc_region_storage_bbox(&storage) else {
return true;
};
let Some(rows) = ppc_region_rows_for_band(&storage, top, bottom) else {
return false;
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let mut wrote = false;
for (row, endpoints) in rows.iter().enumerate() {
let y = i32::from(top) + row as i32 - i32::from(surface.top);
for interval in endpoints.chunks_exact(2) {
for x in (i32::from(interval[0]) - i32::from(surface.left))
..(i32::from(interval[1]) - i32::from(surface.left))
{
wrote |= ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), color_pixel);
}
}
}
wrote
}
fn ppc_frame_region(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
region_handle: u32,
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
// Inside Macintosh: Imaging With QuickDraw, pp. 3-100–3-101: FrameRgn
// draws the outline just inside the region boundary using the pen size.
let Some(storage) = ppc_region_storage(memory, region_handle) else {
return false;
};
let Some((top, _, bottom, _)) = ppc_region_storage_bbox(&storage) else {
return true;
};
let Some(rows) = ppc_region_rows_for_band(&storage, top, bottom) else {
return false;
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let pen_height = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET))
.unwrap_or(1),
)
.max(1);
let pen_width = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2))
.unwrap_or(1),
)
.max(1);
let row_contains = |row_idx: i32, x: i16| -> bool {
if row_idx < 0 || (row_idx as usize) >= rows.len() {
return false;
}
rows[row_idx as usize]
.chunks_exact(2)
.any(|interval| x >= interval[0] && x < interval[1])
};
let mut wrote = false;
for (row_idx, endpoints) in rows.iter().enumerate() {
let v = i32::from(top) + row_idx as i32;
let y = v - i32::from(surface.top);
for interval in endpoints.chunks_exact(2) {
for h in interval[0]..interval[1] {
let x = i32::from(h) - i32::from(surface.left);
let inside_inset = (row_idx as i32 - pen_height
..=row_idx as i32 + pen_height)
.all(|source_row| {
row_contains(source_row, h.saturating_sub(pen_width as i16))
&& row_contains(source_row, h.saturating_add(pen_width as i16))
});
if !inside_inset {
wrote |=
ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), color_pixel);
}
}
}
}
wrote
}
fn ppc_invert_region(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
region_handle: u32,
) -> bool {
let Some(storage) = ppc_region_storage(memory, region_handle) else {
return false;
};
let Some((top, _, bottom, _)) = ppc_region_storage_bbox(&storage) else {
return true;
};
let Some(rows) = ppc_region_rows_for_band(&storage, top, bottom) else {
return false;
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
let mask = match front_buffer.depth {
depth @ (1 | 2 | 4 | 8) => (1u16 << depth) - 1,
16 => 0x7fff,
_ => return false,
};
let mut wrote = false;
for (row, endpoints) in rows.iter().enumerate() {
let y = i32::from(top) + row as i32 - i32::from(surface.top);
for interval in endpoints.chunks_exact(2) {
for x in (i32::from(interval[0]) - i32::from(surface.left))
..(i32::from(interval[1]) - i32::from(surface.left))
{
if let Some(pixel) = ppc_quickdraw_read_pixel(memory, front_buffer, (x, y)) {
wrote |= ppc_invert_pixel_detail(memory, front_buffer, (x, y), pixel, mask);
}
}
}
}
wrote
}
fn ppc_current_text_font(memory: &mut PpcSectionMem, current_gworld: u32) -> i16 {
if current_gworld == 0 {
return PPC_QD_TEXT_FONT_DEFAULT;
}
memory
.read_u16_be(current_gworld + PPC_CGRAF_PORT_TX_FONT_OFFSET)
.map(|font| font as i16)
.unwrap_or(PPC_QD_TEXT_FONT_DEFAULT)
}
fn ppc_current_text_style(memory: &mut PpcSectionMem, current_gworld: u32) -> u8 {
if current_gworld == 0 {
return 0;
}
memory
.read_u8(current_gworld + PPC_CGRAF_PORT_TX_FACE_OFFSET)
.unwrap_or(0)
}
pub(super) fn ppc_text_byte_advance_for_font(ch: u8, text_font: i16, text_size: i16) -> i16 {
let (face, numerator, denominator) = get_font_face_scale_ratio(text_font, text_size);
get_glyph(text_font, face.size, ch as char)
.map(|(glyph, _)| ppc_scale_font_value(i32::from(glyph.advance), numerator, denominator))
.unwrap_or(6)
}
#[cfg(test)]
fn ppc_text_byte_advance(ch: u8, text_size: i16) -> i16 {
ppc_text_byte_advance_for_font(ch, PPC_QD_TEXT_FONT_DEFAULT, text_size)
}
pub(super) fn ppc_text_bytes_advance_for_font(bytes: &[u8], text_font: i16, text_size: i16) -> i16 {
let (face, numerator, denominator) = get_font_face_scale_ratio(text_font, text_size);
let base_advance = bytes.iter().fold(0i32, |advance, ch| {
advance.saturating_add(
get_glyph(text_font, face.size, *ch as char)
.map(|(glyph, _)| i32::from(glyph.advance))
.unwrap_or(6),
)
});
ppc_scale_font_value(base_advance, numerator, denominator)
}
// Inside Macintosh: Text (1993), Text Utilities, TruncString. Use the
// current QuickDraw font and Roman ellipsis, retaining Pascal byte lengths.
fn ppc_trunc_string(
memory: &mut PpcSectionMem,
string: u32,
width: i16,
where_: u16,
font: i16,
size: i16,
style: u8,
) -> i16 {
let Some(bytes) = ppc_read_pstring_bytes(memory, string) else {
return -1;
};
let measure = |text: &[u8]| ppc_text_width_bytes(font, size, style, text);
if measure(&bytes) <= width {
return 0;
}
const ELLIPSIS: u8 = 0xc9;
if !matches!(where_, 0 | 0x4000) || measure(&[ELLIPSIS]) > width {
return -1;
}
// A Pascal string has at most 255 bytes. Measure complete candidates so
// style advances and font scaling agree with StringWidth at the boundary.
for retained in (0..bytes.len()).rev() {
let left = if where_ == 0x4000 {
retained.div_ceil(2)
} else {
retained
};
let right = retained - left;
let mut candidate = bytes[..left].to_vec();
candidate.push(ELLIPSIS);
candidate.extend_from_slice(&bytes[bytes.len() - right..]);
if measure(&candidate) <= width {
return if ppc_write_pstring_bytes(memory, string, &candidate) {
1
} else {
-1
};
}
}
-1
}
fn ppc_text_width_bytes(text_font: i16, text_size: i16, style: u8, bytes: &[u8]) -> i16 {
let style = QuickDrawTextStyle::from_bits(style);
let (face, numerator, denominator) = get_font_face_scale_ratio(text_font, text_size);
let base_advance = bytes.iter().fold(0i32, |advance, ch| {
advance.saturating_add(
get_glyph(text_font, face.size, *ch as char)
.map(|(glyph, _)| style.glyph_advance(i32::from(glyph.advance)))
.unwrap_or_else(|| style.glyph_advance(6)),
)
});
ppc_scale_font_value(base_advance, numerator, denominator)
}
fn ppc_scale_font_value(value: i32, numerator: i32, denominator: i32) -> i16 {
let scaled = value
.saturating_mul(numerator)
.saturating_add(denominator / 2)
/ denominator;
i16::try_from(scaled).unwrap_or(if scaled < 0 { i16::MIN } else { i16::MAX })
}
fn ppc_scale_font_floor(value: i32, numerator: i32, denominator: i32) -> i32 {
let scaled = value.saturating_mul(numerator);
if scaled >= 0 {
scaled / denominator
} else {
-((-scaled).saturating_add(denominator - 1) / denominator)
}
}
#[cfg(test)]
fn ppc_text_bytes_advance(bytes: &[u8], text_size: i16) -> i16 {
ppc_text_bytes_advance_for_font(bytes, PPC_QD_TEXT_FONT_DEFAULT, text_size)
}
fn ppc_read_pascal_string(memory: &mut PpcSectionMem, string_ptr: u32) -> Option<Vec<u8>> {
let len = memory.read_u8(string_ptr)? as u32;
let mut bytes = Vec::with_capacity(len as usize);
for offset in 0..len {
bytes.push(memory.read_u8(string_ptr.checked_add(1 + offset)?)?);
}
Some(bytes)
}
#[allow(clippy::too_many_arguments)]
fn ppc_begin_outline_text_glyph(
memory: &mut PpcSectionMem,
surface: PpcQuickDrawSurface,
vis: Option<&[u8]>,
clip: Option<&[u8]>,
glyph: &crate::quickdraw::fonts::Glyph,
data: &[u8],
h: i32,
v: i32,
color: u16,
style: QuickDrawTextStyle,
italic: Option<i16>,
underline: Option<(i16, i16)>,
) {
let mut slot = memory.presentation();
if slot.is_none() || !matches!(surface.front_buffer.depth, 8 | 16) {
return;
}
let (Ok(h), Ok(v)) = (i16::try_from(h), i16::try_from(v)) else {
return;
};
slot.begin_outline_glyph(glyph, data, h, v, style.bold(), italic, underline);
slot.style_outline_glyph(style);
let bounds = slot.as_ref().and_then(|p| p.glyph_bounds());
let Some((top, left, bottom, right)) = bounds else {
return;
};
let fb = surface.front_buffer;
let lanes = fb.depth / 8;
for y in top.max(0)..bottom.min(fb.height as i32) {
for x in left.max(0)..right.min(fb.width as i32) {
if !ppc_local_point_in_port_regions(surface, (x, y), vis, clip) {
continue;
}
let address = fb.base_addr + y as u32 * fb.row_bytes + x as u32 * lanes;
for lane in 0..lanes {
let foreground = (color >> ((lanes - 1 - lane) * 8)) as u8;
let Some(background) = memory.read_u8(address + lane) else {
continue;
};
if let Some(mut p) = slot.as_mut() {
p.glyph_pixel(address + lane, x as i16, y as i16, foreground, background);
}
}
}
}
}
fn ppc_apply_text_pixel(
memory: &mut PpcSectionMem,
surface: PpcQuickDrawSurface,
vis_storage: Option<&[u8]>,
clip_storage: Option<&[u8]>,
point: (i32, i32),
color_pixel: u16,
text_mode: i16,
) -> bool {
if !ppc_local_point_in_port_regions(surface, point, vis_storage, clip_storage) {
return false;
}
let front_buffer = surface.front_buffer;
let mode = text_mode & 0x3f;
match mode {
2 => {
let Some(dst) = ppc_quickdraw_read_pixel(memory, front_buffer, point) else {
return false;
};
ppc_quickdraw_write_raw_pixel(memory, front_buffer, point, dst ^ color_pixel)
}
3 => {
let Some(dst) = ppc_quickdraw_read_pixel(memory, front_buffer, point) else {
return false;
};
ppc_quickdraw_write_raw_pixel(memory, front_buffer, point, dst & !color_pixel)
}
_ => ppc_quickdraw_write_raw_pixel(memory, front_buffer, point, color_pixel),
}
}
pub(super) fn ppc_draw_text_bytes(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
pen: (i16, i16),
text_font: i16,
text_size: i16,
text_mode: i16,
color: PpcRgbColor,
explicit_index: Option<u8>,
bytes: &[u8],
) -> i16 {
let advance = ppc_text_bytes_advance_for_font(bytes, text_font, text_size);
ppc_draw_text_chars(
memory,
gworlds,
current_gworld,
pen,
text_font,
text_size,
text_mode,
color,
explicit_index,
bytes.iter().map(|byte| char::from(*byte)),
);
advance
}
#[allow(clippy::too_many_arguments)]
fn ppc_draw_text_bytes_styled(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
pen: (i16, i16),
text_font: i16,
text_size: i16,
text_mode: i16,
color: PpcRgbColor,
explicit_index: Option<u8>,
style: u8,
bytes: &[u8],
) -> i16 {
let style = QuickDrawTextStyle::from_bits(style);
let (face, numerator, denominator) = get_font_face_scale_ratio(text_font, text_size);
let base_advance = bytes.iter().fold(0i32, |advance, ch| {
advance.saturating_add(
get_glyph(text_font, face.size, *ch as char)
.map(|(glyph, _)| style.glyph_advance(i32::from(glyph.advance)))
.unwrap_or_else(|| style.glyph_advance(6)),
)
});
let advance = ppc_scale_font_value(base_advance, numerator, denominator);
if style.is_plain() {
ppc_draw_text_chars(
memory,
gworlds,
current_gworld,
pen,
text_font,
text_size,
text_mode,
color,
explicit_index,
bytes.iter().map(|byte| char::from(*byte)),
);
} else {
ppc_draw_text_chars_styled(
memory,
gworlds,
current_gworld,
pen,
text_font,
text_size,
text_mode,
color,
explicit_index,
style,
base_advance,
bytes.iter().map(|byte| char::from(*byte)),
);
}
advance
}
#[allow(clippy::too_many_arguments)]
fn ppc_draw_text_chars(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
pen: (i16, i16),
text_font: i16,
text_size: i16,
text_mode: i16,
color: PpcRgbColor,
explicit_index: Option<u8>,
chars: impl IntoIterator<Item = char>,
) {
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return;
};
let front_buffer = surface.front_buffer;
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return;
}
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return;
};
let clip_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_CLIP_RGN_OFFSET))
.and_then(|clip_rgn| ppc_region_storage(memory, clip_rgn));
let vis_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_VIS_RGN_OFFSET))
.and_then(|vis_rgn| ppc_region_storage(memory, vis_rgn));
let (local_h, local_v) = surface.local_point((i32::from(pen.0), i32::from(pen.1)));
let (face, numerator, denominator) = get_font_face_scale_ratio(text_font, text_size);
let mut base_advance = 0i32;
for ch in chars {
if let Some((glyph, data)) = get_glyph(text_font, face.size, ch) {
if matches!(text_mode & 0x3f, 0 | 1) && numerator == denominator {
ppc_begin_outline_text_glyph(
memory,
surface,
vis_storage.as_deref(),
clip_storage.as_deref(),
glyph,
data,
local_h + base_advance,
local_v,
color_pixel,
QuickDrawTextStyle::from_bits(0),
None,
None,
);
}
let width = glyph.width as usize;
let height = glyph.height as usize;
for row in 0..height {
for col in 0..width {
let index = glyph.data_offset + row * width + col;
if index < data.len() && data[index] >= 128 {
let source_x = base_advance + i32::from(glyph.origin_x) + col as i32;
let source_y = i32::from(glyph.origin_y) + row as i32;
let left = local_h + ppc_scale_font_floor(source_x, numerator, denominator);
let right = local_h
+ ppc_scale_font_floor(source_x + 1, numerator, denominator)
.max(ppc_scale_font_floor(source_x, numerator, denominator) + 1);
let top = local_v + ppc_scale_font_floor(source_y, numerator, denominator);
let bottom = local_v
+ ppc_scale_font_floor(source_y + 1, numerator, denominator)
.max(ppc_scale_font_floor(source_y, numerator, denominator) + 1);
for y in top..bottom {
for x in left..right {
let _ = ppc_apply_text_pixel(
memory,
surface,
vis_storage.as_deref(),
clip_storage.as_deref(),
(x, y),
color_pixel,
text_mode,
);
}
}
}
}
}
memory.presentation().end_outline_glyph();
base_advance = base_advance.saturating_add(i32::from(glyph.advance));
} else {
base_advance = base_advance.saturating_add(6);
}
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_apply_scaled_text_source_pixel(
memory: &mut PpcSectionMem,
surface: PpcQuickDrawSurface,
vis_storage: Option<&[u8]>,
clip_storage: Option<&[u8]>,
local_h: i32,
local_v: i32,
source_x: i32,
source_y: i32,
numerator: i32,
denominator: i32,
color_pixel: u16,
text_mode: i16,
) {
let scaled_x = ppc_scale_font_floor(source_x, numerator, denominator);
let scaled_y = ppc_scale_font_floor(source_y, numerator, denominator);
let left = local_h + scaled_x;
let right =
local_h + ppc_scale_font_floor(source_x + 1, numerator, denominator).max(scaled_x + 1);
let top = local_v + scaled_y;
let bottom =
local_v + ppc_scale_font_floor(source_y + 1, numerator, denominator).max(scaled_y + 1);
for y in top..bottom {
for x in left..right {
let _ = ppc_apply_text_pixel(
memory,
surface,
vis_storage,
clip_storage,
(x, y),
color_pixel,
text_mode,
);
}
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_draw_text_chars_styled(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
pen: (i16, i16),
text_font: i16,
text_size: i16,
text_mode: i16,
color: PpcRgbColor,
explicit_index: Option<u8>,
style: QuickDrawTextStyle,
line_advance: i32,
chars: impl IntoIterator<Item = char>,
) {
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return;
};
let front_buffer = surface.front_buffer;
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return;
}
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return;
};
let clip_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_CLIP_RGN_OFFSET))
.and_then(|clip_rgn| ppc_region_storage(memory, clip_rgn));
let vis_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_VIS_RGN_OFFSET))
.and_then(|vis_rgn| ppc_region_storage(memory, vis_rgn));
let (local_h, local_v) = surface.local_point((i32::from(pen.0), i32::from(pen.1)));
let (face, numerator, denominator) = get_font_face_scale_ratio(text_font, text_size);
let metrics = get_font_metrics(text_font, face.size);
let mut source_advance = 0i32;
for ch in chars {
let (glyph_hit, synthetic_italic) = if style.italic() {
if let Some(hit) = get_glyph_italic(text_font, face.size, ch) {
(Some(hit), false)
} else {
(get_glyph(text_font, face.size, ch), true)
}
} else {
(get_glyph(text_font, face.size, ch), false)
};
let Some((glyph, data)) = glyph_hit else {
source_advance = source_advance.saturating_add(6);
continue;
};
if matches!(text_mode & 0x3f, 0 | 1) && numerator == denominator {
ppc_begin_outline_text_glyph(
memory,
surface,
vis_storage.as_deref(),
clip_storage.as_deref(),
glyph,
data,
local_h + source_advance,
local_v,
color_pixel,
style,
synthetic_italic.then_some(metrics.descent),
style.underline().then_some((
glyph.advance as i16,
get_underline_thickness(text_font, face.size).max(1),
)),
);
}
let mut base_pixels = HashSet::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 {
continue;
}
let source_y = i32::from(glyph.origin_y) + row as i32;
let slant = synthetic_italic.then(|| {
get_italic_slant(
text_font,
face.size,
&metrics,
0,
i16::try_from(source_y).unwrap_or(0),
)
});
let source_x = source_advance
+ i32::from(glyph.origin_x)
+ col as i32
+ i32::from(slant.unwrap_or(0));
base_pixels.insert((source_x, source_y));
if style.bold() {
base_pixels.insert((source_x + 1, source_y));
}
}
}
if style.underline() && style.smear_max().is_some() && line_advance > 0 {
let underline_offset: i32 = if style.shadow() { -1 } else { 0 };
let synthetic_italic = style.italic()
&& get_glyph_italic(text_font, face.size, 'A').is_none();
let underline_left = if synthetic_italic {
get_italic_underline_extend_left(
text_font,
face.size,
style.bold(),
false,
)
} else {
0
};
let underline_right = if synthetic_italic {
get_italic_end_extend(text_font, face.size, &metrics)
} else {
0
};
let final_effect_advance = style.glyph_advance(0);
for source_x in underline_offset.saturating_sub(i32::from(underline_left))
..line_advance
.saturating_sub(final_effect_advance)
.saturating_add(underline_offset)
.saturating_add(i32::from(underline_right))
{
base_pixels.insert((source_x, 1));
}
}
if let Some(smear_max) = style.smear_max() {
let min_x = base_pixels
.iter()
.map(|(x, _)| *x)
.min()
.unwrap_or(source_advance)
- 1;
let max_x = base_pixels
.iter()
.map(|(x, _)| *x)
.max()
.unwrap_or(source_advance)
+ smear_max;
let min_y = base_pixels.iter().map(|(_, y)| *y).min().unwrap_or(0) - 1;
let max_y = base_pixels.iter().map(|(_, y)| *y).max().unwrap_or(0) + smear_max;
for source_y in min_y..=max_y {
for source_x in min_x..=max_x {
if base_pixels.contains(&(source_x, source_y)) {
continue;
}
let smeared = (-1..=smear_max).any(|dy| {
(-1..=smear_max)
.any(|dx| base_pixels.contains(&(source_x - dx, source_y - dy)))
});
if smeared {
ppc_apply_scaled_text_source_pixel(
memory,
surface,
vis_storage.as_deref(),
clip_storage.as_deref(),
local_h,
local_v,
source_x,
source_y,
numerator,
denominator,
color_pixel,
text_mode,
);
}
}
}
} else {
for (source_x, source_y) in base_pixels.iter().copied() {
ppc_apply_scaled_text_source_pixel(
memory,
surface,
vis_storage.as_deref(),
clip_storage.as_deref(),
local_h,
local_v,
source_x,
source_y,
numerator,
denominator,
color_pixel,
text_mode,
);
}
}
memory.presentation().end_outline_glyph();
source_advance =
source_advance.saturating_add(style.glyph_advance(i32::from(glyph.advance)));
}
if style.underline() && style.smear_max().is_none() && source_advance > 0 {
let thickness = get_underline_thickness(text_font, face.size).max(1);
for dy in 1..=i32::from(thickness) {
for source_x in 0..source_advance {
ppc_apply_scaled_text_source_pixel(
memory,
surface,
vis_storage.as_deref(),
clip_storage.as_deref(),
local_h,
local_v,
source_x,
dy,
numerator,
denominator,
color_pixel,
text_mode,
);
}
}
}
}
fn ppc_paint_rect(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
fore_color: PpcRgbColor,
explicit_index: Option<u8>,
back_color: PpcRgbColor,
pattern: &[u8; 8],
) -> bool {
let Some(rect) = ppc_read_rect(memory, cpu.gpr[3]) else {
return false;
};
if pattern.iter().all(|row| *row == 0xff) {
return ppc_paint_rect_bounds(
memory,
gworlds,
current_gworld,
rect,
fore_color,
explicit_index,
);
}
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return false;
}
let Some(fore_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, fore_color, explicit_index)
else {
return false;
};
let Some(back_pixel) = ppc_quickdraw_surface_color_pixel(memory, surface, back_color) else {
return false;
};
let (top, left, bottom, right) = surface.local_rect(rect);
let left = left.max(0).min(front_buffer.width as i32);
let top = top.max(0).min(front_buffer.height as i32);
let right = right.max(0).min(front_buffer.width as i32);
let bottom = bottom.max(0).min(front_buffer.height as i32);
let clip_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_CLIP_RGN_OFFSET))
.and_then(|clip_rgn| ppc_region_storage(memory, clip_rgn));
let vis_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_VIS_RGN_OFFSET))
.and_then(|vis_rgn| ppc_region_storage(memory, vis_rgn));
let mut wrote = false;
for y in top..bottom {
let pattern_row = pattern[(y as usize) & 7];
for x in left..right {
if !ppc_local_point_in_port_regions(
surface,
(x, y),
vis_storage.as_deref(),
clip_storage.as_deref(),
) {
continue;
}
let mask = 0x80 >> ((x as usize) & 7);
let pixel = if pattern_row & mask != 0 {
fore_pixel
} else {
back_pixel
};
wrote |= ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), pixel);
}
}
wrote
}
pub(super) fn ppc_paint_rect_bounds(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
rect: (i16, i16, i16, i16),
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return false;
}
let (top, left, bottom, right) = surface.local_rect(rect);
let left = left.max(0).min(front_buffer.width as i32);
let top = top.max(0).min(front_buffer.height as i32);
let right = right.max(0).min(front_buffer.width as i32);
let bottom = bottom.max(0).min(front_buffer.height as i32);
if left >= right || top >= bottom {
return false;
}
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let clip_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_CLIP_RGN_OFFSET))
.and_then(|clip_rgn| ppc_region_storage(memory, clip_rgn));
let vis_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_VIS_RGN_OFFSET))
.and_then(|vis_rgn| ppc_region_storage(memory, vis_rgn));
// Imaging With QuickDraw (1994), pp. 2-20--2-21: every destination pixel
// is constrained by visRgn ∩ clipRgn. Per-pixel writes also preserve the
// neighboring fields of packed 1/2/4-bit PixMaps.
if matches!(front_buffer.depth, 8 | 16)
&& [
top + i32::from(surface.top),
bottom + i32::from(surface.top),
left + i32::from(surface.left),
right + i32::from(surface.left),
]
.into_iter()
.all(|value| i16::try_from(value).is_ok())
{
let port_top = (top + i32::from(surface.top)) as i16;
let port_bottom = (bottom + i32::from(surface.top)) as i16;
let port_left = (left + i32::from(surface.left)) as i16;
let port_right = (right + i32::from(surface.left)) as i16;
let mut rows = vec![
vec![port_left, port_right];
(port_bottom as i32 - port_top as i32).max(0) as usize
];
for storage in [vis_storage.as_deref(), clip_storage.as_deref()]
.into_iter()
.flatten()
{
let Some(clip_rows) = ppc_region_rows_for_band(storage, port_top, port_bottom) else {
return false;
};
for (row, clip) in rows.iter_mut().zip(clip_rows) {
*row = ppc_region_intersect_rows(row, &clip);
}
}
let lanes = (front_buffer.depth / 8) as usize;
let pixel = color_pixel.to_be_bytes();
let row_bytes: Vec<_> = (left..right)
.flat_map(|_| pixel[2 - lanes..].iter().copied())
.collect();
let mut wrote = false;
for (dy, row) in rows.iter().enumerate() {
let y = i32::from(port_top) + dy as i32 - i32::from(surface.top);
for pair in row.chunks_exact(2) {
let x = i32::from(pair[0]) - i32::from(surface.left);
let len = (i32::from(pair[1]) - i32::from(pair[0])) as usize * lanes;
let address = front_buffer.base_addr
+ y as u32 * front_buffer.row_bytes
+ x as u32 * lanes as u32;
wrote |= memory.write_bytes(address, &row_bytes[..len]).is_some();
}
}
return wrote;
}
let mut wrote = false;
for y in top..bottom {
for x in left..right {
if ppc_local_point_in_port_regions(
surface,
(x, y),
vis_storage.as_deref(),
clip_storage.as_deref(),
) {
wrote |= ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), color_pixel);
}
}
}
wrote
}
fn ppc_invert_rect(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
) -> bool {
let Some(rect) = ppc_read_rect(memory, cpu.gpr[3]) else {
return false;
};
ppc_invert_rect_bounds(memory, gworlds, current_gworld, rect)
}
fn ppc_invert_pixel_detail(
memory: &mut PpcSectionMem,
front: PpcFrontBuffer,
point: (i32, i32),
pixel: u16,
mask: u16,
) -> bool {
let mut detail = crate::memory::SavedPixels::<()>::default();
ppc_capture_saved_detail(memory, front, point, &mut detail, 0);
let wrote = ppc_quickdraw_write_raw_pixel(memory, front, point, pixel ^ mask);
if wrote && matches!(front.depth, 8 | 16) {
let lanes = (front.depth / 8) as usize;
detail.transform_detail(|offset, value| value ^ (mask >> ((lanes - 1 - offset) * 8)) as u8);
ppc_restore_saved_detail(memory, front, point, &detail, 0);
}
wrote
}
fn ppc_invert_rect_bounds(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
rect: (i16, i16, i16, i16),
) -> bool {
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
let mask = match front_buffer.depth {
depth @ (1 | 2 | 4 | 8) => (1u16 << depth) - 1,
16 => 0x7fff,
_ => return false,
};
let (top, left, bottom, right) = surface.local_rect(rect);
let left = left.max(0).min(front_buffer.width as i32);
let top = top.max(0).min(front_buffer.height as i32);
let right = right.max(0).min(front_buffer.width as i32);
let bottom = bottom.max(0).min(front_buffer.height as i32);
if left >= right || top >= bottom {
return false;
}
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 3-42--3-43:
// InvertRect complements every destination pixel in the rectangle and is
// independent of the current foreground color and pen pattern. The same
// volume, pp. 2-13--2-14, defines a basic BitMap as one bit per pixel, so
// monochrome offscreen ports must participate in that complement too.
let mut wrote = false;
for y in top..bottom {
for x in left..right {
if let Some(pixel) = ppc_quickdraw_read_pixel(memory, front_buffer, (x, y)) {
wrote |= ppc_invert_pixel_detail(memory, front_buffer, (x, y), pixel, mask);
}
}
}
wrote
}
fn ppc_frame_rect(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
let Some(rect) = ppc_read_rect(memory, cpu.gpr[3]) else {
return false;
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return false;
}
let (top, left, bottom, right) = surface.local_rect(rect);
let left = left.max(0).min(front_buffer.width as i32);
let top = top.max(0).min(front_buffer.height as i32);
let right = right.max(0).min(front_buffer.width as i32);
let bottom = bottom.max(0).min(front_buffer.height as i32);
if left >= right || top >= bottom {
return false;
}
let pen_height = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET))
.unwrap_or(1),
)
.min(bottom - top);
let pen_width = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2))
.unwrap_or(1),
)
.min(right - left);
if pen_width == 0 || pen_height == 0 {
return true;
}
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let mut wrote = false;
for dy in 0..pen_height {
for x in left..right {
wrote |=
ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, top + dy), color_pixel);
wrote |= ppc_quickdraw_write_raw_pixel(
memory,
front_buffer,
(x, bottom - 1 - dy),
color_pixel,
);
}
}
for dx in 0..pen_width {
for y in top..bottom {
wrote |=
ppc_quickdraw_write_raw_pixel(memory, front_buffer, (left + dx, y), color_pixel);
wrote |= ppc_quickdraw_write_raw_pixel(
memory,
front_buffer,
(right - 1 - dx, y),
color_pixel,
);
}
}
wrote
}
fn ppc_frame_round_rect(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
let Some(rect) = ppc_read_rect(memory, cpu.gpr[3]) else {
return false;
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return false;
}
let (top, left, bottom, right) = surface.local_rect(rect);
let left = left.max(0).min(front_buffer.width as i32);
let top = top.max(0).min(front_buffer.height as i32);
let right = right.max(0).min(front_buffer.width as i32);
let bottom = bottom.max(0).min(front_buffer.height as i32);
if left >= right || top >= bottom {
return false;
}
let pen_height = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET))
.unwrap_or(1),
)
.min(bottom - top);
let pen_width = i32::from(
memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2))
.unwrap_or(1),
)
.min(right - left);
if pen_width == 0 || pen_height == 0 {
return true;
}
let oval_width = (cpu.gpr[4] as u16 as i16).max(0) as i32;
let oval_height = (cpu.gpr[5] as u16 as i16).max(0) as i32;
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let clip_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_CLIP_RGN_OFFSET))
.and_then(|clip_rgn| ppc_region_storage(memory, clip_rgn));
let vis_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_VIS_RGN_OFFSET))
.and_then(|vis_rgn| ppc_region_storage(memory, vis_rgn));
let inner_left = left + pen_width;
let inner_top = top + pen_height;
let inner_right = right - pen_width;
let inner_bottom = bottom - pen_height;
let mut wrote = false;
for y in top..bottom {
for x in left..right {
let outer =
ppc_point_in_rounded_rect(x, y, left, top, right, bottom, oval_width, oval_height);
let inner = inner_left < inner_right
&& inner_top < inner_bottom
&& ppc_point_in_rounded_rect(
x,
y,
inner_left,
inner_top,
inner_right,
inner_bottom,
oval_width.saturating_sub(pen_width.saturating_mul(2)),
oval_height.saturating_sub(pen_height.saturating_mul(2)),
);
if outer
&& !inner
&& ppc_local_point_in_port_regions(
surface,
(x, y),
vis_storage.as_deref(),
clip_storage.as_deref(),
)
{
wrote |= ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), color_pixel);
}
}
}
wrote
}
fn ppc_paint_round_rect(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
let Some(rect) = ppc_read_rect(memory, cpu.gpr[3]) else {
return false;
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return false;
}
let (top, left, bottom, right) = surface.local_rect(rect);
let left = left.max(0).min(front_buffer.width as i32);
let top = top.max(0).min(front_buffer.height as i32);
let right = right.max(0).min(front_buffer.width as i32);
let bottom = bottom.max(0).min(front_buffer.height as i32);
if left >= right || top >= bottom {
return false;
}
let oval_width = (cpu.gpr[4] as u16 as i16).max(0) as i32;
let oval_height = (cpu.gpr[5] as u16 as i16).max(0) as i32;
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let clip_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_CLIP_RGN_OFFSET))
.and_then(|clip_rgn| ppc_region_storage(memory, clip_rgn));
let vis_storage = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_VIS_RGN_OFFSET))
.and_then(|vis_rgn| ppc_region_storage(memory, vis_rgn));
let mut wrote = false;
for y in top..bottom {
for x in left..right {
if ppc_point_in_rounded_rect(
x,
y,
left,
top,
right,
bottom,
oval_width,
oval_height,
) && ppc_local_point_in_port_regions(
surface,
(x, y),
vis_storage.as_deref(),
clip_storage.as_deref(),
) {
wrote |= ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), color_pixel);
}
}
}
wrote
}
#[allow(clippy::too_many_arguments)]
fn ppc_point_in_rounded_rect(
x: i32,
y: i32,
left: i32,
top: i32,
right: i32,
bottom: i32,
oval_width: i32,
oval_height: i32,
) -> bool {
let radius_x = (oval_width.min(right - left).max(0) as f64) / 2.0;
let radius_y = (oval_height.min(bottom - top).max(0) as f64) / 2.0;
if radius_x == 0.0 || radius_y == 0.0 {
return (left..right).contains(&x) && (top..bottom).contains(&y);
}
let px = f64::from(x) + 0.5;
let py = f64::from(y) + 0.5;
let center_x = if px < f64::from(left) + radius_x {
f64::from(left) + radius_x
} else if px > f64::from(right) - radius_x {
f64::from(right) - radius_x
} else {
px
};
let center_y = if py < f64::from(top) + radius_y {
f64::from(top) + radius_y
} else if py > f64::from(bottom) - radius_y {
f64::from(bottom) - radius_y
} else {
py
};
let dx = (px - center_x) / radius_x;
let dy = (py - center_y) / radius_y;
dx * dx + dy * dy <= 1.0
}
const PPC_PIXELS_PURGEABLE: u32 = 1 << 6;
const PPC_PIXELS_LOCKED: u32 = 1 << 7;
const PPC_KEEP_LOCAL: u32 = 1 << 3;
fn ppc_gworld_pixel_state_from_mirror(record: &PpcGWorldRecord) -> u32 {
(u32::from(!record.pixels_no_purge) * PPC_PIXELS_PURGEABLE)
| (u32::from(record.pixels_locked) * PPC_PIXELS_LOCKED)
}
fn ppc_sync_gworld_pixel_state_mirrors(
gworlds: &mut [PpcGWorldRecord],
pixel_states: &SharedProcessQuickDrawPixelStates,
) {
for record in gworlds {
if record.pixmap_handle == 0 {
continue;
}
if !pixel_states.has_quickdraw_pixel_state(record.pixmap_handle) {
// Synthetic/native records created before the process registry
// existed contribute their old booleans exactly once; after this
// adoption the registry is canonical.
pixel_states.set_quickdraw_pixel_state(
record.pixmap_handle,
ppc_gworld_pixel_state_from_mirror(record),
);
}
let state = pixel_states.quickdraw_pixel_state(record.pixmap_handle);
record.pixels_locked = state & PPC_PIXELS_LOCKED != 0;
record.pixels_no_purge = state & PPC_PIXELS_PURGEABLE == 0;
}
}
/// Return a process-owned state word, adopting a legacy native mirror only
/// for a record that predates the shared registry. This compatibility path is
/// intentionally one-way: every subsequent transition writes the registry.
fn ppc_ensure_gworld_pixel_state(
gworlds: &[PpcGWorldRecord],
pixel_states: &SharedProcessQuickDrawPixelStates,
pixmap_handle: u32,
) -> Option<u32> {
if pixmap_handle == 0 {
return None;
}
if pixel_states.has_quickdraw_pixel_state(pixmap_handle) {
return Some(pixel_states.quickdraw_pixel_state(pixmap_handle));
}
let state = gworlds
.iter()
.find(|record| record.pixmap_handle == pixmap_handle)
.map(ppc_gworld_pixel_state_from_mirror)?;
pixel_states.set_quickdraw_pixel_state(pixmap_handle, state);
Some(state)
}
fn ppc_sync_gworld_pixel_state_mirror(
gworlds: &mut [PpcGWorldRecord],
pixmap_handle: u32,
state: u32,
) {
if let Some(record) = gworlds
.iter_mut()
.find(|record| record.pixmap_handle == pixmap_handle)
{
record.pixels_locked = state & PPC_PIXELS_LOCKED != 0;
record.pixels_no_purge = state & PPC_PIXELS_PURGEABLE == 0;
}
}
fn ppc_set_gworld_pixel_state(
gworlds: &mut [PpcGWorldRecord],
pixel_states: &SharedProcessQuickDrawPixelStates,
pixmap_handle: u32,
state: u32,
) {
let Some(existing) = ppc_ensure_gworld_pixel_state(gworlds, pixel_states, pixmap_handle)
else {
return;
};
let masked = state & (PPC_KEEP_LOCAL | PPC_PIXELS_PURGEABLE | PPC_PIXELS_LOCKED);
let preserved = existing & !(PPC_PIXELS_PURGEABLE | PPC_PIXELS_LOCKED);
let next = preserved | masked;
pixel_states.set_quickdraw_pixel_state(pixmap_handle, next);
ppc_sync_gworld_pixel_state_mirror(gworlds, pixmap_handle, next);
}
fn ppc_lock_pixels(
gworlds: &mut [PpcGWorldRecord],
pixel_states: &SharedProcessQuickDrawPixelStates,
pixmap_handle: u32,
) -> u32 {
let Some(state) = ppc_ensure_gworld_pixel_state(gworlds, pixel_states, pixmap_handle) else {
return 0;
};
let next = state | PPC_PIXELS_LOCKED;
pixel_states.set_quickdraw_pixel_state(pixmap_handle, next);
ppc_sync_gworld_pixel_state_mirror(gworlds, pixmap_handle, next);
1
}
fn ppc_unlock_pixels(
gworlds: &mut [PpcGWorldRecord],
pixel_states: &SharedProcessQuickDrawPixelStates,
pixmap_handle: u32,
) {
let Some(state) = ppc_ensure_gworld_pixel_state(gworlds, pixel_states, pixmap_handle) else {
return;
};
let next = state & !PPC_PIXELS_LOCKED;
pixel_states.set_quickdraw_pixel_state(pixmap_handle, next);
ppc_sync_gworld_pixel_state_mirror(gworlds, pixmap_handle, next);
}
fn ppc_allow_purge_pixels(
gworlds: &mut [PpcGWorldRecord],
pixel_states: &SharedProcessQuickDrawPixelStates,
pixmap_handle: u32,
) {
let Some(state) = ppc_ensure_gworld_pixel_state(gworlds, pixel_states, pixmap_handle) else {
return;
};
let next = state | PPC_PIXELS_PURGEABLE;
pixel_states.set_quickdraw_pixel_state(pixmap_handle, next);
ppc_sync_gworld_pixel_state_mirror(gworlds, pixmap_handle, next);
}
fn ppc_no_purge_pixels(
gworlds: &mut [PpcGWorldRecord],
pixel_states: &SharedProcessQuickDrawPixelStates,
pixmap_handle: u32,
) {
let Some(state) = ppc_ensure_gworld_pixel_state(gworlds, pixel_states, pixmap_handle) else {
return;
};
let next = state & !PPC_PIXELS_PURGEABLE;
pixel_states.set_quickdraw_pixel_state(pixmap_handle, next);
ppc_sync_gworld_pixel_state_mirror(gworlds, pixmap_handle, next);
}
fn ppc_read_pixmap_bits(memory: &mut PpcSectionMem, pixmap: u32) -> Option<PpcPixMapBits> {
let base_addr = memory.read_u32_be(pixmap)?;
let packed_row_bytes = memory.read_u16_be(pixmap + 4)?;
let row_bytes = u32::from(packed_row_bytes & 0x3fff);
let (top, left, bottom, right) = ppc_read_rect(memory, pixmap + 6)?;
let width = u32::try_from(i32::from(right) - i32::from(left)).ok()?;
let height = u32::try_from(i32::from(bottom) - i32::from(top)).ok()?;
if base_addr == 0 || row_bytes == 0 || width == 0 || height == 0 {
return None;
}
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 3-12 and 4-46:
// BitMap is the 14-byte prefix shared with PixMap, and a set high bit in
// rowBytes distinguishes the extended PixMap record. Never read pmSize
// from the bytes following a basic BitMap; inside a GrafPort those bytes
// are portRect/visRgn fields and can look like a bogus depth such as -1.
let depth = if packed_row_bytes & 0x8000 == 0 {
1
} else {
memory
.read_u16_be(pixmap + 32)
.map(u32::from)
.filter(|depth| *depth != 0)
.unwrap_or_else(|| {
if row_bytes >= width.saturating_mul(2) {
16
} else {
0
}
})
};
if depth == 0 {
return None;
}
if packed_row_bytes & 0x8000 != 0 && matches!(depth, 1 | 2 | 4 | 8 | 16 | 32) {
let required_row_bytes = width.checked_mul(depth)?.checked_add(7)? / 8;
if row_bytes < required_row_bytes {
return None;
}
}
Some(PpcPixMapBits {
base_addr,
row_bytes,
top,
left,
bottom,
right,
width,
height,
depth,
})
}
pub(super) fn ppc_read_pixmap_handle_bits(
memory: &mut PpcSectionMem,
pixmap_handle: u32,
) -> Option<PpcPixMapBits> {
let pixmap = memory.read_u32_be(pixmap_handle)?;
ppc_read_pixmap_bits(memory, pixmap)
}
fn ppc_pixmap_bits_from_record(record: PpcGWorldRecord) -> Option<PpcPixMapBits> {
let right = ppc_u32_to_i16_saturating(record.width);
let bottom = ppc_u32_to_i16_saturating(record.height);
Some(PpcPixMapBits {
base_addr: record.base_addr,
row_bytes: record.row_bytes,
top: 0,
left: 0,
bottom,
right,
width: record.width,
height: record.height,
depth: record.depth,
})
}
fn ppc_resolve_pixmap_bits(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
bits_ptr: u32,
) -> Option<PpcPixMapBits> {
ppc_resolve_pixmap_bits_with_provenance(memory, gworlds, bits_ptr).map(|resolved| resolved.bits)
}
fn ppc_resolve_pixmap_bits_with_provenance(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
bits_ptr: u32,
) -> Option<PpcResolvedPixMapBits> {
if bits_ptr == 0 {
return None;
}
if let Some(record) = gworlds
.iter()
.find(|record| {
record.pixmap == bits_ptr
|| record.pixmap_handle == bits_ptr
|| record.port == bits_ptr
|| record.port.checked_add(2) == Some(bits_ptr)
})
.copied()
{
if record.port == bits_ptr || record.port.checked_add(2) == Some(bits_ptr) {
let surface = ppc_live_quickdraw_surface(memory, gworlds, record.port)?;
let front = surface.front_buffer;
let bits = PpcPixMapBits {
base_addr: front.base_addr,
row_bytes: front.row_bytes,
top: surface.top,
left: surface.left,
bottom: ppc_i32_to_i16_saturating(
i32::from(surface.top).saturating_add(front.height as i32),
),
right: ppc_i32_to_i16_saturating(
i32::from(surface.left).saturating_add(front.width as i32),
),
width: front.width,
height: front.height,
depth: front.depth,
};
let exact_bottom = i64::from(surface.top) + i64::from(front.height);
let exact_right = i64::from(surface.left) + i64::from(front.width);
return Some(PpcResolvedPixMapBits {
bits,
guest_bounds: false,
authoritative_bounds: i16::try_from(exact_bottom).is_ok()
&& i16::try_from(exact_right).is_ok(),
});
}
let bits = if record.pixmap_handle == bits_ptr {
ppc_read_pixmap_handle_bits(memory, bits_ptr)
} else {
ppc_read_pixmap_bits(memory, record.pixmap)
};
return bits
.map(|bits| PpcResolvedPixMapBits {
bits,
guest_bounds: true,
authoritative_bounds: true,
})
.or_else(|| {
ppc_pixmap_bits_from_record(record).map(|bits| PpcResolvedPixMapBits {
bits,
guest_bounds: false,
authoritative_bounds: i16::try_from(record.height).is_ok()
&& i16::try_from(record.width).is_ok(),
})
});
}
if let Some(bits) = ppc_read_pixmap_bits(memory, bits_ptr) {
return Some(PpcResolvedPixMapBits {
bits,
guest_bounds: true,
authoritative_bounds: true,
});
}
let pixmap_or_handle = memory.read_u32_be(bits_ptr)?;
ppc_read_pixmap_bits(memory, pixmap_or_handle)
.or_else(|| ppc_read_pixmap_handle_bits(memory, pixmap_or_handle))
.map(|bits| PpcResolvedPixMapBits {
bits,
guest_bounds: true,
authoritative_bounds: true,
})
}
fn ppc_read_pixmap_raw_pixel(
memory: &mut PpcSectionMem,
bits: PpcPixMapBits,
x: i32,
y: i32,
) -> Option<u32> {
if x < i32::from(bits.left)
|| x >= i32::from(bits.right)
|| y < i32::from(bits.top)
|| y >= i32::from(bits.bottom)
{
return None;
}
let x_offset = u32::try_from(x - i32::from(bits.left)).ok()?;
let y_offset = u32::try_from(y - i32::from(bits.top)).ok()?;
let row = bits
.base_addr
.checked_add(y_offset.checked_mul(bits.row_bytes)?)?;
match bits.depth {
1 | 2 | 4 => {
let bit_offset = x_offset.checked_mul(bits.depth)?;
let byte_offset = bit_offset / 8;
if byte_offset >= bits.row_bytes {
return None;
}
let shift = 8u32.checked_sub(bits.depth)?.checked_sub(bit_offset & 7)?;
let mask = (1u8 << bits.depth) - 1;
memory
.read_u8(row.checked_add(byte_offset)?)
.map(|byte| u32::from((byte >> shift) & mask))
}
8 => {
if x_offset >= bits.row_bytes {
return None;
}
memory.read_u8(row.checked_add(x_offset)?).map(u32::from)
}
16 => {
let byte_offset = x_offset.checked_mul(2)?;
if byte_offset.checked_add(2)? > bits.row_bytes {
return None;
}
memory
.read_u16_be(row.checked_add(byte_offset)?)
.map(u32::from)
}
32 => {
let byte_offset = x_offset.checked_mul(4)?;
if byte_offset.checked_add(4)? > bits.row_bytes {
return None;
}
memory.read_u32_be(row.checked_add(byte_offset)?)
}
_ => None,
}
}
fn ppc_pixmap_pixel_rgb(
bits: PpcPixMapBits,
pixel: u32,
clut: Option<&[[u16; 3]; 256]>,
) -> Option<[u16; 3]> {
match bits.depth {
1 => Some(if pixel == 0 {
[u16::MAX; 3]
} else {
[0; 3]
}),
_depth @ (2 | 4 | 8) => clut?.get(pixel as usize).copied(),
16 => Some(ppc_rgb555_to_rgb16(pixel as u16)),
32 => Some([
u16::from(((pixel >> 16) & 0xff) as u8) * 0x0101,
u16::from(((pixel >> 8) & 0xff) as u8) * 0x0101,
u16::from((pixel & 0xff) as u8) * 0x0101,
]),
_ => None,
}
}
fn ppc_rgb_to_pixmap_pixel(
bits: PpcPixMapBits,
rgb: [u16; 3],
clut: Option<&[[u16; 3]; 256]>,
) -> Option<u32> {
match bits.depth {
1 => {
let black_distance = u64::from(rgb[0]).pow(2)
+ u64::from(rgb[1]).pow(2)
+ u64::from(rgb[2]).pow(2);
let white_distance = u64::from(u16::MAX - rgb[0]).pow(2)
+ u64::from(u16::MAX - rgb[1]).pow(2)
+ u64::from(u16::MAX - rgb[2]).pow(2);
Some(u32::from(black_distance <= white_distance))
}
depth @ (2 | 4 | 8) => Some(u32::from(ppc_rgb_color_to_index_in_clut(
PpcRgbColor {
red: rgb[0],
green: rgb[1],
blue: rgb[2],
},
clut?,
ppc_indexed_depth_entry_count(depth)?,
))),
16 => Some(u32::from(ppc_rgb_color_to_rgb555(PpcRgbColor {
red: rgb[0],
green: rgb[1],
blue: rgb[2],
}))),
32 => Some(
(u32::from(rgb[0] >> 8) << 16)
| (u32::from(rgb[1] >> 8) << 8)
| u32::from(rgb[2] >> 8),
),
_ => None,
}
}
fn ppc_blend_deep_mask_rgb(source: [u16; 3], destination: [u16; 3], mask: [u16; 3]) -> [u16; 3] {
std::array::from_fn(|component| {
let source = u64::from(source[component]);
let destination = u64::from(destination[component]);
let mask = u64::from(mask[component]);
((source * (u64::from(u16::MAX) - mask) + destination * mask + 32_767)
/ u64::from(u16::MAX)) as u16
})
}
fn ppc_deep_mask_boolean_pixel(source: u32, destination: u32, depth: u32, mode: u16) -> u32 {
if depth == 1 {
let source = u32::from(source != 0);
let destination = u32::from(destination != 0);
return match mode {
0 => source,
1 => source | destination,
2 => source ^ destination,
3 => (!source) & destination & 1,
4 => 1 - source,
5 => (1 - source) | destination,
6 => (1 - source) ^ destination,
7 => source & destination,
_ => source,
};
}
let value_mask = match depth {
2 | 4 | 8 => (1u32 << depth) - 1,
16 => u32::from(u16::MAX),
32 => u32::MAX,
_ => 0,
};
match mode {
0 => source,
1 => source | destination,
2 => source ^ destination,
3 => (!source) & destination & value_mask,
4 => !source & value_mask,
5 => (!source & value_mask) | destination,
6 => (!source & value_mask) ^ destination,
7 => source & destination,
_ => source,
}
}
fn ppc_write_pixmap_raw_pixel(
memory: &mut PpcSectionMem,
bits: PpcPixMapBits,
x: i32,
y: i32,
pixel: u32,
) -> Option<()> {
if x < i32::from(bits.left)
|| x >= i32::from(bits.right)
|| y < i32::from(bits.top)
|| y >= i32::from(bits.bottom)
{
return None;
}
let x_offset = u32::try_from(x - i32::from(bits.left)).ok()?;
let y_offset = u32::try_from(y - i32::from(bits.top)).ok()?;
let row = bits
.base_addr
.checked_add(y_offset.checked_mul(bits.row_bytes)?)?;
match bits.depth {
1 | 2 | 4 => {
let bit_offset = x_offset.checked_mul(bits.depth)?;
let byte_offset = bit_offset / 8;
if byte_offset >= bits.row_bytes {
return None;
}
let addr = row.checked_add(byte_offset)?;
let shift = 8u32.checked_sub(bits.depth)?.checked_sub(bit_offset & 7)?;
let value_mask = (1u8 << bits.depth) - 1;
let field_mask = value_mask << shift;
let byte = memory.read_u8(addr)?;
memory.write_u8(
addr,
(byte & !field_mask) | (((pixel as u8) & value_mask) << shift),
)?;
}
8 => {
if x_offset >= bits.row_bytes {
return None;
}
memory.write_u8(row.checked_add(x_offset)?, pixel as u8)?;
}
16 => {
let byte_offset = x_offset.checked_mul(2)?;
if byte_offset.checked_add(2)? > bits.row_bytes {
return None;
}
memory.write_u16_be(row.checked_add(byte_offset)?, pixel as u16)?;
}
32 => {
let byte_offset = x_offset.checked_mul(4)?;
if byte_offset.checked_add(4)? > bits.row_bytes {
return None;
}
memory.write_u32_be(row.checked_add(byte_offset)?, pixel)?;
}
_ => return None,
}
Some(())
}
fn ppc_resolve_pixmap_ctable_handle(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
bits_ptr: u32,
) -> Option<u32> {
ppc_resolve_pixmap_ctable_handle_with_provenance(memory, gworlds, bits_ptr).handle
}
#[derive(Clone, Copy)]
struct PpcOptionalHandleResolution {
handle: Option<u32>,
known: bool,
}
fn ppc_resolve_pixmap_ctable_handle_with_provenance(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
bits_ptr: u32,
) -> PpcOptionalHandleResolution {
let tracked_pixmap = gworlds.iter().find_map(|record| {
if record.pixmap == bits_ptr {
return Some(record.pixmap);
}
if record.pixmap_handle == bits_ptr {
return memory.read_u32_be(bits_ptr);
}
if record.port == bits_ptr || record.port.checked_add(2) == Some(bits_ptr) {
let port_bits = record.port.checked_add(2)?;
return memory
.read_u32_be(port_bits)
.and_then(|pixmap_handle| memory.read_u32_be(pixmap_handle));
}
None
});
let pixmap = tracked_pixmap.or_else(|| {
let direct_is_pixmap = bits_ptr
.checked_add(4)
.and_then(|row_bytes| memory.read_u16_be(row_bytes))
.is_some_and(|row_bytes| row_bytes & 0x8000 != 0);
if direct_is_pixmap {
return Some(bits_ptr);
}
let indirect = memory.read_u32_be(bits_ptr)?;
indirect
.checked_add(4)
.and_then(|row_bytes| memory.read_u16_be(row_bytes))
.filter(|row_bytes| row_bytes & 0x8000 != 0)
.map(|_| indirect)
});
let Some(pixmap) = pixmap else {
return PpcOptionalHandleResolution {
handle: None,
known: false,
};
};
let raw_handle = pixmap
.checked_add(42)
.and_then(|pm_table| memory.read_u32_be(pm_table));
let Some(raw_handle) = raw_handle else {
return PpcOptionalHandleResolution {
handle: None,
known: false,
};
};
PpcOptionalHandleResolution {
handle: (raw_handle != 0).then_some(raw_handle),
known: true,
}
}
fn ppc_color_tables_share_index_space(
memory: &mut PpcSectionMem,
src_ctable_handle: Option<u32>,
dst_ctable_handle: Option<u32>,
) -> bool {
let identity = |memory: &mut PpcSectionMem, handle: Option<u32>| {
let table = handle
.and_then(|handle| memory.read_u32_be(handle))
.filter(|table| *table != 0)?;
let seed = memory.read_u32_be(table)?;
let flags = memory.read_u16_be(table.checked_add(4)?)?;
if seed == 0 || flags & 0xc000 != 0 {
return None;
}
let entry_count = usize::from(memory.read_u16_be(table.checked_add(6)?)?).checked_add(1)?;
if entry_count > 256 {
return None;
}
let mut colors = [None; 256];
for slot in 0..entry_count {
let entry = table.checked_add(8 + u32::try_from(slot).ok()?.checked_mul(8)?)?;
let index = usize::from(memory.read_u16_be(entry)?);
if index >= colors.len() || colors[index].is_some() {
return None;
}
colors[index] = Some([
memory.read_u16_be(entry.checked_add(2)?)?,
memory.read_u16_be(entry.checked_add(4)?)?,
memory.read_u16_be(entry.checked_add(6)?)?,
]);
}
Some((seed, colors))
};
let src_identity = identity(memory, src_ctable_handle);
let dst_identity = identity(memory, dst_ctable_handle);
matches!((src_identity, dst_identity), (Some(src), Some(dst)) if src == dst)
}
fn ppc_copy_bits_clut(
memory: &mut PpcSectionMem,
ctable_handle: u32,
color_manager_clut: &[[u16; 3]; 256],
) -> [[u16; 3]; 256] {
ppc_copy_bits_clut_with_provenance(memory, ctable_handle, color_manager_clut).0
}
fn ppc_copy_bits_clut_with_provenance(
memory: &mut PpcSectionMem,
ctable_handle: u32,
color_manager_clut: &[[u16; 3]; 256],
) -> ([[u16; 3]; 256], bool) {
if ctable_handle == 0 {
return (*color_manager_clut, true);
}
// Inside Macintosh Volume V (1986), p. V-143: SetEntries updates the
// current GDevice's ColorTable as well as its hardware lookup table.
// Read even the main device table from guest memory so CopyBits sees
// palette animation instead of the immutable startup palette.
match ppc_read_ctable_clut(memory, ctable_handle, color_manager_clut) {
Some(clut) => (clut, true),
None => (*color_manager_clut, false),
}
}
fn ppc_copy_bits_palette_index_map(
memory: &mut PpcSectionMem,
ctable_handle: u32,
current_gworld: u32,
current_gdevice: u32,
toolbox_startup: &PpcToolboxStartupState,
dst_clut: &[[u16; 3]; 256],
) -> Option<[u8; 256]> {
let ctable = memory.read_u32_be(ctable_handle).filter(|ptr| *ptr != 0)?;
let flags = memory.read_u16_be(ctable + 4)?;
// Inside Macintosh Volume VI (1991), pp. 20-16--20-17: bit 14
// links a source PixMap table to Palette Manager entries. The high bit
// instead identifies a GDevice table, whose ColorSpec.value fields are
// reserved and whose pixel values are implicit table positions.
if flags & 0xc000 != 0x4000 {
return None;
}
let entry_count = usize::from(memory.read_u16_be(ctable + 6)?)
.saturating_add(1)
.min(256);
let assigned_palette = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET))
.unwrap_or(0);
let palette_handle = if assigned_palette != 0 {
assigned_palette
} else {
toolbox_startup.application_palette
};
let palette = memory.read_u32_be(palette_handle).filter(|ptr| *ptr != 0);
let palette_count = palette
.and_then(|ptr| memory.read_u16_be(ptr))
.map(usize::from)
.unwrap_or(0);
let mut map = std::array::from_fn(|index| index as u8);
for (slot, mapped) in map.iter_mut().enumerate().take(entry_count) {
let spec = ctable + 8 + slot as u32 * 8;
let palette_entry = usize::from(memory.read_u16_be(spec)?);
let fallback = [
memory.read_u16_be(spec + 2)?,
memory.read_u16_be(spec + 4)?,
memory.read_u16_be(spec + 6)?,
];
let Some(palette_info) = palette
.filter(|_| palette_entry < palette_count)
.and_then(|ptr| ptr.checked_add(16 + palette_entry as u32 * 16))
else {
// Inside Macintosh Volume VI (1991), pp. 20-16--20-17: the
// ColorSpec RGB is the required fallback when no palette exists
// or the linked entry lies beyond that palette.
*mapped = pict::closest_clut_index(fallback[0], fallback[1], fallback[2], dst_clut);
continue;
};
if let Some(index) = ppc_palette_allocated_index(
toolbox_startup,
palette_handle,
current_gdevice,
palette_entry,
) {
*mapped = index;
continue;
}
let usage = memory.read_u16_be(palette_info + 6)?;
if usage & 0x0008 != 0 {
// Explicit entries are defined as the palette entry modulo the
// indexed device's table size.
*mapped = palette_entry as u8;
} else {
let color = ppc_read_rgb_color(memory, palette_info)?;
let rgb = [color.red, color.green, color.blue];
*mapped = if usage & 0x0004 != 0 {
// Animated colors use the device index reserved for the
// palette entry. Prefer the aligned allocation used by this
// HLE, then find the exact active-device entry; if the
// reservation is gone, Palette Manager semantics degrade to
// an ordinary courteous color match.
dst_clut
.get(palette_entry)
.filter(|candidate| **candidate == rgb)
.map(|_| palette_entry)
.or_else(|| dst_clut.iter().position(|candidate| *candidate == rgb))
.map(|index| index as u8)
.unwrap_or_else(|| {
pict::closest_clut_index(color.red, color.green, color.blue, dst_clut)
})
} else {
pict::closest_clut_index(color.red, color.green, color.blue, dst_clut)
};
}
}
Some(map)
}
fn ppc_copy_bits_linked_palette_clut(
memory: &mut PpcSectionMem,
ctable_handle: u32,
current_gworld: u32,
_current_gdevice: u32,
toolbox_startup: &PpcToolboxStartupState,
fallback_clut: &[[u16; 3]; 256],
) -> Option<[[u16; 3]; 256]> {
let ctable = memory.read_u32_be(ctable_handle).filter(|ptr| *ptr != 0)?;
(memory.read_u16_be(ctable + 4)? & 0xc000 == 0x4000).then_some(())?;
let entry_count = usize::from(memory.read_u16_be(ctable + 6)?)
.saturating_add(1)
.min(256);
let assigned_palette = memory
.read_u32_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET))
.unwrap_or(0);
let palette_handle = if assigned_palette != 0 {
assigned_palette
} else {
toolbox_startup.application_palette
};
let palette = memory.read_u32_be(palette_handle).filter(|ptr| *ptr != 0);
let palette_count = palette
.and_then(|ptr| memory.read_u16_be(ptr))
.map(usize::from)
.unwrap_or(0);
let mut clut = *fallback_clut;
for (slot, color) in clut.iter_mut().enumerate().take(entry_count) {
let spec = ctable + 8 + slot as u32 * 8;
let palette_entry = usize::from(memory.read_u16_be(spec)?);
let color_ptr = palette
.filter(|_| palette_entry < palette_count)
.and_then(|ptr| ptr.checked_add(16 + palette_entry as u32 * 16))
.unwrap_or(spec + 2);
let rgb = ppc_read_rgb_color(memory, color_ptr)?;
*color = [rgb.red, rgb.green, rgb.blue];
}
Some(clut)
}
fn ppc_record_copy_bits(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
commands: &mut Vec<u8>,
) -> bool {
let src_bits_ptr = cpu.gpr[3];
let Some(src_bits) = ppc_resolve_pixmap_bits(memory, gworlds, src_bits_ptr) else {
return false;
};
if src_bits.depth != 8 || cpu.gpr[8] != 0 || cpu.gpr[7] as u16 & 0x3f != 0 {
return false;
}
let Some(src_rect) = ppc_read_rect(memory, cpu.gpr[5]) else {
return false;
};
let Some(dst_rect) = ppc_read_rect(memory, cpu.gpr[6]) else {
return false;
};
let width = src_rect.3.saturating_sub(src_rect.1);
let height = src_rect.2.saturating_sub(src_rect.0);
if width <= 0 || height <= 0 || width > 0x3fff {
return false;
}
let Some(ctable_handle) = ppc_resolve_pixmap_ctable_handle(memory, gworlds, src_bits_ptr) else {
return false;
};
let Some(ctable) = memory.read_u32_be(ctable_handle).filter(|ptr| *ptr != 0) else {
return false;
};
let Some(ct_seed) = memory.read_u32_be(ctable) else {
return false;
};
let Some(ct_flags) = memory.read_u16_be(ctable + 4) else {
return false;
};
let Some(ct_size) = memory.read_u16_be(ctable + 6) else {
return false;
};
let entry_count = usize::from(ct_size).saturating_add(1).min(256);
// Assemble the complete opcode before appending it so a malformed source
// PixMap cannot leave a partial command in an otherwise valid picture.
let mut recording = Vec::new();
pict::recording_push_word(&mut recording, 0x0090); // BitsRect with indexed PixMap
pict::recording_push_word(&mut recording, 0x8000 | width as u16);
for value in [src_rect.0, src_rect.1, src_rect.2, src_rect.3] {
pict::recording_push_word(&mut recording, value as u16);
}
pict::recording_push_word(&mut recording, 0); // pmVersion
pict::recording_push_word(&mut recording, 1); // packType: unpacked
recording.extend_from_slice(&0u32.to_be_bytes()); // packSize
recording.extend_from_slice(&0x0048_0000u32.to_be_bytes()); // hRes
recording.extend_from_slice(&0x0048_0000u32.to_be_bytes()); // vRes
pict::recording_push_word(&mut recording, 0); // indexed pixelType
pict::recording_push_word(&mut recording, 8); // pixelSize
pict::recording_push_word(&mut recording, 1); // cmpCount
pict::recording_push_word(&mut recording, 8); // cmpSize
recording.extend_from_slice(&0u32.to_be_bytes()); // planeBytes
recording.extend_from_slice(&0u32.to_be_bytes()); // pmTable is not serialized
recording.extend_from_slice(&0u32.to_be_bytes()); // pmReserved
recording.extend_from_slice(&ct_seed.to_be_bytes());
pict::recording_push_word(&mut recording, ct_flags);
pict::recording_push_word(&mut recording, entry_count.saturating_sub(1) as u16);
for entry in 0..entry_count {
let spec = ctable + 8 + entry as u32 * 8;
let Some(bytes) = ppc_memory_read_bytes(memory, spec, 8) else {
return false;
};
recording.extend_from_slice(&bytes);
}
for rect in [src_rect, dst_rect] {
for value in [rect.0, rect.1, rect.2, rect.3] {
pict::recording_push_word(&mut recording, value as u16);
}
}
pict::recording_push_word(&mut recording, cpu.gpr[7] as u16);
for y in src_rect.0..src_rect.2 {
for x in src_rect.1..src_rect.3 {
let Some(pixel) = ppc_read_pixmap_raw_pixel(memory, src_bits, i32::from(x), i32::from(y))
else {
return false;
};
recording.push(pixel as u8);
}
}
if !recording.len().is_multiple_of(2) {
recording.push(0);
}
commands.extend(recording);
true
}
fn ppc_copy_bits(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
current_gdevice: u32,
toolbox_startup: &PpcToolboxStartupState,
color_manager_clut: &[[u16; 3]; 256],
fore_color: PpcRgbColor,
fore_index: Option<u8>,
back_color: PpcRgbColor,
back_index: Option<u8>,
op_color: PpcRgbColor,
) -> bool {
let src_bits_ptr = cpu.gpr[3];
let dst_bits_ptr = cpu.gpr[4];
let src_rect_ptr = cpu.gpr[5];
let dst_rect_ptr = cpu.gpr[6];
let transfer_mode = cpu.gpr[7] as u16;
let mask_rgn = cpu.gpr[8];
let mut reason = "ok";
let mut trace_details = None;
let copied = (|| {
let mode = transfer_mode & 0x3f;
if !matches!(mode, 0 | 32 | 36) {
reason = "unsupported-mode";
return None;
}
let Some(src_resolved) =
ppc_resolve_pixmap_bits_with_provenance(memory, gworlds, src_bits_ptr)
else {
reason = "src-bits";
return None;
};
let Some(dst_resolved) =
ppc_resolve_pixmap_bits_with_provenance(memory, gworlds, dst_bits_ptr)
else {
reason = "dst-bits";
return None;
};
let src_bits = src_resolved.bits;
let dst_bits = dst_resolved.bits;
let transparent = mode == 36;
let supported_source = matches!(src_bits.depth, 1 | 2 | 4 | 8 | 16);
let supported_destination = matches!(dst_bits.depth, 1 | 2 | 4 | 8 | 16);
let compatible_depths = if transparent || mode == 0 {
// Imaging With QuickDraw (1994), p. 3-117 and pp. 4-27--4-28:
// CopyBits converts source colors into the destination device's
// pixel format, and expands a BitMap through the foreground and
// background colors. Source and destination depths need not match.
supported_source && supported_destination
} else {
src_bits.depth == dst_bits.depth && supported_source
};
if !compatible_depths {
reason = "depth";
return None;
}
let src_ctable_resolution =
ppc_resolve_pixmap_ctable_handle_with_provenance(memory, gworlds, src_bits_ptr);
let dst_ctable_resolution =
ppc_resolve_pixmap_ctable_handle_with_provenance(memory, gworlds, dst_bits_ptr);
// Keep the legacy Option values below: unreadable lookup metadata has
// always fallen back to the Color Manager table. The additional
// provenance only prevents that fallback from selecting the new raw
// indexed reducer as if a readable nil pmTable had been observed.
let src_ctable = src_ctable_resolution.handle;
let dst_ctable = dst_ctable_resolution.handle;
let mut src_clut_resolution_known = false;
let src_clut = ppc_indexed_depth_entry_count(src_bits.depth).map(|_| {
let src_ctable = src_ctable.unwrap_or(0);
if let Some(clut) = ppc_copy_bits_linked_palette_clut(
memory,
src_ctable,
current_gworld,
current_gdevice,
toolbox_startup,
color_manager_clut,
) {
src_clut_resolution_known = src_ctable_resolution.known;
clut
} else {
let (clut, known) =
ppc_copy_bits_clut_with_provenance(memory, src_ctable, color_manager_clut);
src_clut_resolution_known = src_ctable_resolution.known && known;
clut
}
});
// Inside Macintosh Volume V (1986), p. V-69: CopyBits assumes that
// an indexed destination uses the current GDevice's color table,
// because that device's inverse table performs RGB-to-index mapping.
// A destination PixMap's own ColorTable is therefore not the target
// of the translation.
// Imaging With QuickDraw (1994), pp. 4-27--4-28: CopyBits maps
// colors into the current GDevice. The destination PixMap's table is
// not the inverse-mapping target, even when it differs from that
// device table.
let dst_device_ctable_resolution =
ppc_gdevice_ctable_handle_with_provenance(memory, current_gdevice);
let mut dst_clut_resolution_known = false;
let dst_clut = ppc_indexed_depth_entry_count(dst_bits.depth).map(|_| {
if let Some(handle) = dst_device_ctable_resolution.handle {
let (clut, known) =
ppc_copy_bits_clut_with_provenance(memory, handle, color_manager_clut);
dst_clut_resolution_known = dst_device_ctable_resolution.known && known;
clut
} else {
dst_clut_resolution_known = dst_device_ctable_resolution.known;
*color_manager_clut
}
});
// A shared nonzero ctSeed identifies a particular ColorTable instance.
// When two same-depth ordinary image tables also describe the same
// index-to-RGB space, their pixels already name the same colors and
// CopyBits preserves the raw indexes even if the handles differ.
// Imaging With QuickDraw (1994), pp. 4-56--4-57 and 4-97.
let same_indexed_ctable_identity = src_bits.depth == dst_bits.depth
&& ppc_indexed_depth_entry_count(src_bits.depth).is_some()
&& src_ctable_resolution.known
&& dst_ctable_resolution.known
&& ppc_color_tables_share_index_space(memory, src_ctable, dst_ctable);
let mut indexed_palette_identity_known = false;
let palette_map = if src_bits.depth == 8 && dst_bits.depth == 8 {
let src_ctable = src_ctable.unwrap_or(0);
let src_clut = src_clut.as_ref().unwrap();
let dst_clut = dst_clut.as_ref().unwrap();
let source_uses_device_indices = memory
.read_u32_be(src_ctable)
.and_then(|table| memory.read_u16_be(table + 4))
.is_some_and(|flags| flags & 0x8000 != 0);
let linked_palette_map = ppc_copy_bits_palette_index_map(
memory,
src_ctable,
current_gworld,
current_gdevice,
toolbox_startup,
dst_clut,
);
if let Some(linked_palette_map) = linked_palette_map {
Some(linked_palette_map)
} else if same_indexed_ctable_identity {
indexed_palette_identity_known =
src_clut_resolution_known && dst_clut_resolution_known;
None
} else {
// Inside Macintosh Volume V (1986), p. V-135: the high
// ctFlags bit distinguishes a GDevice table from a PixMap
// image table. Its pixels are already device indexes, so an
// indexed CopyBits preserves them.
if source_uses_device_indices || src_clut == dst_clut {
indexed_palette_identity_known =
src_clut_resolution_known && dst_clut_resolution_known;
None
} else {
Some(std::array::from_fn::<u8, 256, _>(|index| {
let [red, green, blue] = src_clut[index];
pict::closest_clut_index(red, green, blue, dst_clut)
}))
}
}
} else if src_bits.depth == dst_bits.depth && matches!(src_bits.depth, 1 | 2 | 4) {
let src_ctable = src_ctable.unwrap_or(0);
let src_clut = src_clut.as_ref().unwrap();
let dst_clut = dst_clut.as_ref().unwrap();
let source_uses_device_indices = memory
.read_u32_be(src_ctable)
.and_then(|table| memory.read_u16_be(table + 4))
.is_some_and(|flags| flags & 0x8000 != 0);
(!same_indexed_ctable_identity && !source_uses_device_indices && src_clut != dst_clut)
.then(|| {
let entry_count = ppc_indexed_depth_entry_count(src_bits.depth).unwrap_or(1);
std::array::from_fn::<u8, 256, _>(|index| {
let [red, green, blue] = src_clut[index];
// The inverse lookup is constrained to the active
// destination table entries representable at this
// packed depth. Looking up in an 8-bit table and then
// masking the result does not preserve the matched
// color. Imaging With QuickDraw (1994), pp. 4-27--4-28
// and 4-81--4-82.
ppc_rgb_color_to_index_in_clut(
PpcRgbColor { red, green, blue },
dst_clut,
entry_count,
)
})
})
} else {
None
};
let (src_top, src_left, src_bottom, src_right) = if src_rect_ptr != 0 {
ppc_read_rect(memory, src_rect_ptr).unwrap_or((
src_bits.top,
src_bits.left,
src_bits.bottom,
src_bits.right,
))
} else {
(src_bits.top, src_bits.left, src_bits.bottom, src_bits.right)
};
let (dst_top, dst_left, dst_bottom, dst_right) = if dst_rect_ptr != 0 {
ppc_read_rect(memory, dst_rect_ptr).unwrap_or((
dst_bits.top,
dst_bits.left,
dst_bits.bottom,
dst_bits.right,
))
} else {
(dst_bits.top, dst_bits.left, dst_bits.bottom, dst_bits.right)
};
trace_details = Some((
src_bits,
dst_bits,
(src_top, src_left, src_bottom, src_right),
(dst_top, dst_left, dst_bottom, dst_right),
));
let src_width = i64::from(src_right) - i64::from(src_left);
let src_height = i64::from(src_bottom) - i64::from(src_top);
let dst_width = i64::from(dst_right) - i64::from(dst_left);
let dst_height = i64::from(dst_bottom) - i64::from(dst_top);
if src_width <= 0 || src_height <= 0 || dst_width <= 0 || dst_height <= 0 {
reason = "empty-rect";
return None;
}
let copy_left = i32::from(dst_left).max(i32::from(dst_bits.left));
let copy_top = i32::from(dst_top).max(i32::from(dst_bits.top));
let copy_right = i32::from(dst_right).min(i32::from(dst_bits.right));
let copy_bottom = i32::from(dst_bottom).min(i32::from(dst_bits.bottom));
if copy_left >= copy_right || copy_top >= copy_bottom {
reason = "clipped-empty";
return None;
}
let mask_storage = if mask_rgn == 0 {
None
} else {
let Some(storage) = ppc_region_storage(memory, mask_rgn) else {
reason = "mask-rgn";
return None;
};
Some(storage)
};
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 3-112–3-116
// and 4-27: CopyBits copies bitmap or PixMap pixels between graphics
// ports and GWorlds, including indexed-color PixMaps. The import
// resolves records and masks; the shared operation owns pure
// byte-aligned or packed srcCopy format, mode, and geometry eligibility.
if mask_storage.is_none() {
use crate::copy_bits::{
BytePixmap, Indexed8ScalingSelection, RowCopy, RowCopyOutcome,
};
let indexed8_scaling = Indexed8ScalingSelection::from_adapter_facts(
mask_rgn == 0,
src_resolved.guest_bounds,
dst_resolved.authoritative_bounds,
indexed_palette_identity_known,
transfer_mode,
);
let outcome = RowCopy {
mode,
source: BytePixmap {
base: src_bits.base_addr,
row_bytes: src_bits.row_bytes,
depth: src_bits.depth,
bounds: [src_bits.top, src_bits.left, src_bits.bottom, src_bits.right]
.map(i32::from),
},
destination: BytePixmap {
base: dst_bits.base_addr,
row_bytes: dst_bits.row_bytes,
depth: dst_bits.depth,
bounds: [dst_bits.top, dst_bits.left, dst_bits.bottom, dst_bits.right]
.map(i32::from),
},
source_rect: [src_top, src_left, src_bottom, src_right].map(i32::from),
destination_rect: [dst_top, dst_left, dst_bottom, dst_right].map(i32::from),
clip: [copy_top, copy_left, copy_bottom, copy_right],
palette: palette_map.as_ref(),
}
.execute_with_indexed8_scaling(memory, indexed8_scaling);
match outcome {
RowCopyOutcome::Completed => return Some(()),
RowCopyOutcome::NoOp => {
reason = "row-copy-no-op";
return Some(());
}
RowCopyOutcome::Declined => {}
RowCopyOutcome::ReadOrGeometryFailure => {
reason = "row-copy-read-or-geometry";
return None;
}
RowCopyOutcome::WriteFailure { .. } => {
reason = "row-copy-write";
return None;
}
}
}
let transparent_back_pixel = match src_bits.depth {
1 => 0,
8 if back_index.is_some() => u32::from(back_index.unwrap()),
2 | 4 | 8 => {
let clut = src_clut.as_ref()?;
u32::from(ppc_rgb_color_to_index_in_clut(
back_color,
clut,
ppc_indexed_depth_entry_count(src_bits.depth)?,
))
}
16 => u32::from(ppc_rgb_color_to_rgb555(back_color)),
_ => return None,
};
let bitmap_fore_pixel = match dst_bits.depth {
1 | 2 | 4 | 8 if fore_index.is_some() => {
let pixel_mask = ((1u16 << dst_bits.depth) - 1) as u8;
u32::from(fore_index.unwrap() & pixel_mask)
}
1 | 2 | 4 | 8 => {
let clut = dst_clut.as_ref()?;
u32::from(ppc_rgb_color_to_index_in_clut(
fore_color,
clut,
ppc_indexed_depth_entry_count(dst_bits.depth)?,
))
}
16 => u32::from(ppc_rgb_color_to_rgb555(fore_color)),
_ => return None,
};
let bitmap_back_pixel = match dst_bits.depth {
1 | 2 | 4 | 8 if back_index.is_some() => {
let pixel_mask = ((1u16 << dst_bits.depth) - 1) as u8;
u32::from(back_index.unwrap() & pixel_mask)
}
1 | 2 | 4 | 8 => {
let clut = dst_clut.as_ref()?;
u32::from(ppc_rgb_color_to_index_in_clut(
back_color,
clut,
ppc_indexed_depth_entry_count(dst_bits.depth)?,
))
}
16 => u32::from(ppc_rgb_color_to_rgb555(back_color)),
_ => return None,
};
let mut writes = Vec::new();
let mut details = crate::memory::SavedPixels::<()>::default();
for dst_y in copy_top..copy_bottom {
let rel_y = i64::from(dst_y) - i64::from(dst_top);
let src_y = i64::from(src_top) + (rel_y * src_height) / dst_height;
let Ok(src_y) = i32::try_from(src_y) else {
continue;
};
for dst_x in copy_left..copy_right {
let rel_x = i64::from(dst_x) - i64::from(dst_left);
let src_x = i64::from(src_left) + (rel_x * src_width) / dst_width;
let Ok(src_x) = i32::try_from(src_x) else {
continue;
};
let Some(src_pixel) = ppc_read_pixmap_raw_pixel(memory, src_bits, src_x, src_y)
else {
continue;
};
if mask_storage.as_ref().is_some_and(|storage| {
!ppc_point_in_region_storage(storage, dst_y as i16, dst_x as i16)
}) {
continue;
}
if transparent && src_pixel == transparent_back_pixel {
continue;
}
let pixel = if mode == 32 {
let dst_pixel = ppc_read_pixmap_raw_pixel(memory, dst_bits, dst_x, dst_y)?;
let (source_rgb, destination_rgb) = match src_bits.depth {
1 | 2 | 4 | 8 => (
src_clut.as_ref()?[src_pixel as usize],
dst_clut.as_ref()?[dst_pixel as usize],
),
16 => (
ppc_rgb555_to_rgb16(src_pixel as u16),
ppc_rgb555_to_rgb16(dst_pixel as u16),
),
_ => return None,
};
let weights = [op_color.red, op_color.green, op_color.blue];
let blended: [u16; 3] = std::array::from_fn(|channel| {
let weight = u64::from(weights[channel]);
((u64::from(source_rgb[channel]) * weight
+ u64::from(destination_rgb[channel]) * (65_536 - weight))
>> 16) as u16
});
match dst_bits.depth {
depth @ (1 | 2 | 4 | 8) => u32::from(ppc_rgb_color_to_index_in_clut(
PpcRgbColor {
red: blended[0],
green: blended[1],
blue: blended[2],
},
dst_clut.as_ref()?,
ppc_indexed_depth_entry_count(depth)?,
)),
16 => u32::from(ppc_rgb_color_to_rgb555(PpcRgbColor {
red: blended[0],
green: blended[1],
blue: blended[2],
})),
_ => return None,
}
} else if transparent && src_bits.depth == 1 {
bitmap_fore_pixel
} else if src_bits.depth == 1 {
if src_pixel == 0 {
bitmap_back_pixel
} else {
bitmap_fore_pixel
}
} else if ppc_indexed_depth_entry_count(src_bits.depth).is_some()
&& src_bits.depth == dst_bits.depth
{
u32::from(
palette_map
.as_ref()
.map(|palette_map| palette_map[src_pixel as usize])
.unwrap_or(src_pixel as u8),
)
} else if ppc_indexed_depth_entry_count(src_bits.depth).is_some()
&& dst_bits.depth == 16
{
let [red, green, blue] = src_clut.as_ref()?[src_pixel as usize];
u32::from(ppc_rgb_color_to_rgb555(PpcRgbColor { red, green, blue }))
} else if src_bits.depth == 16
&& ppc_indexed_depth_entry_count(dst_bits.depth).is_some()
{
let [red, green, blue] = ppc_rgb555_to_rgb16(src_pixel as u16);
u32::from(ppc_rgb_color_to_index_in_clut(
PpcRgbColor { red, green, blue },
dst_clut.as_ref()?,
ppc_indexed_depth_entry_count(dst_bits.depth)?,
))
} else if ppc_indexed_depth_entry_count(src_bits.depth).is_some()
&& ppc_indexed_depth_entry_count(dst_bits.depth).is_some()
{
let [red, green, blue] = src_clut.as_ref()?[src_pixel as usize];
u32::from(ppc_rgb_color_to_index_in_clut(
PpcRgbColor { red, green, blue },
dst_clut.as_ref()?,
ppc_indexed_depth_entry_count(dst_bits.depth)?,
))
} else {
src_pixel
};
if matches!(mode, 0 | 36)
&& src_bits.depth == dst_bits.depth
&& matches!(src_bits.depth, 8 | 16)
&& src_pixel == pixel
{
let lanes = src_bits.depth / 8;
let address = src_bits.base_addr
+ (src_y - i32::from(src_bits.top)) as u32 * src_bits.row_bytes
+ (src_x - i32::from(src_bits.left)) as u32 * lanes;
memory.presentation().capture_detail(
&mut details,
writes.len() * lanes as usize,
address,
lanes as usize,
);
}
writes.push((dst_x, dst_y, pixel));
}
}
if writes.is_empty() {
if transparent {
return Some(());
}
reason = "no-pixels";
return None;
}
for (index, (x, y, pixel)) in writes.into_iter().enumerate() {
ppc_write_pixmap_raw_pixel(memory, dst_bits, x, y, pixel)?;
if matches!(dst_bits.depth, 8 | 16) {
let lanes = dst_bits.depth / 8;
let address = dst_bits.base_addr
+ (y - i32::from(dst_bits.top)) as u32 * dst_bits.row_bytes
+ (x - i32::from(dst_bits.left)) as u32 * lanes;
memory.presentation().restore_detail(
&details,
index * lanes as usize,
address,
lanes as usize,
);
}
}
Some(())
})();
let copied = copied.is_some();
if ppc_hle_trace_enabled() {
if let Some((src, dst, src_rect, dst_rect)) = trace_details {
eprintln!(
"[PPC-TRACE] CopyBits src=${:08X}[base=${:08X} rb={} depth={} bounds=({},{},{},{})] dst=${:08X}[base=${:08X} rb={} depth={} bounds=({},{},{},{})] srcRect=${:08X}({},{},{},{}) dstRect=${:08X}({},{},{},{}) mode=${:04X} maskRgn=${:08X} copied={} reason={}",
src_bits_ptr,
src.base_addr,
src.row_bytes,
src.depth,
src.top,
src.left,
src.bottom,
src.right,
dst_bits_ptr,
dst.base_addr,
dst.row_bytes,
dst.depth,
dst.top,
dst.left,
dst.bottom,
dst.right,
src_rect_ptr,
src_rect.0,
src_rect.1,
src_rect.2,
src_rect.3,
dst_rect_ptr,
dst_rect.0,
dst_rect.1,
dst_rect.2,
dst_rect.3,
transfer_mode,
mask_rgn,
copied,
reason,
);
} else {
eprintln!(
"[PPC-TRACE] CopyBits src=${:08X} dst=${:08X} srcRect=${:08X} dstRect=${:08X} mode=${:04X} maskRgn=${:08X} copied={} reason={}",
src_bits_ptr,
dst_bits_ptr,
src_rect_ptr,
dst_rect_ptr,
transfer_mode,
mask_rgn,
copied,
reason
);
}
}
copied
}
fn ppc_copy_mask(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
color_manager_clut: &[[u16; 3]; 256],
) -> bool {
let src_bits_ptr = cpu.gpr[3];
let mask_bits_ptr = cpu.gpr[4];
let dst_bits_ptr = cpu.gpr[5];
let src_rect_ptr = cpu.gpr[6];
let mask_rect_ptr = cpu.gpr[7];
let dst_rect_ptr = cpu.gpr[8];
let mut reason = "ok";
let mut trace_details = None;
let copied = (|| {
let Some(src_bits) = ppc_resolve_pixmap_bits(memory, gworlds, src_bits_ptr) else {
reason = "src-bits";
return None;
};
let Some(mask_bits) = ppc_resolve_pixmap_bits(memory, gworlds, mask_bits_ptr) else {
reason = "mask-bits";
return None;
};
let Some(dst_bits) = ppc_resolve_pixmap_bits(memory, gworlds, dst_bits_ptr) else {
reason = "dst-bits";
return None;
};
if src_bits.depth != dst_bits.depth || !matches!(src_bits.depth, 1 | 2 | 4 | 8 | 16) {
reason = "depth";
return None;
}
if mask_bits.depth != 1 {
reason = "mask-depth";
return None;
}
let src_rect = ppc_read_rect(memory, src_rect_ptr)?;
let mask_rect = ppc_read_rect(memory, mask_rect_ptr)?;
let dst_rect = ppc_read_rect(memory, dst_rect_ptr)?;
trace_details = Some((src_bits, mask_bits, dst_bits, src_rect, mask_rect, dst_rect));
let src_width = i64::from(src_rect.3) - i64::from(src_rect.1);
let src_height = i64::from(src_rect.2) - i64::from(src_rect.0);
let mask_width = i64::from(mask_rect.3) - i64::from(mask_rect.1);
let mask_height = i64::from(mask_rect.2) - i64::from(mask_rect.0);
let dst_width = i64::from(dst_rect.3) - i64::from(dst_rect.1);
let dst_height = i64::from(dst_rect.2) - i64::from(dst_rect.0);
if src_width <= 0
|| src_height <= 0
|| mask_width <= 0
|| mask_height <= 0
|| dst_width <= 0
|| dst_height <= 0
{
reason = "empty-rect";
return None;
}
let palette_map = if let Some(entry_count) = ppc_indexed_depth_entry_count(src_bits.depth) {
let src_ctable = ppc_resolve_pixmap_ctable_handle(memory, gworlds, src_bits_ptr);
let dst_ctable = ppc_resolve_pixmap_ctable_handle(memory, gworlds, dst_bits_ptr);
match (src_ctable, dst_ctable) {
(Some(src_ctable), Some(dst_ctable)) if src_ctable != dst_ctable => {
let src_clut = ppc_copy_bits_clut(memory, src_ctable, color_manager_clut);
let dst_clut = ppc_copy_bits_clut(memory, dst_ctable, color_manager_clut);
(src_clut[..entry_count] != dst_clut[..entry_count]).then(|| {
std::array::from_fn::<u8, 256, _>(|index| {
if index >= entry_count {
return 0;
}
let [red, green, blue] = src_clut[index];
ppc_rgb_color_to_index_in_clut(
PpcRgbColor { red, green, blue },
&dst_clut,
entry_count,
)
})
})
}
_ => None,
}
} else {
None
};
let copy_left = i32::from(dst_rect.1).max(i32::from(dst_bits.left));
let copy_top = i32::from(dst_rect.0).max(i32::from(dst_bits.top));
let copy_right = i32::from(dst_rect.3).min(i32::from(dst_bits.right));
let copy_bottom = i32::from(dst_rect.2).min(i32::from(dst_bits.bottom));
if copy_left >= copy_right || copy_top >= copy_bottom {
reason = "clipped-empty";
return None;
}
// Imaging With QuickDraw (1994), pp. 3-119--3-120: CopyMask scales
// srcRect and maskRect to dstRect, transferring a source pixel only
// where the corresponding one-bit mask pixel is set (black).
let mut writes = Vec::new();
for dst_y in copy_top..copy_bottom {
let rel_y = i64::from(dst_y) - i64::from(dst_rect.0);
let src_y = i64::from(src_rect.0) + rel_y * src_height / dst_height;
let mask_y = i64::from(mask_rect.0) + rel_y * mask_height / dst_height;
let (Ok(src_y), Ok(mask_y)) = (i32::try_from(src_y), i32::try_from(mask_y)) else {
continue;
};
for dst_x in copy_left..copy_right {
let rel_x = i64::from(dst_x) - i64::from(dst_rect.1);
let src_x = i64::from(src_rect.1) + rel_x * src_width / dst_width;
let mask_x = i64::from(mask_rect.1) + rel_x * mask_width / dst_width;
let (Ok(src_x), Ok(mask_x)) = (i32::try_from(src_x), i32::try_from(mask_x)) else {
continue;
};
if ppc_read_pixmap_raw_pixel(memory, mask_bits, mask_x, mask_y) != Some(1) {
continue;
}
let Some(mut pixel) = ppc_read_pixmap_raw_pixel(memory, src_bits, src_x, src_y)
else {
continue;
};
if let Some(palette_map) = palette_map.as_ref() {
pixel = u32::from(palette_map[pixel as usize]);
}
writes.push((dst_x, dst_y, pixel));
}
}
if writes.is_empty() {
reason = "no-pixels";
return None;
}
for (x, y, pixel) in writes {
ppc_write_pixmap_raw_pixel(memory, dst_bits, x, y, pixel)?;
}
Some(())
})();
let copied = copied.is_some();
if ppc_hle_trace_enabled() {
if let Some((src, mask, dst, src_rect, mask_rect, dst_rect)) = trace_details {
eprintln!(
"[PPC-TRACE] CopyMask src=${src_bits_ptr:08X}[rb={} depth={} bounds=({},{},{},{})] mask=${mask_bits_ptr:08X}[rb={} depth={} bounds=({},{},{},{})] dst=${dst_bits_ptr:08X}[rb={} depth={} bounds=({},{},{},{})] srcRect={src_rect:?} maskRect={mask_rect:?} dstRect={dst_rect:?} copied={copied} reason={reason}",
src.row_bytes,
src.depth,
src.top,
src.left,
src.bottom,
src.right,
mask.row_bytes,
mask.depth,
mask.top,
mask.left,
mask.bottom,
mask.right,
dst.row_bytes,
dst.depth,
dst.top,
dst.left,
dst.bottom,
dst.right,
);
} else {
eprintln!(
"[PPC-TRACE] CopyMask src=${src_bits_ptr:08X} mask=${mask_bits_ptr:08X} dst=${dst_bits_ptr:08X} copied={copied} reason={reason}"
);
}
}
copied
}
fn ppc_copy_deep_mask(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
color_manager_clut: &[[u16; 3]; 256],
) -> bool {
let src_bits_ptr = cpu.gpr[3];
let mask_bits_ptr = cpu.gpr[4];
let dst_bits_ptr = cpu.gpr[5];
let src_rect_ptr = cpu.gpr[6];
let mask_rect_ptr = cpu.gpr[7];
let dst_rect_ptr = cpu.gpr[8];
let mode = cpu.gpr[9] as u16 & 0x3f;
let mask_rgn = cpu.gpr[10];
let mut reason = "ok";
let mut trace_details = None;
let copied = (|| {
let Some(src_bits) = ppc_resolve_pixmap_bits(memory, gworlds, src_bits_ptr) else {
reason = "src-bits";
return None;
};
let Some(mask_bits) = ppc_resolve_pixmap_bits(memory, gworlds, mask_bits_ptr) else {
reason = "mask-bits";
return None;
};
let Some(dst_bits) = ppc_resolve_pixmap_bits(memory, gworlds, dst_bits_ptr) else {
reason = "dst-bits";
return None;
};
if !matches!(src_bits.depth, 1 | 2 | 4 | 8 | 16 | 32)
|| !matches!(dst_bits.depth, 1 | 2 | 4 | 8 | 16 | 32)
|| !matches!(mask_bits.depth, 1 | 2 | 4 | 8 | 16 | 32)
{
reason = "depth";
return None;
}
let src_rect = ppc_read_rect(memory, src_rect_ptr)?;
let mask_rect = ppc_read_rect(memory, mask_rect_ptr)?;
let dst_rect = ppc_read_rect(memory, dst_rect_ptr)?;
trace_details = Some((src_bits, mask_bits, dst_bits, src_rect, mask_rect, dst_rect));
let src_width = i64::from(src_rect.3) - i64::from(src_rect.1);
let src_height = i64::from(src_rect.2) - i64::from(src_rect.0);
let mask_width = i64::from(mask_rect.3) - i64::from(mask_rect.1);
let mask_height = i64::from(mask_rect.2) - i64::from(mask_rect.0);
let dst_width = i64::from(dst_rect.3) - i64::from(dst_rect.1);
let dst_height = i64::from(dst_rect.2) - i64::from(dst_rect.0);
if src_width <= 0
|| src_height <= 0
|| mask_width <= 0
|| mask_height <= 0
|| dst_width <= 0
|| dst_height <= 0
{
reason = "empty-rect";
return None;
}
let mask_storage = if mask_rgn == 0 {
None
} else {
let Some(storage) = ppc_region_storage(memory, mask_rgn) else {
reason = "mask-rgn";
return None;
};
Some(storage)
};
let src_clut = ppc_indexed_depth_entry_count(src_bits.depth).map(|_| {
ppc_resolve_pixmap_ctable_handle(memory, gworlds, src_bits_ptr)
.map(|handle| ppc_copy_bits_clut(memory, handle, color_manager_clut))
.unwrap_or(*color_manager_clut)
});
let dst_clut = ppc_indexed_depth_entry_count(dst_bits.depth).map(|_| {
ppc_resolve_pixmap_ctable_handle(memory, gworlds, dst_bits_ptr)
.map(|handle| ppc_copy_bits_clut(memory, handle, color_manager_clut))
.unwrap_or(*color_manager_clut)
});
let mask_clut = ppc_indexed_depth_entry_count(mask_bits.depth).map(|_| {
ppc_resolve_pixmap_ctable_handle(memory, gworlds, mask_bits_ptr)
.map(|handle| ppc_copy_bits_clut(memory, handle, color_manager_clut))
.unwrap_or(*color_manager_clut)
});
let copy_left = i32::from(dst_rect.1).max(i32::from(dst_bits.left));
let copy_top = i32::from(dst_rect.0).max(i32::from(dst_bits.top));
let copy_right = i32::from(dst_rect.3).min(i32::from(dst_bits.right));
let copy_bottom = i32::from(dst_rect.2).min(i32::from(dst_bits.bottom));
if copy_left >= copy_right || copy_top >= copy_bottom {
reason = "clipped-empty";
return None;
}
// Imaging With QuickDraw (1994), pp. 3-120--3-122: CopyDeepMask
// scales the source and deep mask into dstRect, then clips the
// transfer to maskRgn. For a deep mask, black selects the source,
// white preserves the destination, and intermediate RGB components
// weight the source and destination independently.
let mut writes = Vec::new();
for dst_y in copy_top..copy_bottom {
let rel_y = i64::from(dst_y) - i64::from(dst_rect.0);
let src_y = i64::from(src_rect.0) + rel_y * src_height / dst_height;
let mask_y = i64::from(mask_rect.0) + rel_y * mask_height / dst_height;
let (Ok(src_y), Ok(mask_y)) = (i32::try_from(src_y), i32::try_from(mask_y)) else {
continue;
};
for dst_x in copy_left..copy_right {
if mask_storage.as_ref().is_some_and(|storage| {
!ppc_point_in_region_storage(storage, dst_y as i16, dst_x as i16)
}) {
continue;
}
let rel_x = i64::from(dst_x) - i64::from(dst_rect.1);
let src_x = i64::from(src_rect.1) + rel_x * src_width / dst_width;
let mask_x = i64::from(mask_rect.1) + rel_x * mask_width / dst_width;
let (Ok(src_x), Ok(mask_x)) = (i32::try_from(src_x), i32::try_from(mask_x)) else {
continue;
};
let Some(src_pixel) = ppc_read_pixmap_raw_pixel(memory, src_bits, src_x, src_y)
else {
continue;
};
let Some(source_rgb) =
ppc_pixmap_pixel_rgb(src_bits, src_pixel, src_clut.as_ref())
else {
continue;
};
let Some(destination_pixel) =
ppc_read_pixmap_raw_pixel(memory, dst_bits, dst_x, dst_y)
else {
continue;
};
let Some(destination_rgb) = ppc_pixmap_pixel_rgb(
dst_bits,
destination_pixel,
dst_clut.as_ref(),
) else {
continue;
};
let Some(mask_pixel) = ppc_read_pixmap_raw_pixel(memory, mask_bits, mask_x, mask_y)
else {
continue;
};
if mask_bits.depth == 1 {
// A one-bit mask uses the historical BitMap convention:
// a set (black) bit copies the source and a clear (white)
// bit leaves the destination unchanged.
if mask_pixel == 0 {
continue;
}
let source_for_destination = ppc_rgb_to_pixmap_pixel(
dst_bits,
source_rgb,
dst_clut.as_ref(),
)?;
let pixel = if mode <= 7 {
ppc_deep_mask_boolean_pixel(
source_for_destination,
destination_pixel,
dst_bits.depth,
mode,
)
} else {
source_for_destination
};
writes.push((dst_x, dst_y, pixel));
continue;
}
let Some(mask_rgb) =
ppc_pixmap_pixel_rgb(mask_bits, mask_pixel, mask_clut.as_ref())
else {
continue;
};
let source_for_blend = if mode <= 7 && mode != 0 {
let source_for_destination = ppc_rgb_to_pixmap_pixel(
dst_bits,
source_rgb,
dst_clut.as_ref(),
)?;
let mode_pixel = ppc_deep_mask_boolean_pixel(
source_for_destination,
destination_pixel,
dst_bits.depth,
mode,
);
ppc_pixmap_pixel_rgb(dst_bits, mode_pixel, dst_clut.as_ref())?
} else {
source_rgb
};
let blended_rgb = ppc_blend_deep_mask_rgb(
source_for_blend,
destination_rgb,
mask_rgb,
);
let pixel = ppc_rgb_to_pixmap_pixel(dst_bits, blended_rgb, dst_clut.as_ref())?;
writes.push((dst_x, dst_y, pixel));
}
}
if writes.is_empty() {
reason = "no-pixels";
return None;
}
for (x, y, pixel) in writes {
ppc_write_pixmap_raw_pixel(memory, dst_bits, x, y, pixel)?;
}
Some(())
})();
let copied = copied.is_some();
if ppc_hle_trace_enabled() {
if let Some((src, mask, dst, src_rect, mask_rect, dst_rect)) = trace_details {
eprintln!(
"[PPC-TRACE] CopyDeepMask src=${src_bits_ptr:08X}[rb={} depth={} bounds=({},{},{},{})] mask=${mask_bits_ptr:08X}[rb={} depth={} bounds=({},{},{},{})] dst=${dst_bits_ptr:08X}[rb={} depth={} bounds=({},{},{},{})] srcRect={src_rect:?} maskRect={mask_rect:?} dstRect={dst_rect:?} mode={mode} maskRgn=${mask_rgn:08X} copied={copied} reason={reason}",
src.row_bytes,
src.depth,
src.top,
src.left,
src.bottom,
src.right,
mask.row_bytes,
mask.depth,
mask.top,
mask.left,
mask.bottom,
mask.right,
dst.row_bytes,
dst.depth,
dst.top,
dst.left,
dst.bottom,
dst.right,
);
} else {
eprintln!(
"[PPC-TRACE] CopyDeepMask src=${src_bits_ptr:08X} mask=${mask_bits_ptr:08X} dst=${dst_bits_ptr:08X} mode={mode} maskRgn=${mask_rgn:08X} copied={copied} reason={reason}"
);
}
}
copied
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_write_pixmap(
memory: &mut PpcSectionMem,
pixmap: u32,
base_addr: u32,
row_bytes: u32,
top: i16,
left: i16,
bottom: i16,
right: i16,
depth: u32,
) -> Option<()> {
memory.write_u32_be(pixmap, base_addr)?;
memory.write_u16_be(pixmap + 4, (row_bytes as u16) | 0x8000)?;
ppc_write_rect(memory, pixmap + 6, top, left, bottom, right)?;
memory.write_u16_be(pixmap + 14, 0)?;
memory.write_u16_be(pixmap + 16, 0)?;
memory.write_u32_be(pixmap + 18, 0)?;
memory.write_u32_be(pixmap + 22, 0x0048_0000)?;
memory.write_u32_be(pixmap + 26, 0x0048_0000)?;
let (pixel_type, component_count, component_size) = match depth {
16 => (16, 3, 5),
32 => (16, 3, 8),
_ => (0, 1, depth),
};
memory.write_u16_be(pixmap + 30, pixel_type)?;
memory.write_u16_be(pixmap + 32, depth as u16)?;
memory.write_u16_be(pixmap + 34, component_count)?;
memory.write_u16_be(pixmap + 36, component_size as u16)?;
memory.write_u32_be(pixmap + 38, 0)?;
memory.write_u32_be(pixmap + 42, 0)?;
memory.write_u32_be(pixmap + 46, 0)?;
Some(())
}
pub(super) fn ppc_write_gworld_port(
memory: &mut PpcSectionMem,
port: u32,
pixmap_handle: u32,
top: i16,
left: i16,
bottom: i16,
right: i16,
) -> Option<()> {
memory.write_u16_be(port, 0)?;
memory.write_u32_be(port + 2, pixmap_handle)?;
memory.write_u16_be(port + 6, 0xc000)?;
ppc_write_rect(memory, port + 16, top, left, bottom, right)?;
ppc_write_rgb_color(
memory,
port + PPC_CGRAF_PORT_RGB_FG_COLOR_OFFSET,
PPC_RGB_BLACK,
)?;
ppc_write_rgb_color(
memory,
port + PPC_CGRAF_PORT_RGB_BK_COLOR_OFFSET,
PPC_RGB_WHITE,
)?;
memory.write_u16_be(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET, 1)?;
memory.write_u16_be(port + PPC_CGRAF_PORT_PN_SIZE_OFFSET + 2, 1)?;
ppc_write_rgb_color(
memory,
port + PPC_CGRAF_PORT_RGB_FG_COLOR_OFFSET,
PPC_RGB_BLACK,
)?;
ppc_write_rgb_color(
memory,
port + PPC_CGRAF_PORT_RGB_BK_COLOR_OFFSET,
PPC_RGB_WHITE,
)?;
memory.write_u16_be(
port + PPC_CGRAF_PORT_PN_MODE_OFFSET,
PPC_QD_PEN_MODE_PAT_COPY as u16,
)?;
memory.write_u16_be(
port + PPC_CGRAF_PORT_TX_FONT_OFFSET,
PPC_QD_TEXT_FONT_DEFAULT as u16,
)?;
memory.write_u16_be(port + PPC_CGRAF_PORT_TX_FACE_OFFSET, 0)?;
memory.write_u16_be(
port + PPC_CGRAF_PORT_TX_MODE_OFFSET,
PPC_QD_TEXT_MODE_SRC_OR as u16,
)?;
memory.write_u16_be(
port + PPC_CGRAF_PORT_TX_SIZE_OFFSET,
PPC_QD_TEXT_SIZE_SYSTEM as u16,
)?;
Some(())
}
fn ppc_write_gdevice(
memory: &mut PpcSectionMem,
gdevice: u32,
pixmap_handle: u32,
top: i16,
left: i16,
bottom: i16,
right: i16,
) -> Option<()> {
let depth = memory
.read_u32_be(pixmap_handle)
.filter(|pixmap| *pixmap != 0)
.and_then(|pixmap| memory.read_u16_be(pixmap + 32))
.map(u32::from)
.unwrap_or(PPC_MAIN_PIXEL_DEPTH);
let gd_type = if depth <= 8 { 0 } else { 2 };
let depth_mode = crate::display::classic_depth_mode(u16::try_from(depth).ok()?)?;
memory.write_u16_be(gdevice, 0)?;
memory.write_u16_be(gdevice + 2, 0)?;
memory.write_u16_be(gdevice + 4, gd_type)?;
memory.write_u16_be(gdevice + 10, 4)?;
memory.write_u16_be(gdevice + 20, PPC_MAIN_GDEVICE_FLAGS)?;
memory.write_u32_be(gdevice + 22, pixmap_handle)?;
ppc_write_rect(memory, gdevice + 34, top, left, bottom, right)?;
memory.write_u32_be(gdevice + 42, u32::from(depth_mode))?;
Some(())
}
fn ppc_test_device_attribute(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> u32 {
let gdevice_handle = cpu.gpr[3];
let attribute = cpu.gpr[4] & 0xffff;
let Some(bit) = 1u16.checked_shl(attribute) else {
return 0;
};
let Some(gdevice) = memory.read_u32_be(gdevice_handle) else {
return 0;
};
if gdevice == 0 {
return 0;
}
let flags = memory.read_u16_be(gdevice + 20).unwrap_or(0);
if flags & bit != 0 {
0xffff
} else {
0
}
}
fn ppc_set_device_attribute(cpu: &PpcCpu, memory: &mut PpcSectionMem) {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 5-22--5-23:
// SetDeviceAttribute changes the requested gdFlags bit to the supplied
// Boolean value on the GDevice record referenced by the handle.
let gdevice_handle = cpu.gpr[3];
let attribute = cpu.gpr[4] & 0xffff;
let Some(bit) = 1u16.checked_shl(attribute) else {
return;
};
let Some(gdevice) = memory
.read_u32_be(gdevice_handle)
.filter(|gdevice| *gdevice != 0)
else {
return;
};
let Some(flags) = memory.read_u16_be(gdevice + 20) else {
return;
};
let flags = if cpu.gpr[5] & 0xff != 0 {
flags | bit
} else {
flags & !bit
};
let _ = memory.write_u16_be(gdevice + 20, flags);
}
pub(super) fn ppc_main_gdevice_record_for_depth(
memory: &mut PpcSectionMem,
requested_gdevice: u32,
) -> Option<u32> {
// Classic applications commonly use NIL to mean the current/main screen.
// Every non-NIL handle must be the actual single display handle; never
// fall back to the main record after a failed guest dereference.
let gdevice_handle = if requested_gdevice == 0 {
PPC_MAIN_GDEVICE
} else {
requested_gdevice
};
if gdevice_handle != PPC_MAIN_GDEVICE {
return None;
}
(memory.read_u32_be(gdevice_handle) == Some(PPC_MAIN_GDEVICE_RECORD))
.then_some(PPC_MAIN_GDEVICE_RECORD)
}
fn ppc_supported_depth_mode(
depth_or_mode: u32,
which_flags: u32,
flags: u32,
current_flags: u16,
) -> Option<(u32, bool)> {
let depth = u32::from(crate::display::classic_pixel_size(
(depth_or_mode & 0xffff) as u16,
)?);
if !matches!(depth, 1 | 2 | 4 | 8 | 16) {
return None;
}
// Imaging With QuickDraw (1994), pp. 5-33--5-35: bit gdDevType in
// whichFlags selects the black-and-white/grayscale or color personality.
// Indexed hardware exposes grayscale at 1/2/4/8 bits and color at 2/4/8
// bits; the modeled 16-bit direct mode is color-only. With no gdDevType
// constraint, preserve the current indexed personality and use the only
// coherent personality at the two endpoint depths.
let mode_is_color = if which_flags & 1 != 0 {
flags & 1 != 0
} else {
match depth {
1 => false,
16 => true,
_ => current_flags & 1 != 0,
}
};
if (depth == 1 && mode_is_color) || (depth == 16 && !mode_is_color) {
return None;
}
let fixed_mask = which_flags as u16 & !1;
if current_flags & fixed_mask != flags as u16 & fixed_mask {
return None;
}
Some((depth, mode_is_color))
}
fn ppc_has_depth(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> u32 {
let Some(gdevice) = ppc_main_gdevice_record_for_depth(memory, cpu.gpr[3]) else {
return 0;
};
let Some(current_flags) = memory.read_u16_be(gdevice + 20) else {
return 0;
};
ppc_supported_depth_mode(cpu.gpr[4], cpu.gpr[5], cpu.gpr[6], current_flags)
.and_then(|(depth, _)| {
crate::display::classic_depth_mode(u16::try_from(depth).ok()?).map(u32::from)
})
.unwrap_or(0)
}
fn ppc_standard_screen_clut(depth: u32, is_color: bool) -> Option<([[u16; 3]; 256], usize)> {
let (mut clut, entry_count) = TrapDispatcher::standard_mac_indexed_clut(depth as u16)?;
if !is_color {
let last = u32::try_from(entry_count.checked_sub(1)?).ok()?;
for (index, color) in clut.iter_mut().take(entry_count).enumerate() {
let index = u32::try_from(index).ok()?;
let component = ((last - index) * u32::from(u16::MAX) / last) as u16;
*color = [component; 3];
}
} else if depth == 2 {
// Inside Macintosh: Volume VI (1991), pp. 17-17--17-18: a color
// 2-bit screen uses the enhanced standard table, whose spare entry
// carries the current highlight color. PPC currently exposes the
// System 7 default highlight green used by the shared 68k Toolbox.
(clut, _) = TrapDispatcher::standard_mac_enhanced_clut(2, DEFAULT_QUICKDRAW_HILITE_COLOR)?;
}
Some((clut, entry_count))
}
fn ppc_update_pixmap_depth(
memory: &mut PpcSectionMem,
pixmap: u32,
row_bytes: u32,
depth: u32,
indexed_ctable: u32,
) -> Option<()> {
let (pixel_type, component_count, component_size, color_table) = match depth {
1 | 2 | 4 | 8 => (0, 1, depth as u16, indexed_ctable),
16 => (16, 3, 5, 0),
_ => return None,
};
memory.write_u16_be(pixmap + 4, (row_bytes as u16) | 0x8000)?;
memory.write_u16_be(pixmap + 30, pixel_type)?;
memory.write_u16_be(pixmap + 32, depth as u16)?;
memory.write_u16_be(pixmap + 34, component_count)?;
memory.write_u16_be(pixmap + 36, component_size)?;
memory.write_u32_be(pixmap + 42, color_table)?;
Some(())
}
fn ppc_main_color_table_is_valid(memory: &mut PpcSectionMem) -> bool {
let Some(table) = memory
.read_u32_be(PPC_MAIN_CTABLE_HANDLE)
.filter(|table| *table != 0)
else {
return false;
};
ppc_memory_can_write_bytes(memory, table, PPC_MAIN_CTABLE_SIZE)
}
fn ppc_install_standard_indexed_ctable(
memory: &mut PpcSectionMem,
ctable_handle: u32,
seed: u32,
clut: &[[u16; 3]; 256],
entry_count: usize,
) -> Option<()> {
let table = memory
.read_u32_be(ctable_handle)
.filter(|table| *table != 0)?;
let byte_len = 8u32.checked_add(u32::try_from(entry_count).ok()?.checked_mul(8)?)?;
if !ppc_memory_can_write_bytes(memory, table, byte_len) {
return None;
}
let flags = memory.read_u16_be(table + 4)?;
memory.write_u32_be(table, seed)?;
memory.write_u16_be(
table + 4,
if ctable_handle == PPC_MAIN_CTABLE_HANDLE {
flags | 0x8000
} else {
flags
},
)?;
memory.write_u16_be(table + 6, u16::try_from(entry_count.checked_sub(1)?).ok()?)?;
for (index, [red, green, blue]) in clut.iter().copied().take(entry_count).enumerate() {
let entry = table.checked_add(8 + u32::try_from(index).ok()?.checked_mul(8)?)?;
memory.write_u16_be(entry, index as u16)?;
memory.write_u16_be(entry + 2, red)?;
memory.write_u16_be(entry + 4, green)?;
memory.write_u16_be(entry + 6, blue)?;
}
Some(())
}
fn ppc_preflight_ctable_growth(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
ctable_handles: &[u32],
required_size: u32,
heap_cursor: u32,
heap_limit: u32,
) -> Result<(), i16> {
let mut simulated_handles = handles.to_vec();
let mut simulated_cursor = heap_cursor;
for ctable_handle in ctable_handles {
if *ctable_handle == PPC_MAIN_CTABLE_HANDLE {
let table = memory
.read_u32_be(*ctable_handle)
.filter(|table| *table != 0)
.ok_or(PPC_PARAM_ERR)?;
if !ppc_memory_can_write_bytes(memory, table, required_size) {
return Err(PPC_PARAM_ERR);
}
continue;
}
let table = memory
.read_u32_be(*ctable_handle)
.filter(|table| *table != 0)
.ok_or(PPC_PARAM_ERR)?;
let tracked = simulated_handles
.iter_mut()
.find(|record| record.handle == *ctable_handle);
let Some(record) = tracked else {
// A mapped address is not evidence that an untracked ColorTable
// owns the following bytes: the synthetic heap is one contiguous
// region and another object can begin immediately after ctTable.
// Without a Memory Manager record we can only use the logical
// size declared by ctSize, and cannot relocate the caller's
// private Handle on its behalf. Imaging With QuickDraw (1994),
// pp. 4-56--4-57.
let last_index = memory.read_u16_be(table + 6).ok_or(PPC_PARAM_ERR)?;
if (last_index as i16) < 0 || last_index >= 256 {
return Err(PPC_PARAM_ERR);
}
let logical_size = u32::from(last_index)
.checked_add(1)
.and_then(|entries| entries.checked_mul(8))
.and_then(|entries| entries.checked_add(8))
.ok_or(PPC_PARAM_ERR)?;
if logical_size < required_size
|| !ppc_memory_can_write_bytes(memory, table, required_size)
{
return Err(PPC_PARAM_ERR);
}
continue;
};
if record.ptr != table {
return Err(PPC_PARAM_ERR);
}
if record.capacity >= required_size {
continue;
}
let old_aligned = ppc_allocation_size(record.size).ok_or(PPC_PARAM_ERR)?;
let new_aligned = ppc_allocation_size(required_size).ok_or(PPC_MEM_FULL_ERR)?;
let old_end = record
.ptr
.checked_add(old_aligned)
.ok_or(PPC_MEM_FULL_ERR)?;
let in_place_end = (old_end == simulated_cursor)
.then(|| {
ppc_heap_allocation_bounds(memory, record.ptr, heap_limit, new_aligned)
.filter(|(new_ptr, _)| *new_ptr == record.ptr)
.map(|(_, new_end)| new_end)
})
.flatten();
if let Some(new_end) = in_place_end {
simulated_cursor = new_end;
} else {
let (new_ptr, new_end) =
ppc_heap_allocation_bounds(memory, simulated_cursor, heap_limit, new_aligned)
.ok_or(PPC_MEM_FULL_ERR)?;
record.ptr = new_ptr;
simulated_cursor = new_end;
}
record.size = required_size;
record.capacity = required_size;
}
Ok(())
}
fn ppc_grow_ctables(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
ctable_handles: &[u32],
required_size: u32,
) -> Result<(), i16> {
for ctable_handle in ctable_handles {
if *ctable_handle == PPC_MAIN_CTABLE_HANDLE {
continue;
}
let Some(record) = handles
.iter()
.find(|record| record.handle == *ctable_handle)
.copied()
else {
continue;
};
if record.capacity >= required_size {
continue;
}
let result = ppc_allocator_view_resize_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
*ctable_handle,
required_size,
);
if result != PPC_NO_ERR {
return Err(result);
}
}
Ok(())
}
pub(super) fn ppc_set_depth(
cpu: &PpcCpu,
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
gworlds: &mut [PpcGWorldRecord],
toolbox_startup: &mut PpcToolboxStartupState,
screen_clut: &mut [[u16; 3]; 256],
color_manager_clut: &mut [[u16; 3]; 256],
) -> i16 {
let Some(gdevice) = ppc_main_gdevice_record_for_depth(memory, cpu.gpr[3]) else {
return PPC_PARAM_ERR;
};
let Some(current_gd_flags) = memory.read_u16_be(gdevice + 20) else {
return PPC_PARAM_ERR;
};
let Some((depth, target_is_color)) =
ppc_supported_depth_mode(cpu.gpr[4], cpu.gpr[5], cpu.gpr[6], current_gd_flags)
else {
return PPC_PARAM_ERR;
};
let Some(main_record) = gworlds
.iter()
.find(|record| record.port == PPC_MAIN_GWORLD && record.gdevice == PPC_MAIN_GDEVICE)
.copied()
else {
return PPC_PARAM_ERR;
};
let Some(row_bytes) = ppc_row_bytes(main_record.width, depth).filter(|row| *row <= 0x3fff)
else {
return PPC_PARAM_ERR;
};
let Some(clear_len) = row_bytes
.checked_mul(main_record.height)
.and_then(|len| usize::try_from(len).ok())
else {
return PPC_PARAM_ERR;
};
let Some(clear_len_u32) = u32::try_from(clear_len).ok() else {
return PPC_PARAM_ERR;
};
// Discover screen-backed color ports through their live portPixMap
// handles. A GWorld that merely uses the main GDevice but owns separate
// pixel storage remains an offscreen world and must retain its format.
let mut screen_records = Vec::new();
let mut screen_pixmaps = Vec::new();
for (index, record) in gworlds.iter().enumerate() {
let Some(port_version_addr) = record.port.checked_add(6) else {
return PPC_PARAM_ERR;
};
let Some(port_version) = memory.read_u16_be(port_version_addr) else {
return PPC_PARAM_ERR;
};
if port_version & 0xc000 != 0xc000 {
continue;
}
let Some(port_pixmap_addr) = record.port.checked_add(2) else {
return PPC_PARAM_ERR;
};
let Some(pixmap_handle) = memory
.read_u32_be(port_pixmap_addr)
.filter(|handle| *handle != 0)
else {
return PPC_PARAM_ERR;
};
let Some(pixmap) = memory
.read_u32_be(pixmap_handle)
.filter(|pixmap| *pixmap != 0)
else {
return PPC_PARAM_ERR;
};
let Some(base_addr) = memory.read_u32_be(pixmap) else {
return PPC_PARAM_ERR;
};
if base_addr != PPC_MAIN_SCREEN_BASE {
continue;
}
if pixmap.checked_add(PPC_PIXMAP_SIZE - 1).is_none() {
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, pixmap + 4, 2)
|| !ppc_memory_can_write_bytes(memory, pixmap + 30, 8)
|| !ppc_memory_can_write_bytes(memory, pixmap + 42, 4)
{
return PPC_PARAM_ERR;
}
screen_records.push((index, pixmap_handle, pixmap));
if !screen_pixmaps.contains(&pixmap) {
screen_pixmaps.push(pixmap);
}
}
let Some((_, main_pixmap_handle, main_pixmap)) = screen_records
.iter()
.find(|(index, _, _)| gworlds[*index].port == PPC_MAIN_GWORLD)
.copied()
else {
return PPC_PARAM_ERR;
};
if memory.read_u32_be(gdevice + 22) != Some(main_pixmap_handle) {
return PPC_PARAM_ERR;
}
let Some(current_screen_depth) = memory.read_u16_be(main_pixmap + 32).map(u32::from) else {
return PPC_PARAM_ERR;
};
let current_is_color = current_gd_flags & 1 != 0;
let preserved_indexed_mode = if current_screen_depth <= 8 {
Some((current_screen_depth, current_is_color))
} else {
toolbox_startup.indexed_screen_mode
};
let preserve_indexed_tables =
depth <= 8 && preserved_indexed_mode == Some((depth, target_is_color));
let screen_bits = if toolbox_startup.init_graf_global_ptr == 0 {
None
} else {
let Some(screen_bits) = toolbox_startup.init_graf_global_ptr.checked_sub(122) else {
return PPC_PARAM_ERR;
};
if !ppc_memory_can_write_bytes(memory, screen_bits, 14) {
return PPC_PARAM_ERR;
}
Some(screen_bits)
};
if !ppc_memory_can_write_bytes(memory, gdevice + 4, 2)
|| !ppc_memory_can_write_bytes(memory, gdevice + 20, 2)
|| !ppc_memory_can_write_bytes(memory, gdevice + 42, 4)
|| (depth <= 8 && !ppc_main_color_table_is_valid(memory))
{
return PPC_PARAM_ERR;
}
// Imaging With QuickDraw (1994), pp. 4-46--4-47 and 4-83: indexed
// PixMaps carry a ColorTable Handle, while direct PixMaps expose NIL.
// Retain each live Handle's indexed attachment in host state so a
// caller-installed SetPortPix table can be restored after the direct leg.
let mut indexed_screen_ctables = toolbox_startup.indexed_screen_ctables.clone();
for (_, pixmap_handle, pixmap) in &screen_records {
let Some(ctable_handle) = memory.read_u32_be(*pixmap + 42) else {
return PPC_PARAM_ERR;
};
if ctable_handle != 0 {
indexed_screen_ctables.insert(*pixmap_handle, ctable_handle);
}
}
let ctable_fallback = TrapDispatcher::standard_mac_8bpp_clut();
let mut screen_pixmap_updates = Vec::with_capacity(screen_pixmaps.len());
for pixmap in screen_pixmaps {
let indexed_ctable = if depth <= 8 {
let mut selected = (pixmap == main_pixmap).then_some(PPC_MAIN_CTABLE_HANDLE);
for (_, pixmap_handle, candidate_pixmap) in &screen_records {
if *candidate_pixmap != pixmap {
continue;
}
let Some(candidate) = indexed_screen_ctables.get(pixmap_handle).copied() else {
continue;
};
if ppc_read_ctable_clut(memory, candidate, &ctable_fallback).is_none() {
indexed_screen_ctables.remove(pixmap_handle);
continue;
}
if selected.is_some_and(|current| current != candidate) {
return PPC_PARAM_ERR;
}
selected = Some(candidate);
}
let selected = selected.unwrap_or(PPC_MAIN_CTABLE_HANDLE);
for (_, pixmap_handle, candidate_pixmap) in &screen_records {
if *candidate_pixmap == pixmap {
indexed_screen_ctables.insert(*pixmap_handle, selected);
}
}
selected
} else {
0
};
screen_pixmap_updates.push((pixmap, indexed_ctable));
}
let indexed_device_clut = if depth <= 8 {
let Some((standard_clut, entry_count)) = ppc_standard_screen_clut(depth, target_is_color)
else {
return PPC_PARAM_ERR;
};
if preserve_indexed_tables {
let Some(clut) = ppc_read_ctable_clut(memory, PPC_MAIN_CTABLE_HANDLE, &standard_clut)
else {
return PPC_PARAM_ERR;
};
Some((clut, entry_count, Vec::new(), false, 0))
} else {
let Some(byte_len) = u32::try_from(entry_count)
.ok()
.and_then(|count| count.checked_mul(8))
.and_then(|entries| entries.checked_add(8))
else {
return PPC_PARAM_ERR;
};
let mut ctable_handles = screen_pixmap_updates
.iter()
.map(|(_, ctable_handle)| *ctable_handle)
.filter(|ctable_handle| *ctable_handle != 0)
.collect::<Vec<_>>();
ctable_handles.sort_unstable();
ctable_handles.dedup();
if let Err(error) = ppc_preflight_ctable_growth(
memory,
handles,
&ctable_handles,
byte_len,
*heap_cursor,
heap_limit,
) {
return error;
}
Some((standard_clut, entry_count, ctable_handles, true, byte_len))
}
} else {
None
};
if !ppc_memory_can_write_bytes(memory, PPC_MAIN_SCREEN_BASE, clear_len_u32) {
return PPC_PARAM_ERR;
}
if let Some((indexed_device_clut, entry_count, ctable_handles, install_tables, required_size)) =
indexed_device_clut.as_ref()
{
if *install_tables {
if let Err(error) = ppc_grow_ctables(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
ctable_handles,
*required_size,
) {
return error;
}
// Canonical color tables use their depth as the traditional
// seed. Grayscale and enhanced 2-bit color tables differ at the
// same depth, so give them a fresh seed to keep inverse-table
// caches from treating distinct personalities as identical.
let seed = if (target_is_color && depth != 2) || depth == 1 {
depth
} else {
ppc_next_ct_seed(toolbox_startup)
};
for ctable_handle in ctable_handles {
if ppc_install_standard_indexed_ctable(
memory,
*ctable_handle,
seed,
indexed_device_clut,
*entry_count,
)
.is_none()
{
return PPC_PARAM_ERR;
}
}
}
}
// All guest addresses have been preflighted. Patch only the fields that
// describe the selected format so window bounds, resolutions, private
// metadata, ColorTable contents, and unrelated GDevice flags survive.
for (pixmap, indexed_ctable) in screen_pixmap_updates {
if ppc_update_pixmap_depth(memory, pixmap, row_bytes, depth, indexed_ctable).is_none() {
return PPC_PARAM_ERR;
}
}
for (index, pixmap_handle, pixmap) in screen_records {
let record = &mut gworlds[index];
// SetPortPix replaces the live destination without rewriting the
// creation-time GWorld cache. Keep that cache self-consistent when it
// still describes an owned offscreen PixMap; live QuickDraw drawing
// resolves the replacement through the port itself.
if record.pixmap_handle == pixmap_handle && record.pixmap == pixmap {
record.depth = depth;
record.row_bytes = row_bytes;
}
}
let gd_type = if depth <= 8 { 0 } else { 2 };
let gd_flags = if target_is_color {
current_gd_flags | 1
} else {
current_gd_flags & !1
};
let Some(depth_mode) = u16::try_from(depth)
.ok()
.and_then(crate::display::classic_depth_mode)
else {
return PPC_PARAM_ERR;
};
if memory.write_u16_be(gdevice + 4, gd_type).is_none()
|| memory.write_u16_be(gdevice + 20, gd_flags).is_none()
|| memory
.write_u32_be(gdevice + 42, u32::from(depth_mode))
.is_none()
{
return PPC_PARAM_ERR;
}
if let Some(screen_bits) = screen_bits {
if memory
.write_u32_be(screen_bits, PPC_MAIN_SCREEN_BASE)
.is_none()
|| memory
.write_u16_be(screen_bits + 4, row_bytes as u16 & 0x3fff)
.is_none()
|| ppc_write_rect(
memory,
screen_bits + 6,
0,
0,
ppc_u32_to_i16_saturating(main_record.height),
ppc_u32_to_i16_saturating(main_record.width),
)
.is_none()
{
return PPC_PARAM_ERR;
}
}
let clear_byte = if depth == 8 { 0xff } else { 0x00 };
let clear = vec![clear_byte; clear_len];
if memory.write_bytes(PPC_MAIN_SCREEN_BASE, &clear).is_none() {
return PPC_PARAM_ERR;
}
toolbox_startup.indexed_screen_ctables = indexed_screen_ctables;
toolbox_startup.indexed_screen_mode = if depth <= 8 {
Some((depth, target_is_color))
} else {
preserved_indexed_mode
};
if let Some((indexed_device_clut, _, _, _, _)) = indexed_device_clut {
*screen_clut = indexed_device_clut;
*color_manager_clut = indexed_device_clut;
}
// A depth switch invalidates the saved pixels and front-buffer metadata
// owned by an active menu operation. Drop that operation only after the
// mode switch succeeds so it cannot resume against the new PixMap. A
// PopUpMenuSelect overlay never owns TheMenu, so preserve that low-memory
// value when cancelling popup tracking.
let tracking_owned_menu_bar = toolbox_startup
.execution
.menu()
.as_ref()
.is_some_and(|state| state.kind == MenuTrackingKind::MenuBar);
toolbox_startup.execution.with_existing_menu_context_mut(|context| {
context.tracking = None;
context.clear_native_popup();
});
toolbox_startup.go_away_tracking = None;
toolbox_startup.drag_window_tracking = None;
toolbox_startup.grow_window_tracking = None;
if tracking_owned_menu_bar {
let _ = memory.write_u16_be(PPC_THE_MENU_ADDR, 0);
}
PPC_NO_ERR
}
fn ppc_read_dsp_context_attributes(
memory: &mut PpcSectionMem,
attributes: u32,
) -> Option<PpcDspContextAttributes> {
Some(PpcDspContextAttributes {
frequency: memory.read_u32_be(attributes)?,
width: memory.read_u32_be(attributes + 4)?,
height: memory.read_u32_be(attributes + 8)?,
context_options: memory.read_u32_be(attributes + 28)?,
back_buffer_best_depth_mask: memory.read_u32_be(attributes + 32)?,
display_best_depth_mask: memory.read_u32_be(attributes + 36)?,
back_buffer_depth: memory.read_u32_be(attributes + 40)?,
display_depth: memory.read_u32_be(attributes + 44)?,
page_count: memory.read_u32_be(attributes + 48)?,
})
}
fn ppc_selected_dsp_context_attributes(
requested: PpcDspContextAttributes,
) -> PpcDspContextAttributes {
let mut selected = PpcDspContextAttributes::default();
if !ppc_dsp_context_request_is_supported(requested) {
return selected;
}
let display_depth = ppc_selected_dsp_depth(
requested.display_best_depth_mask,
requested.display_depth,
selected.display_depth,
);
let back_buffer_depth = ppc_selected_dsp_depth(
requested.back_buffer_best_depth_mask,
requested.back_buffer_depth,
display_depth,
);
selected.display_best_depth_mask = 1 << display_depth.trailing_zeros();
selected.back_buffer_best_depth_mask = 1 << back_buffer_depth.trailing_zeros();
selected.display_depth = display_depth;
selected.back_buffer_depth = back_buffer_depth;
if requested.page_count != 0 {
selected.page_count = requested.page_count;
}
selected
}
fn ppc_selected_dsp_depth(depth_mask: u32, best_depth: u32, default_depth: u32) -> u32 {
if matches!(best_depth, 8 | 16)
&& (depth_mask == 0 || depth_mask & (1 << best_depth.trailing_zeros()) != 0)
{
return best_depth;
}
if depth_mask & PPC_DSP_DEPTH_MASK_16 != 0 {
16
} else if depth_mask & PPC_DSP_DEPTH_MASK_8 != 0 {
8
} else {
default_depth
}
}
fn ppc_dsp_context_request_is_supported(requested: PpcDspContextAttributes) -> bool {
(requested.width == 0 || requested.width == PPC_DSP_SCREEN_WIDTH)
&& (requested.height == 0 || requested.height == PPC_DSP_SCREEN_HEIGHT)
&& ppc_dsp_depth_request_is_supported(
requested.display_best_depth_mask,
requested.display_depth,
)
&& ppc_dsp_back_buffer_depth_request_is_supported(
requested.back_buffer_best_depth_mask,
requested.back_buffer_depth,
)
&& (requested.page_count == 0 || requested.page_count <= PPC_DSP_MAX_REQUESTED_PAGE_COUNT)
}
fn ppc_dsp_depth_request_is_supported(depth_mask: u32, best_depth: u32) -> bool {
const SUPPORTED_DEPTH_MASK: u32 = PPC_DSP_DEPTH_MASK_8 | PPC_DSP_DEPTH_MASK_16;
(depth_mask == 0 || depth_mask & SUPPORTED_DEPTH_MASK != 0)
&& (best_depth == 0 || matches!(best_depth, 8 | 16))
}
fn ppc_dsp_back_buffer_depth_request_is_supported(depth_mask: u32, best_depth: u32) -> bool {
if depth_mask == 1 && best_depth == 1 {
return true;
}
ppc_dsp_depth_request_is_supported(depth_mask, best_depth)
}
fn ppc_read_optional_dsp_context_attributes(
memory: &mut PpcSectionMem,
attributes: u32,
) -> Option<PpcDspContextAttributes> {
if attributes == 0 {
Some(PpcDspContextAttributes::default())
} else {
ppc_read_dsp_context_attributes(memory, attributes)
}
}
fn ppc_record_requested_dsp_context_attributes(
memory: &mut PpcSectionMem,
attributes: u32,
draw_sprocket: &mut PpcDrawSprocketState,
) -> Option<()> {
let requested = ppc_read_optional_dsp_context_attributes(memory, attributes)?;
draw_sprocket.context_attributes = ppc_selected_dsp_context_attributes(requested);
Some(())
}
fn ppc_write_dsp_context_attributes(
memory: &mut PpcSectionMem,
attributes: u32,
context_attributes: PpcDspContextAttributes,
) -> Option<()> {
for offset in 0..PPC_DSP_CONTEXT_ATTRIBUTES_SIZE {
memory.write_u8(attributes + offset, 0)?;
}
memory.write_u32_be(attributes, context_attributes.frequency)?;
memory.write_u32_be(attributes + 4, context_attributes.width)?;
memory.write_u32_be(attributes + 8, context_attributes.height)?;
memory.write_u32_be(attributes + 28, context_attributes.context_options)?;
memory.write_u32_be(
attributes + 32,
context_attributes.back_buffer_best_depth_mask,
)?;
memory.write_u32_be(attributes + 36, context_attributes.display_best_depth_mask)?;
memory.write_u32_be(attributes + 40, context_attributes.back_buffer_depth)?;
memory.write_u32_be(attributes + 44, context_attributes.display_depth)?;
memory.write_u32_be(attributes + 48, context_attributes.page_count)?;
Some(())
}
fn ppc_dsp_context_get_buffer(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
buffer_gworld: u32,
buffer_out_ptr: u32,
) -> i16 {
if let Some(error) = ppc_dsp_context_error(cpu.gpr[3]) {
return error;
}
if buffer_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, buffer_out_ptr, 4) {
return PPC_PARAM_ERR;
}
if memory.write_u32_be(buffer_out_ptr, buffer_gworld).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_dsp_context_error(context: u32) -> Option<i16> {
if context == PPC_DSP_CONTEXT {
None
} else {
Some(PPC_DSP_CONTEXT_NOT_FOUND_ERR)
}
}
fn ppc_dsp_context_state_from_raw(state: u32) -> Option<PpcDspContextPlayState> {
match state {
PPC_DSP_CONTEXT_STATE_ACTIVE => Some(PpcDspContextPlayState::Active),
PPC_DSP_CONTEXT_STATE_PAUSED => Some(PpcDspContextPlayState::Paused),
PPC_DSP_CONTEXT_STATE_INACTIVE => Some(PpcDspContextPlayState::Inactive),
_ => None,
}
}
fn ppc_dsp_context_get_back_buffer(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
draw_sprocket: &PpcDrawSprocketState,
) -> i16 {
if let Some(error) = ppc_dsp_context_error(cpu.gpr[3]) {
return error;
}
let buffer_kind = cpu.gpr[4];
let buffer_out_ptr = cpu.gpr[5];
if buffer_kind != PPC_DSP_BUFFER_KIND_NORMAL {
return PPC_PARAM_ERR;
}
ppc_dsp_context_get_buffer(
cpu,
memory,
draw_sprocket.back_buffer_gworld,
buffer_out_ptr,
)
}
fn ppc_dsp_can_user_select_context(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let desired_attributes_ptr = cpu.gpr[3];
let can_select_out_ptr = cpu.gpr[4];
if can_select_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, can_select_out_ptr, 1) {
return PPC_PARAM_ERR;
}
if desired_attributes_ptr != 0
&& ppc_read_dsp_context_attributes(memory, desired_attributes_ptr).is_none()
{
return PPC_PARAM_ERR;
}
if memory.write_u8(can_select_out_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_dsp_get_first_context(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let display_id = cpu.gpr[3];
let context_out_ptr = cpu.gpr[4];
if context_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, context_out_ptr, 4) {
return PPC_PARAM_ERR;
}
// Inside Macintosh: Apple Game Sprockets Guide, "Summary of
// DrawSprocket" (1996), lists DSpGetFirstContext(DisplayIDType,
// DSpContextReference *) as the start of per-display context enumeration.
if display_id != 0 && display_id != PPC_DSP_DISPLAY_ID {
return PPC_DSP_CONTEXT_NOT_FOUND_ERR;
}
if memory
.write_u32_be(context_out_ptr, PPC_DSP_CONTEXT)
.is_none()
{
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_dsp_get_next_context(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let current_context = cpu.gpr[3];
let context_out_ptr = cpu.gpr[4];
if context_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, context_out_ptr, 4) {
return PPC_PARAM_ERR;
}
if let Some(error) = ppc_dsp_context_error(current_context) {
return error;
}
// Systemless exposes one faithful software display context, so the first
// valid context is also the end of the enumeration described above.
PPC_DSP_CONTEXT_NOT_FOUND_ERR
}
fn ppc_dsp_process_event(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let event_was_processed_out_ptr = cpu.gpr[4];
if event_was_processed_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, event_was_processed_out_ptr, 1)
{
return PPC_PARAM_ERR;
}
// Inside Macintosh: Apple Game Sprockets Guide, "Summary of
// DrawSprocket" (1996), defines DSpProcessEvent(EventRecord *, Boolean *).
// Systemless does not consume any host-only DrawSprocket window events.
if memory.write_u8(event_was_processed_out_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_dsp_find_best_context(
memory: &mut PpcSectionMem,
desired_attributes_ptr: u32,
context_out_ptr: u32,
draw_sprocket: &mut PpcDrawSprocketState,
) -> i16 {
if context_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, context_out_ptr, 4) {
return PPC_PARAM_ERR;
}
let Some(requested) = ppc_read_optional_dsp_context_attributes(memory, desired_attributes_ptr)
else {
return PPC_PARAM_ERR;
};
if sprocket_trace_enabled() {
eprintln!(
"[SPROCKET-TRACE] DSpFindBestContext requested attrs={}x{} display_mask=${:08X} back_mask=${:08X} display_best={} back_best={} pages={}",
requested.width,
requested.height,
requested.display_best_depth_mask,
requested.back_buffer_best_depth_mask,
requested.display_depth,
requested.back_buffer_depth,
requested.page_count
);
}
if !ppc_dsp_context_request_is_supported(requested) {
return PPC_DSP_CONTEXT_NOT_FOUND_ERR;
}
if memory
.write_u32_be(context_out_ptr, PPC_DSP_CONTEXT)
.is_none()
{
return PPC_PARAM_ERR;
}
draw_sprocket.context_attributes = ppc_selected_dsp_context_attributes(requested);
draw_sprocket.started = true;
PPC_NO_ERR
}
fn ppc_dsp_user_select_context(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
draw_sprocket: &mut PpcDrawSprocketState,
) -> i16 {
let result = ppc_dsp_find_best_context(memory, cpu.gpr[3], cpu.gpr[6], draw_sprocket);
if result == PPC_NO_ERR {
draw_sprocket.last_user_select_display_id = Some(cpu.gpr[4]);
draw_sprocket.last_user_select_event_proc = Some(cpu.gpr[5]);
draw_sprocket.user_select_count = draw_sprocket.user_select_count.saturating_add(1);
}
result
}
fn ppc_dsp_set_blanking_color(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
draw_sprocket: &mut PpcDrawSprocketState,
) -> i16 {
// Inside Macintosh: Apple Game Sprockets Guide (1996),
// "DSpSetBlankingColor": the RGBColor applies to the blanking window for
// every display while any context is active.
if cpu.gpr[3] == 0 {
return PPC_PARAM_ERR;
}
let Some(color) = ppc_read_rgb_color(memory, cpu.gpr[3]) else {
return PPC_PARAM_ERR;
};
draw_sprocket.blanking_color = color;
PPC_NO_ERR
}
fn ppc_dsp_get_mouse(cpu: &PpcCpu, memory: &mut PpcSectionMem, input: &PpcInputSnapshot) -> i16 {
// DrawSprocket.h: DSpGetMouse reports a global QuickDraw Point.
let out_global_point = cpu.gpr[3];
if out_global_point == 0 || !ppc_memory_can_write_bytes(memory, out_global_point, 4) {
return PPC_PARAM_ERR;
}
if memory
.write_u16_be(out_global_point, input.mouse_v as u16)
.is_none()
|| memory
.write_u16_be(out_global_point + 2, input.mouse_h as u16)
.is_none()
{
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_dsp_find_context_from_point(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
// Inside Macintosh: Apple Game Sprockets Guide (1996),
// "DSpFindContextFromPoint". PowerPC passes the four-byte Point value in r3.
let global_v = (cpu.gpr[3] >> 16) as u16 as i16;
let global_h = cpu.gpr[3] as u16 as i16;
let out_context = cpu.gpr[4];
if out_context == 0 || !ppc_memory_can_write_bytes(memory, out_context, 4) {
return PPC_PARAM_ERR;
}
if global_v < 0
|| global_h < 0
|| global_v >= PPC_MAIN_SCREEN_HEIGHT as i16
|| global_h >= PPC_MAIN_SCREEN_WIDTH as i16
{
return PPC_DSP_CONTEXT_NOT_FOUND_ERR;
}
if memory.write_u32_be(out_context, PPC_DSP_CONTEXT).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_dsp_context_global_to_local(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
// Systemless currently exposes one DrawSprocket context whose origin is
// the main display origin, so global and context-local coordinates match.
if let Some(error) = ppc_dsp_context_error(cpu.gpr[3]) {
return error;
}
let point = cpu.gpr[4];
if point == 0 || !ppc_memory_can_write_bytes(memory, point, 4) {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
#[allow(clippy::too_many_arguments)]
fn ppc_dsp_alt_buffer_new(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
gworlds: &mut Vec<PpcGWorldRecord>,
gworld_allocations: &mut HashMap<u32, PpcGWorldAllocationRecord>,
current_gdevice: u32,
draw_sprocket: &PpcDrawSprocketState,
) -> i16 {
if let Some(error) = ppc_dsp_context_error(cpu.gpr[3]) {
return error;
}
let out_alt_buffer = cpu.gpr[6];
if out_alt_buffer == 0 || !ppc_memory_can_write_bytes(memory, out_alt_buffer, 4) {
return PPC_PARAM_ERR;
}
let (width, height) = if cpu.gpr[5] == 0 {
(
draw_sprocket.context_attributes.width,
draw_sprocket.context_attributes.height,
)
} else {
let Some(width) = memory.read_u32_be(cpu.gpr[5]) else {
return PPC_PARAM_ERR;
};
let Some(height) = memory.read_u32_be(cpu.gpr[5] + 4) else {
return PPC_PARAM_ERR;
};
let Some(_options) = memory.read_u32_be(cpu.gpr[5] + 8) else {
return PPC_PARAM_ERR;
};
(width, height)
};
if width == 0 || height == 0 || width > i16::MAX as u32 || height > i16::MAX as u32 {
return PPC_PARAM_ERR;
}
let rect_ptr = ppc_process_heap_alloc(process_memory_manager, memory, heap_cursor, 8, true);
if rect_ptr == 0
|| ppc_write_rect(memory, rect_ptr, 0, 0, height as i16, width as i16).is_none()
{
*last_mem_error = PPC_MEM_FULL_ERR;
return PPC_MEM_FULL_ERR;
}
let mut world_cpu = cpu.clone();
world_cpu.gpr[3] = out_alt_buffer;
world_cpu.gpr[4] = draw_sprocket.context_attributes.display_depth;
world_cpu.gpr[5] = rect_ptr;
world_cpu.gpr[6] = 0;
world_cpu.gpr[7] = current_gdevice;
world_cpu.gpr[8] = 0;
ppc_new_gworld(
&mut world_cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
gworlds,
gworld_allocations,
current_gdevice,
)
}
fn ppc_dsp_alt_buffer_get_cgraf_ptr(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
) -> i16 {
if cpu.gpr[4] != PPC_DSP_BUFFER_KIND_NORMAL
|| cpu.gpr[5] == 0
|| cpu.gpr[6] == 0
|| !ppc_memory_can_write_bytes(memory, cpu.gpr[5], 4)
|| !ppc_memory_can_write_bytes(memory, cpu.gpr[6], 4)
{
return PPC_PARAM_ERR;
}
let Some(world) = gworlds.iter().find(|world| world.port == cpu.gpr[3]) else {
return PPC_PARAM_ERR;
};
if memory.write_u32_be(cpu.gpr[5], world.port).is_none()
|| memory.write_u32_be(cpu.gpr[6], world.gdevice).is_none()
{
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_dsp_context_reserve(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
draw_sprocket: &mut PpcDrawSprocketState,
gworlds: &mut [PpcGWorldRecord],
) -> i16 {
let context = cpu.gpr[3];
if let Some(error) = ppc_dsp_context_error(context) {
return error;
}
if draw_sprocket.reserved_context.is_some() {
return PPC_DSP_CONTEXT_ALREADY_RESERVED_ERR;
}
if cpu.gpr[4] != 0
&& ppc_record_requested_dsp_context_attributes(memory, cpu.gpr[4], draw_sprocket).is_none()
{
return PPC_PARAM_ERR;
}
if ppc_configure_dsp_framebuffers(memory, gworlds, draw_sprocket.context_attributes).is_none() {
return PPC_PARAM_ERR;
}
// A one-page DrawSprocket context exposes the displayed page as its
// drawing buffer. Multi-page contexts retain the distinct back buffer
// that DSpContext_SwapBuffers transfers to the displayed page.
draw_sprocket.back_buffer_gworld = if draw_sprocket.context_attributes.page_count == 1 {
draw_sprocket.front_buffer_gworld
} else {
PPC_DSP_BACK_GWORLD
};
draw_sprocket.started = true;
draw_sprocket.reserved_context = Some(context);
draw_sprocket.active_context = None;
draw_sprocket.context_state = PpcDspContextPlayState::Inactive;
PPC_NO_ERR
}
fn ppc_configure_dsp_framebuffers(
memory: &mut PpcSectionMem,
gworlds: &mut [PpcGWorldRecord],
attributes: PpcDspContextAttributes,
) -> Option<()> {
if attributes.width != PPC_DSP_SCREEN_WIDTH
|| attributes.height != PPC_DSP_SCREEN_HEIGHT
|| attributes.display_depth != attributes.back_buffer_depth
|| !matches!(attributes.display_depth, 8 | 16)
{
return None;
}
let row_bytes = ppc_row_bytes(attributes.width, attributes.display_depth)?;
// Apple Game Sprockets Guide (1996), DSpContext_Reserve and
// DSpContext_GetFrontBuffer/GetBackBuffer: reserving a context provides
// display and back-buffer GWorlds in the selected context depth.
for record in gworlds.iter_mut().filter(|record| {
record.base_addr == PPC_MAIN_SCREEN_BASE || record.base_addr == PPC_DSP_BACK_SCREEN_BASE
}) {
record.width = attributes.width;
record.height = attributes.height;
record.depth = attributes.display_depth;
record.row_bytes = row_bytes;
ppc_write_pixmap(
memory,
record.pixmap,
record.base_addr,
row_bytes,
0,
0,
attributes.height as i16,
attributes.width as i16,
attributes.display_depth,
)?;
}
ppc_write_gdevice(
memory,
PPC_MAIN_GDEVICE_RECORD,
PPC_MAIN_PIXMAP_HANDLE,
0,
0,
attributes.height as i16,
attributes.width as i16,
)?;
Some(())
}
fn ppc_dsp_context_release(cpu: &PpcCpu, draw_sprocket: &mut PpcDrawSprocketState) -> i16 {
let context = cpu.gpr[3];
if let Some(error) = ppc_dsp_context_error(context) {
return error;
}
if draw_sprocket.reserved_context != Some(context) {
return PPC_DSP_CONTEXT_NOT_RESERVED_ERR;
}
draw_sprocket.reserved_context = None;
draw_sprocket.active_context = None;
draw_sprocket.context_state = PpcDspContextPlayState::Inactive;
PPC_NO_ERR
}
fn ppc_dsp_context_set_state(cpu: &PpcCpu, draw_sprocket: &mut PpcDrawSprocketState) -> i16 {
let context = cpu.gpr[3];
if let Some(error) = ppc_dsp_context_error(context) {
return error;
}
let Some(state) = ppc_dsp_context_state_from_raw(cpu.gpr[4]) else {
return PPC_PARAM_ERR;
};
if draw_sprocket.reserved_context != Some(context) {
return PPC_DSP_CONTEXT_NOT_RESERVED_ERR;
}
match state {
PpcDspContextPlayState::Active => {
draw_sprocket.started = true;
draw_sprocket.active_context = Some(context);
draw_sprocket.context_state = state;
}
PpcDspContextPlayState::Paused | PpcDspContextPlayState::Inactive => {
draw_sprocket.started = true;
draw_sprocket.active_context = None;
draw_sprocket.context_state = state;
}
}
PPC_NO_ERR
}
fn ppc_read_rgb_color(memory: &mut PpcSectionMem, color: u32) -> Option<PpcRgbColor> {
Some(PpcRgbColor {
red: memory.read_u16_be(color)?,
green: memory.read_u16_be(color + 2)?,
blue: memory.read_u16_be(color + 4)?,
})
}
fn ppc_write_rgb_color(memory: &mut PpcSectionMem, color: u32, value: PpcRgbColor) -> Option<()> {
memory.write_u16_be(color, value.red)?;
memory.write_u16_be(color + 2, value.green)?;
memory.write_u16_be(color + 4, value.blue)?;
Some(())
}
fn ppc_port_rgb_colors(
memory: &mut PpcSectionMem,
port: u32,
) -> Option<(PpcRgbColor, PpcRgbColor)> {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 2-9--2-10:
// rgbFgColor and rgbBkColor belong to each CGrafPort. Port switches must
// therefore restore them instead of leaking the previous port's colors.
if memory.read_u16_be(port.checked_add(6)?)? & 0xc000 != 0xc000 {
return None;
}
Some((
ppc_read_rgb_color(
memory,
port.checked_add(PPC_CGRAF_PORT_RGB_FG_COLOR_OFFSET)?,
)?,
ppc_read_rgb_color(
memory,
port.checked_add(PPC_CGRAF_PORT_RGB_BK_COLOR_OFFSET)?,
)?,
))
}
fn ppc_port_op_color_from_graf_vars(
memory: &mut PpcSectionMem,
port: u32,
) -> Option<PpcRgbColor> {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 4-62 and 4-64:
// a CGrafPort's GrafVars record begins with rgbOpColor. Do not consult
// the fallback map when a valid guest record is present; guest memory is
// the authoritative representation for that port.
if memory.read_u16_be(port.checked_add(6)?)? & 0xc000 != 0xc000 {
return None;
}
let graf_vars_handle = memory.read_u32_be(port.checked_add(PPC_CGRAF_PORT_GRAF_VARS_OFFSET)?)?;
if graf_vars_handle == 0 || !ppc_memory_can_write_bytes(memory, graf_vars_handle, 4) {
return None;
}
let graf_vars = memory.read_u32_be(graf_vars_handle)?;
if graf_vars == 0 || !ppc_memory_can_write_bytes(memory, graf_vars, 6) {
return None;
}
ppc_read_rgb_color(memory, graf_vars)
}
fn ppc_current_op_color(
memory: &mut PpcSectionMem,
port: u32,
quickdraw_op_colors: &SharedProcessQuickDrawOpColors,
) -> PpcRgbColor {
ppc_port_op_color_from_graf_vars(memory, port)
.or_else(|| {
quickdraw_op_colors
.quickdraw_op_color(port)
.map(|(red, green, blue)| PpcRgbColor { red, green, blue })
})
.unwrap_or(PPC_RGB_BLACK)
}
fn ppc_write_port_op_color(
memory: &mut PpcSectionMem,
port: u32,
color: PpcRgbColor,
quickdraw_op_colors: &SharedProcessQuickDrawOpColors,
) {
let Some(port_version) = port.checked_add(6).and_then(|address| memory.read_u16_be(address))
else {
return;
};
if port_version & 0xc000 != 0xc000 {
return;
}
let graf_vars_handle = memory
.read_u32_be(port.wrapping_add(PPC_CGRAF_PORT_GRAF_VARS_OFFSET))
.unwrap_or(0);
if let Some(graf_vars) = (graf_vars_handle != 0)
.then(|| memory.read_u32_be(graf_vars_handle).unwrap_or(0))
.filter(|graf_vars| {
*graf_vars != 0 && ppc_memory_can_write_bytes(memory, *graf_vars, 6)
})
{
let _ = ppc_write_rgb_color(memory, graf_vars, color);
}
// Static process ports (including the seeded main port) do not own an
// allocator-managed GrafVars handle. Keep their per-port fallback live
// across attached 68K and PowerPC adapters.
quickdraw_op_colors.set_quickdraw_op_color(port, (color.red, color.green, color.blue));
}
fn ppc_port_hilite_color_from_graf_vars(
memory: &mut PpcSectionMem,
port: u32,
) -> Option<PpcRgbColor> {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 4-62 and 4-64:
// a CGrafPort's GrafVars.rgbHiliteColor follows rgbOpColor at offset 6.
// Do not consult the fallback map when a valid guest record is present;
// guest memory is the authoritative representation for that port.
if memory.read_u16_be(port.checked_add(6)?)? & 0xc000 != 0xc000 {
return None;
}
let graf_vars_handle = memory.read_u32_be(port.checked_add(PPC_CGRAF_PORT_GRAF_VARS_OFFSET)?)?;
if graf_vars_handle == 0 || !ppc_memory_can_write_bytes(memory, graf_vars_handle, 4) {
return None;
}
let graf_vars = memory.read_u32_be(graf_vars_handle)?;
let hilite_color = graf_vars.checked_add(6)?;
if graf_vars == 0 || !ppc_memory_can_write_bytes(memory, hilite_color, 6) {
return None;
}
ppc_read_rgb_color(memory, hilite_color)
}
fn ppc_current_hilite_color(
memory: &mut PpcSectionMem,
port: u32,
quickdraw_hilite_colors: &SharedProcessQuickDrawHiliteColors,
) -> PpcRgbColor {
ppc_port_hilite_color_from_graf_vars(memory, port)
.or_else(|| {
quickdraw_hilite_colors
.quickdraw_hilite_color(port)
.map(|(red, green, blue)| PpcRgbColor { red, green, blue })
})
.unwrap_or_else(|| {
let (red, green, blue) = DEFAULT_QUICKDRAW_HILITE_COLOR;
PpcRgbColor { red, green, blue }
})
}
fn ppc_write_port_hilite_color(
memory: &mut PpcSectionMem,
port: u32,
color: PpcRgbColor,
quickdraw_hilite_colors: &SharedProcessQuickDrawHiliteColors,
) {
let Some(port_version) = port.checked_add(6).and_then(|address| memory.read_u16_be(address))
else {
return;
};
if port_version & 0xc000 != 0xc000 {
return;
}
let graf_vars_handle = memory
.read_u32_be(port.wrapping_add(PPC_CGRAF_PORT_GRAF_VARS_OFFSET))
.unwrap_or(0);
if let Some(graf_vars) = (graf_vars_handle != 0)
.then(|| memory.read_u32_be(graf_vars_handle).unwrap_or(0))
.filter(|graf_vars| *graf_vars != 0)
.and_then(|graf_vars| graf_vars.checked_add(6))
.filter(|graf_vars| {
ppc_memory_can_write_bytes(memory, *graf_vars, 6)
})
{
let _ = ppc_write_rgb_color(memory, graf_vars, color);
}
// Static process ports (including the seeded main port) do not own an
// allocator-managed GrafVars handle. Keep their per-port fallback live
// across attached 68K and PowerPC adapters.
quickdraw_hilite_colors.set_quickdraw_hilite_color(
port,
(color.red, color.green, color.blue),
);
}
fn ppc_write_port_rgb_color(
memory: &mut PpcSectionMem,
port: u32,
offset: u32,
color: PpcRgbColor,
) -> Option<()> {
// A monochrome GrafPort has legacy fgColor/bkColor fields at these byte
// positions rather than RGBColor records. Do not overwrite them.
if memory.read_u16_be(port.checked_add(6)?)? & 0xc000 != 0xc000 {
return None;
}
ppc_write_rgb_color(memory, port.checked_add(offset)?, color)
}
pub(super) fn ppc_restore_port_colors(
memory: &mut PpcSectionMem,
port: u32,
fore_color: &mut PpcRgbColor,
back_color: &mut PpcRgbColor,
) {
if let Some((port_fore_color, port_back_color)) = ppc_port_rgb_colors(memory, port) {
*fore_color = port_fore_color;
*back_color = port_back_color;
}
}
fn ppc_restore_process_port_draw_state(
memory: &mut PpcSectionMem,
port: u32,
fore_color: &mut PpcRgbColor,
back_color: &mut PpcRgbColor,
pen_h: &mut i16,
pen_v: &mut i16,
text_mode: &mut i16,
text_size: &mut i16,
) {
let Some((port_fore_color, port_back_color)) = ppc_port_rgb_colors(memory, port) else {
return;
};
// A graphics port is the complete drawing environment, and each port
// owns its pen, colors, and text settings. Reload the documented
// CGrafPort fields whenever attached execution crosses an HLE boundary so
// a preceding 68K callback is visible without an adapter-to-adapter copy.
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 2-30--2-33,
// 4-8--4-10, and 4-48.
*fore_color = port_fore_color;
*back_color = port_back_color;
if let Some((h, v)) = ppc_gworld_pen(memory, port) {
*pen_h = h;
*pen_v = v;
}
if let Some(value) = memory.read_u16_be(port.wrapping_add(PPC_CGRAF_PORT_TX_MODE_OFFSET)) {
*text_mode = value as i16;
}
if let Some(value) = memory.read_u16_be(port.wrapping_add(PPC_CGRAF_PORT_TX_SIZE_OFFSET)) {
*text_size = value as i16;
}
}
fn ppc_rgb2hsl(memory: &mut PpcSectionMem, rgb_ptr: u32, hsl_ptr: u32) -> bool {
// Inside Macintosh Volume VI (1991), pp. 19-10--19-11: RGBColor and
// HSLColor both carry unsigned 16-bit components; hue is a fraction of a
// circle and lightness is midway between the greatest and least channel.
let Some(rgb) = ppc_read_rgb_color(memory, rgb_ptr) else {
return false;
};
if hsl_ptr == 0 || !ppc_memory_can_write_bytes(memory, hsl_ptr, 6) {
return false;
}
let red = f64::from(rgb.red) / 65_535.0;
let green = f64::from(rgb.green) / 65_535.0;
let blue = f64::from(rgb.blue) / 65_535.0;
let greatest = red.max(green).max(blue);
let least = red.min(green).min(blue);
let delta = greatest - least;
let lightness = (greatest + least) / 2.0;
let (hue, saturation) = if delta == 0.0 {
(0.0, 0.0)
} else {
let saturation = if lightness <= 0.5 {
delta / (greatest + least)
} else {
delta / (2.0 - greatest - least)
};
let mut hue = if greatest == red {
(green - blue) / delta
} else if greatest == green {
2.0 + (blue - red) / delta
} else {
4.0 + (red - green) / delta
};
if hue < 0.0 {
hue += 6.0;
}
(hue / 6.0, saturation)
};
let to_small_fract =
|component: f64| -> u16 { (component.clamp(0.0, 1.0) * 65_535.0).round() as u16 };
memory.write_u16_be(hsl_ptr, to_small_fract(hue)).is_some()
&& memory
.write_u16_be(hsl_ptr + 2, to_small_fract(saturation))
.is_some()
&& memory
.write_u16_be(hsl_ptr + 4, to_small_fract(lightness))
.is_some()
}
fn ppc_rgb2hsv(memory: &mut PpcSectionMem, rgb_ptr: u32, hsv_ptr: u32) -> bool {
// Inside Macintosh Volume VI (1991), pp. 19-10--19-11: HSVColor uses
// unsigned 16-bit fractions for hue, saturation, and value.
let Some(rgb) = ppc_read_rgb_color(memory, rgb_ptr) else {
return false;
};
if hsv_ptr == 0 || !ppc_memory_can_write_bytes(memory, hsv_ptr, 6) {
return false;
}
let red = f64::from(rgb.red) / 65_535.0;
let green = f64::from(rgb.green) / 65_535.0;
let blue = f64::from(rgb.blue) / 65_535.0;
let greatest = red.max(green).max(blue);
let least = red.min(green).min(blue);
let delta = greatest - least;
let saturation = if greatest == 0.0 {
0.0
} else {
delta / greatest
};
let hue = if delta == 0.0 {
0.0
} else {
let mut sector = if greatest == red {
(green - blue) / delta
} else if greatest == green {
2.0 + (blue - red) / delta
} else {
4.0 + (red - green) / delta
};
if sector < 0.0 {
sector += 6.0;
}
sector / 6.0
};
let to_small_fract =
|component: f64| -> u16 { (component.clamp(0.0, 1.0) * 65_535.0).round() as u16 };
memory.write_u16_be(hsv_ptr, to_small_fract(hue)).is_some()
&& memory
.write_u16_be(hsv_ptr + 2, to_small_fract(saturation))
.is_some()
&& memory
.write_u16_be(hsv_ptr + 4, to_small_fract(greatest))
.is_some()
}
fn ppc_hsv2rgb(memory: &mut PpcSectionMem, hsv_ptr: u32, rgb_ptr: u32) -> bool {
if hsv_ptr == 0
|| rgb_ptr == 0
|| !ppc_memory_can_write_bytes(memory, hsv_ptr, 6)
|| !ppc_memory_can_write_bytes(memory, rgb_ptr, 6)
{
return false;
}
let hue = f64::from(memory.read_u16_be(hsv_ptr).unwrap_or(0)) / 65_535.0;
let saturation = f64::from(memory.read_u16_be(hsv_ptr + 2).unwrap_or(0)) / 65_535.0;
let value = f64::from(memory.read_u16_be(hsv_ptr + 4).unwrap_or(0)) / 65_535.0;
let (red, green, blue) = if saturation == 0.0 {
(value, value, value)
} else {
let scaled_hue = hue * 6.0;
let sector = scaled_hue.floor() as u32 % 6;
let fraction = scaled_hue - scaled_hue.floor();
let low = value * (1.0 - saturation);
let falling = value * (1.0 - saturation * fraction);
let rising = value * (1.0 - saturation * (1.0 - fraction));
match sector {
0 => (value, rising, low),
1 => (falling, value, low),
2 => (low, value, rising),
3 => (low, falling, value),
4 => (rising, low, value),
_ => (value, low, falling),
}
};
let to_word =
|component: f64| -> u16 { (component.clamp(0.0, 1.0) * 65_535.0).round() as u16 };
memory.write_u16_be(rgb_ptr, to_word(red)).is_some()
&& memory.write_u16_be(rgb_ptr + 2, to_word(green)).is_some()
&& memory.write_u16_be(rgb_ptr + 4, to_word(blue)).is_some()
}
fn ppc_optional_rgb_color(memory: &mut PpcSectionMem, color: u32) -> Option<Option<PpcRgbColor>> {
if color == 0 {
Some(None)
} else {
Some(Some(ppc_read_rgb_color(memory, color)?))
}
}
fn ppc_dsp_context_fade_gamma(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
draw_sprocket: &mut PpcDrawSprocketState,
kind: PpcDspGammaFadeKind,
) -> i16 {
let context = cpu.gpr[3];
if context != 0 {
if let Some(error) = ppc_dsp_context_error(context) {
return error;
}
if kind != PpcDspGammaFadeKind::Manual && draw_sprocket.reserved_context != Some(context) {
return PPC_DSP_CONTEXT_NOT_RESERVED_ERR;
}
} else if kind != PpcDspGammaFadeKind::Manual && draw_sprocket.reserved_context.is_none() {
return PPC_DSP_CONTEXT_NOT_RESERVED_ERR;
}
let (percent, zero_color_ptr) = match kind {
PpcDspGammaFadeKind::Manual => (cpu.gpr[4] as i32, cpu.gpr[5]),
PpcDspGammaFadeKind::In => (100, cpu.gpr[4]),
PpcDspGammaFadeKind::Out => (0, cpu.gpr[4]),
};
let Some(zero_color) = ppc_optional_rgb_color(memory, zero_color_ptr) else {
return PPC_PARAM_ERR;
};
draw_sprocket.last_fade_context = Some(context);
draw_sprocket.last_fade_kind = Some(kind);
draw_sprocket.last_fade_percent = Some(percent);
draw_sprocket.last_fade_zero_color = zero_color;
draw_sprocket.fade_count = draw_sprocket.fade_count.saturating_add(1);
PPC_NO_ERR
}
fn ppc_dsp_context_swap_buffers(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
draw_sprocket: &mut PpcDrawSprocketState,
gworlds: &[PpcGWorldRecord],
) -> i16 {
let context = cpu.gpr[3];
if let Some(error) = ppc_dsp_context_error(context) {
return error;
}
if draw_sprocket.active_context != Some(context) {
return PPC_PARAM_ERR;
}
let Some(front) = gworlds
.iter()
.find(|record| record.port == draw_sprocket.front_buffer_gworld)
.copied()
else {
return PPC_PARAM_ERR;
};
let Some(back) = gworlds
.iter()
.find(|record| record.port == draw_sprocket.back_buffer_gworld)
.copied()
else {
return PPC_PARAM_ERR;
};
if !ppc_dsp_present_back_buffer(memory, back, front) {
return PPC_PARAM_ERR;
}
draw_sprocket.last_swap_context = Some(context);
draw_sprocket.swap_count = draw_sprocket.swap_count.saturating_add(1);
PPC_NO_ERR
}
fn ppc_dsp_present_back_buffer(
memory: &mut PpcSectionMem,
back: PpcGWorldRecord,
front: PpcGWorldRecord,
) -> bool {
if back.width != front.width
|| back.height != front.height
|| back.depth != front.depth
|| !matches!(back.depth, 8 | 16)
{
return false;
}
let row_len =
match ppc_row_bytes(back.width, back.depth).and_then(|len| usize::try_from(len).ok()) {
Some(row_len) => row_len,
None => return false,
};
let mut frame = vec![0; row_len.saturating_mul(back.height as usize)];
for row in 0..back.height {
let Some(src) = back
.base_addr
.checked_add(row.saturating_mul(back.row_bytes))
else {
return false;
};
let start = row as usize * row_len;
if memory
.read_bytes_into(src, &mut frame[start..start + row_len])
.is_none()
{
return false;
}
}
for row in 0..front.height {
let Some(dst) = front
.base_addr
.checked_add(row.saturating_mul(front.row_bytes))
else {
return false;
};
let start = row as usize * row_len;
if memory
.write_bytes(dst, &frame[start..start + row_len])
.is_none()
{
return false;
}
}
// Apple Game Sprockets Guide (1996), DSpContext_SwapBuffers, p. 2-55:
// the invalid parts of the context's back buffer (or the entire buffer
// when no dirty rectangles are supplied) are drawn to the screen.
true
}
fn ppc_dsp_context_set_clut_entries(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
screen_clut: &mut [[u16; 3]; 256],
) -> i16 {
if let Some(error) = ppc_dsp_context_error(cpu.gpr[3]) {
return error;
}
let entries_ptr = cpu.gpr[4];
let starting_entry = usize::from(cpu.gpr[5] as u16);
let entry_count = usize::from(cpu.gpr[6] as u16);
let Some(end_entry) = starting_entry.checked_add(entry_count) else {
return PPC_PARAM_ERR;
};
if end_entry > screen_clut.len() {
return PPC_PARAM_ERR;
}
let Some(byte_count) = entry_count.checked_mul(8) else {
return PPC_PARAM_ERR;
};
if byte_count != 0
&& (entries_ptr == 0 || !ppc_memory_can_read_bytes(memory, entries_ptr, byte_count as u32))
{
return PPC_PARAM_ERR;
}
// Inside Macintosh: Apple Game Sprockets Guide (1996),
// DSpContext_SetCLUTEntries, p. 2-70: inEntries is an array of ColorSpec
// records replacing a zero-based contiguous range of the context's CLUT.
for offset in 0..entry_count {
let entry_ptr = entries_ptr + (offset as u32) * 8;
let Some(red) = memory.read_u16_be(entry_ptr + 2) else {
return PPC_PARAM_ERR;
};
let Some(green) = memory.read_u16_be(entry_ptr + 4) else {
return PPC_PARAM_ERR;
};
let Some(blue) = memory.read_u16_be(entry_ptr + 6) else {
return PPC_PARAM_ERR;
};
screen_clut[starting_entry + offset] = [red, green, blue];
}
PPC_NO_ERR
}
fn ppc_i16_return_value(action: &PpcImportAction) -> Option<i16> {
match *action {
PpcImportAction::Return(value) => Some(value as i16),
_ => None,
}
}
fn ppc_draw_sprocket_action_name(target: &PpcImportDispatcherTarget) -> Option<&'static str> {
match target {
PpcImportDispatcherTarget::DSpStartup => Some("startup"),
PpcImportDispatcherTarget::DSpShutdown => Some("shutdown"),
PpcImportDispatcherTarget::DSpGetFirstContext => Some("get_first_context"),
PpcImportDispatcherTarget::DSpGetNextContext => Some("get_next_context"),
PpcImportDispatcherTarget::DSpProcessEvent => Some("process_event"),
PpcImportDispatcherTarget::DSpCanUserSelectContext => Some("can_user_select_context"),
PpcImportDispatcherTarget::DSpGetMouse => Some("get_mouse"),
PpcImportDispatcherTarget::DSpFindContextFromPoint => Some("find_context_from_point"),
PpcImportDispatcherTarget::DSpContextGlobalToLocal => Some("context_global_to_local"),
PpcImportDispatcherTarget::DSpFindBestContext => Some("find_best_context"),
PpcImportDispatcherTarget::DSpUserSelectContext => Some("user_select_context"),
PpcImportDispatcherTarget::DSpSetBlankingColor => Some("set_blanking_color"),
PpcImportDispatcherTarget::DSpAltBufferNew => Some("alt_buffer_new"),
PpcImportDispatcherTarget::DSpAltBufferGetCGrafPtr => Some("alt_buffer_get_cgraf_ptr"),
PpcImportDispatcherTarget::DSpContextReserve => Some("context_reserve"),
PpcImportDispatcherTarget::DSpContextRelease => Some("context_release"),
PpcImportDispatcherTarget::DSpContextSetState => Some("context_set_state"),
PpcImportDispatcherTarget::DSpContextFadeGamma => Some("fade_gamma"),
PpcImportDispatcherTarget::DSpContextFadeGammaIn => Some("fade_gamma_in"),
PpcImportDispatcherTarget::DSpContextFadeGammaOut => Some("fade_gamma_out"),
PpcImportDispatcherTarget::DSpContextGetFrontBuffer => Some("get_front_buffer"),
PpcImportDispatcherTarget::DSpContextGetBackBuffer => Some("get_back_buffer"),
PpcImportDispatcherTarget::DSpContextSwapBuffers => Some("swap_buffers"),
PpcImportDispatcherTarget::DSpContextSetClutEntries => Some("set_clut_entries"),
PpcImportDispatcherTarget::DSpContextGetDisplayID => Some("get_display_id"),
PpcImportDispatcherTarget::DSpContextGetAttributes => Some("get_attributes"),
PpcImportDispatcherTarget::DSpContextSetVblProc => Some("set_vbl_proc"),
PpcImportDispatcherTarget::DSpContextIsBusy => Some("is_busy"),
PpcImportDispatcherTarget::DSpAltBufferDispose => Some("alt_buffer_dispose"),
PpcImportDispatcherTarget::DSpContextInvalBackBufferRect => Some("inval_back_buffer_rect"),
PpcImportDispatcherTarget::DSpContextSetUnderlayAltBuffer => Some("set_underlay_alt_buffer"),
_ => None,
}
}
fn ppc_draw_sprocket_trace_entry(
import_index: u32,
pc: u32,
memory: &mut PpcSectionMem,
cpu: &PpcCpu,
action: &str,
result: i16,
draw_sprocket: &PpcDrawSprocketState,
) -> PpcDrawSprocketTraceEntry {
let attributes = draw_sprocket.context_attributes;
let requested_attributes = ppc_draw_sprocket_trace_requested_attributes(action, cpu, memory);
let fade_zero_color = draw_sprocket.last_fade_zero_color;
PpcDrawSprocketTraceEntry {
import_index,
pc,
action: action.to_string(),
result,
context: ppc_draw_sprocket_trace_context(action, cpu),
requested_state: ppc_draw_sprocket_trace_requested_state(action, cpu),
requested_frequency: requested_attributes.map(|attributes| attributes.frequency),
requested_width: requested_attributes.map(|attributes| attributes.width),
requested_height: requested_attributes.map(|attributes| attributes.height),
requested_context_options: requested_attributes
.map(|attributes| attributes.context_options),
requested_display_depth_mask: requested_attributes
.map(|attributes| attributes.display_best_depth_mask),
requested_back_buffer_depth_mask: requested_attributes
.map(|attributes| attributes.back_buffer_best_depth_mask),
requested_display_depth: requested_attributes.map(|attributes| attributes.display_depth),
requested_back_buffer_depth: requested_attributes
.map(|attributes| attributes.back_buffer_depth),
requested_page_count: requested_attributes.map(|attributes| attributes.page_count),
can_user_select: ppc_draw_sprocket_trace_can_user_select(action, result, cpu, memory),
fade_kind: draw_sprocket
.last_fade_kind
.map(|kind| dsp_gamma_kind_name(kind).to_string()),
fade_percent: draw_sprocket.last_fade_percent,
fade_zero_red: fade_zero_color.map(|color| color.red),
fade_zero_green: fade_zero_color.map(|color| color.green),
fade_zero_blue: fade_zero_color.map(|color| color.blue),
reserved_context: draw_sprocket.reserved_context,
active_context: draw_sprocket.active_context,
context_state: dsp_context_play_state_name(draw_sprocket.context_state).to_string(),
front_buffer_gworld: draw_sprocket.front_buffer_gworld,
back_buffer_gworld: draw_sprocket.back_buffer_gworld,
last_swap_context: draw_sprocket.last_swap_context,
swap_count: draw_sprocket.swap_count,
fade_count: draw_sprocket.fade_count,
frequency: attributes.frequency,
width: attributes.width,
height: attributes.height,
context_options: attributes.context_options,
display_depth_mask: attributes.display_best_depth_mask,
back_buffer_depth_mask: attributes.back_buffer_best_depth_mask,
display_depth: attributes.display_depth,
back_buffer_depth: attributes.back_buffer_depth,
page_count: attributes.page_count,
}
}
fn ppc_draw_sprocket_trace_requested_attributes(
action: &str,
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
) -> Option<PpcDspContextAttributes> {
let attributes_ptr = match action {
"can_user_select_context" | "find_best_context" | "user_select_context" => cpu.gpr[3],
"context_reserve" => cpu.gpr[4],
_ => return None,
};
ppc_read_optional_dsp_context_attributes(memory, attributes_ptr)
}
fn ppc_draw_sprocket_trace_can_user_select(
action: &str,
result: i16,
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
) -> Option<bool> {
if action != "can_user_select_context" || result != PPC_NO_ERR {
return None;
}
memory.read_u8(cpu.gpr[4]).map(|value| value != 0)
}
fn ppc_draw_sprocket_trace_context(action: &str, cpu: &PpcCpu) -> Option<u32> {
match action {
"context_reserve" | "context_release" | "context_set_state" | "fade_gamma"
| "fade_gamma_in" | "fade_gamma_out" | "get_front_buffer" | "get_back_buffer"
| "swap_buffers" | "get_display_id" | "get_attributes" => Some(cpu.gpr[3]),
_ => None,
}
}
fn ppc_draw_sprocket_trace_requested_state(action: &str, cpu: &PpcCpu) -> Option<String> {
if action != "context_set_state" {
return None;
}
Some(
ppc_dsp_context_state_from_raw(cpu.gpr[4])
.map(dsp_context_play_state_name)
.unwrap_or("invalid")
.to_string(),
)
}
fn ppc_qa_engine_gestalt(cpu: &mut PpcCpu, memory: &mut PpcSectionMem) -> u32 {
let engine = cpu.gpr[3];
let selector = cpu.gpr[4];
let response = cpu.gpr[5];
if engine != PPC_QA_ENGINE || response == 0 {
return ppc_i16_result(PPC_PARAM_ERR);
}
let response_size = if selector == 6 {
PPC_QA_ENGINE_NAME.len() as u32 + 1
} else {
4
};
if !ppc_memory_can_write_bytes(memory, response, response_size) {
return ppc_i16_result(PPC_PARAM_ERR);
}
let write_result = match selector {
0 => memory.write_u32_be(response, ppc_qa_optional_features()),
1 => memory.write_u32_be(response, ppc_qa_fast_features()),
2 => memory.write_u32_be(response, PPC_QA_VENDOR_APPLE),
3 => memory.write_u32_be(response, PPC_QA_ENGINE_APPLE_SW),
4 => memory.write_u32_be(response, 1),
5 => memory.write_u32_be(response, PPC_QA_ENGINE_NAME.len() as u32),
6 => ppc_write_c_string(memory, response, PPC_QA_ENGINE_NAME),
7 => memory.write_u32_be(response, PPC_QA_AVAILABLE_TEXTURE_MEMORY),
_ => memory.write_u32_be(response, 0),
};
if write_result.is_some() {
0
} else {
ppc_i16_result(PPC_PARAM_ERR)
}
}
fn ppc_qa_optional_features() -> u32 {
PPC_QA_OPTIONAL_TEXTURE | PPC_QA_OPTIONAL_TEXTURE_COLOR | PPC_QA_OPTIONAL_PERSPECTIVE_Z
}
fn ppc_qa_fast_features() -> u32 {
PPC_QA_FAST_LINE | PPC_QA_FAST_GOURAUD | PPC_QA_FAST_TEXTURE
}
fn ppc_write_c_string(memory: &mut PpcSectionMem, ptr: u32, bytes: &[u8]) -> Option<()> {
for (offset, byte) in bytes.iter().copied().enumerate() {
memory.write_u8(ptr + offset as u32, byte)?;
}
memory.write_u8(ptr + bytes.len() as u32, 0)?;
Some(())
}
fn ppc_isp_element_new_virtual_from_needs(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
input_sprocket: &mut PpcInputSprocketState,
virtual_elements: &mut Vec<PpcInputSprocketVirtualElementRecord>,
) -> i16 {
let count = cpu.gpr[3];
let needs_ptr = cpu.gpr[4];
let out_elements_ptr = cpu.gpr[5];
if (count > 0 && needs_ptr == 0) || out_elements_ptr == 0 {
return PPC_PARAM_ERR;
}
let Some(output_size) = count.checked_mul(4) else {
return PPC_PARAM_ERR;
};
if !ppc_memory_can_write_bytes(memory, out_elements_ptr, output_size) {
return PPC_PARAM_ERR;
}
let mut drafts = Vec::with_capacity(usize::try_from(count).unwrap_or(0));
for index in 0..count {
let Some(need_ptr) = index
.checked_mul(PPC_ISP_NEED_SIZE)
.and_then(|offset| needs_ptr.checked_add(offset))
else {
return PPC_PARAM_ERR;
};
let Some(need_record) = ppc_isp_read_need_record(memory, need_ptr) else {
return PPC_PARAM_ERR;
};
let Some(kind) = ppc_isp_need_record_kind(&need_record) else {
return PPC_PARAM_ERR;
};
let state = ppc_isp_default_simple_state(kind);
let need_name = ppc_isp_need_record_name(&need_record);
let action_binding = ppc_isp_action_binding(kind, Some(&need_name));
drafts.push(PpcInputSprocketVirtualElementDraft {
need_index: index,
need_source: need_ptr,
kind,
default_state: state,
action_binding,
need_name,
need_record,
});
}
if !ppc_heap_can_alloc_repeated(
memory,
*heap_cursor,
heap_limit,
PPC_ISP_VIRTUAL_ELEMENT_RECORD_SIZE,
count,
) {
return PPC_MEM_FULL_ERR;
}
let mut created_records = Vec::with_capacity(drafts.len());
for draft in drafts {
let element = ppc_process_heap_alloc(
process_memory_manager,
memory,
heap_cursor,
PPC_ISP_VIRTUAL_ELEMENT_RECORD_SIZE,
true,
);
if element == 0
|| memory.write_u32_be(element, draft.kind).is_none()
|| memory
.write_u32_be(element + 4, draft.default_state)
.is_none()
|| memory
.write_u32_be(
element + PPC_ISP_ELEMENT_NEED_INDEX_OFFSET,
draft.need_index,
)
.is_none()
|| memory
.write_u32_be(
element + PPC_ISP_ELEMENT_NEED_SOURCE_OFFSET,
draft.need_source,
)
.is_none()
|| !ppc_isp_write_need_record(
memory,
element + PPC_ISP_ELEMENT_NEED_RECORD_OFFSET,
&draft.need_record,
)
|| draft
.need_index
.checked_mul(4)
.and_then(|offset| out_elements_ptr.checked_add(offset))
.and_then(|slot| memory.write_u32_be(slot, element))
.is_none()
{
return PPC_MEM_FULL_ERR;
}
created_records.push(PpcInputSprocketVirtualElementRecord {
element,
need_index: draft.need_index,
need_source: draft.need_source,
kind: draft.kind,
default_state: draft.default_state,
action_binding: draft.action_binding,
need_name: draft.need_name,
need_record: draft.need_record,
});
}
input_sprocket.initialized = true;
input_sprocket.virtual_element_count =
input_sprocket.virtual_element_count.saturating_add(count);
input_sprocket.last_virtual_need_count = count;
input_sprocket.last_virtual_needs_ptr = needs_ptr;
input_sprocket.last_virtual_elements_out_ptr = out_elements_ptr;
virtual_elements.extend(created_records);
PPC_NO_ERR
}
fn ppc_isp_element_list_new(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
) -> i16 {
let count = cpu.gpr[3];
let elements_ptr = cpu.gpr[4];
let out_list_ptr = cpu.gpr[5];
let flags = cpu.gpr[6];
let Some(elements_size) = count.checked_mul(4) else {
return PPC_PARAM_ERR;
};
if count > PPC_ISP_ELEMENT_LIST_CAPACITY
|| out_list_ptr == 0
|| !ppc_memory_can_write_bytes(memory, out_list_ptr, 4)
|| (count > 0
&& (elements_ptr == 0
|| !ppc_memory_can_read_bytes(memory, elements_ptr, elements_size)))
{
return PPC_PARAM_ERR;
}
// Apple Game Sprockets Legacy Reference (2003), ISpElementList_New:
// the returned value is an opaque list reference initialized with the
// supplied elements. The host-private tail tracks each member's refCon
// and last state so event transitions can be delivered deterministically.
let _ = memory.write_u32_be(out_list_ptr, 0);
let list = ppc_process_heap_alloc(
process_memory_manager,
memory,
heap_cursor,
PPC_ISP_ELEMENT_LIST_RECORD_SIZE,
true,
);
if list == 0 {
return PPC_MEM_FULL_ERR;
}
if memory.write_u32_be(list, count).is_none()
|| memory.write_u32_be(list + 4, flags).is_none()
|| memory.write_u32_be(out_list_ptr, list).is_none()
{
return PPC_MEM_FULL_ERR;
}
for index in 0..count {
let Some(element) = memory.read_u32_be(elements_ptr + index * 4) else {
return PPC_PARAM_ERR;
};
if !ppc_isp_element_list_write_entry(
memory,
list,
index,
element,
0,
ppc_isp_virtual_element_default_state(element, virtual_elements),
) {
return PPC_MEM_FULL_ERR;
}
}
PPC_NO_ERR
}
fn ppc_isp_element_list_add_elements(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
) -> i16 {
let list = cpu.gpr[3];
let ref_con = cpu.gpr[4];
let count = cpu.gpr[5];
let elements_ptr = cpu.gpr[6];
let Some(elements_size) = count.checked_mul(4) else {
return PPC_PARAM_ERR;
};
if list == 0
|| !ppc_memory_can_write_bytes(memory, list, PPC_ISP_ELEMENT_LIST_RECORD_SIZE)
|| (count > 0
&& (elements_ptr == 0
|| !ppc_memory_can_read_bytes(memory, elements_ptr, elements_size)))
{
return PPC_PARAM_ERR;
}
let Some(existing_count) = memory.read_u32_be(list) else {
return PPC_PARAM_ERR;
};
let Some(new_count) = existing_count.checked_add(count) else {
return PPC_PARAM_ERR;
};
if new_count > PPC_ISP_ELEMENT_LIST_CAPACITY {
return PPC_PARAM_ERR;
}
for offset in 0..count {
let Some(element) = memory.read_u32_be(elements_ptr + offset * 4) else {
return PPC_PARAM_ERR;
};
if !ppc_isp_element_list_write_entry(
memory,
list,
existing_count + offset,
element,
ref_con,
ppc_isp_virtual_element_default_state(element, virtual_elements),
) {
return PPC_PARAM_ERR;
}
}
if memory.write_u32_be(list, new_count).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_isp_element_list_get_next_event(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
input: PpcInputSnapshot,
input_sprocket: PpcInputSprocketState,
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
tick_count: u32,
) -> i16 {
let list = cpu.gpr[3];
let buffer_size = cpu.gpr[4];
let event_ptr = cpu.gpr[5];
let was_event_ptr = cpu.gpr[6];
if list == 0
|| !ppc_memory_can_read_bytes(memory, list, PPC_ISP_ELEMENT_LIST_RECORD_SIZE)
|| was_event_ptr == 0
|| !ppc_memory_can_write_bytes(memory, was_event_ptr, 1)
|| (buffer_size > 0
&& (event_ptr == 0 || !ppc_memory_can_write_bytes(memory, event_ptr, buffer_size)))
{
return PPC_PARAM_ERR;
}
// Apple Game Sprockets Legacy Reference (2003),
// ISpElementList_GetNextEvent: events contain AbsoluteTime, element,
// refCon, and data. Button data is 1 on press and 0 on release.
let count = memory
.read_u32_be(list)
.unwrap_or(0)
.min(PPC_ISP_ELEMENT_LIST_CAPACITY);
for index in 0..count {
let Some((element, ref_con, previous_state)) =
ppc_isp_element_list_read_entry(memory, list, index)
else {
return PPC_PARAM_ERR;
};
let Some(current_state) = ppc_isp_virtual_element_simple_state(
element,
input,
input_sprocket,
virtual_elements,
) else {
continue;
};
if current_state == previous_state {
continue;
}
let event = [
0u32,
tick_count,
element,
ref_con,
current_state,
];
let copy_size = buffer_size.min(PPC_ISP_ELEMENT_EVENT_SIZE);
for offset in 0..copy_size {
let word = event[(offset / 4) as usize];
let shift = 24 - (offset % 4) * 8;
if memory
.write_u8(event_ptr + offset, ((word >> shift) & 0xff) as u8)
.is_none()
{
return PPC_PARAM_ERR;
}
}
if memory
.write_u32_be(
ppc_isp_element_list_entry_address(list, index) + 8,
current_state,
)
.is_none()
|| memory.write_u8(was_event_ptr, 1).is_none()
{
return PPC_PARAM_ERR;
}
return if buffer_size < PPC_ISP_ELEMENT_EVENT_SIZE {
PPC_PARAM_ERR
} else {
PPC_NO_ERR
};
}
if memory.write_u8(was_event_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_isp_element_list_flush(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
input: PpcInputSnapshot,
input_sprocket: PpcInputSprocketState,
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
) -> i16 {
let list = cpu.gpr[3];
if list == 0 || !ppc_memory_can_write_bytes(memory, list, PPC_ISP_ELEMENT_LIST_RECORD_SIZE) {
return PPC_PARAM_ERR;
}
let count = memory
.read_u32_be(list)
.unwrap_or(0)
.min(PPC_ISP_ELEMENT_LIST_CAPACITY);
for index in 0..count {
let Some((element, _, _)) = ppc_isp_element_list_read_entry(memory, list, index) else {
return PPC_PARAM_ERR;
};
let Some(state) = ppc_isp_virtual_element_simple_state(
element,
input,
input_sprocket,
virtual_elements,
) else {
continue;
};
if memory
.write_u32_be(ppc_isp_element_list_entry_address(list, index) + 8, state)
.is_none()
{
return PPC_PARAM_ERR;
}
}
PPC_NO_ERR
}
fn ppc_isp_element_list_entry_address(list: u32, index: u32) -> u32 {
list + PPC_ISP_ELEMENT_LIST_HEADER_SIZE + index * PPC_ISP_ELEMENT_LIST_ENTRY_SIZE
}
fn ppc_isp_element_list_write_entry(
memory: &mut PpcSectionMem,
list: u32,
index: u32,
element: u32,
ref_con: u32,
state: u32,
) -> bool {
let entry = ppc_isp_element_list_entry_address(list, index);
memory.write_u32_be(entry, element).is_some()
&& memory.write_u32_be(entry + 4, ref_con).is_some()
&& memory.write_u32_be(entry + 8, state).is_some()
}
fn ppc_isp_element_list_read_entry(
memory: &mut PpcSectionMem,
list: u32,
index: u32,
) -> Option<(u32, u32, u32)> {
let entry = ppc_isp_element_list_entry_address(list, index);
Some((
memory.read_u32_be(entry)?,
memory.read_u32_be(entry + 4)?,
memory.read_u32_be(entry + 8)?,
))
}
fn ppc_isp_virtual_element_default_state(
element: u32,
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
) -> u32 {
virtual_elements
.iter()
.find(|record| record.element == element)
.map_or(0, |record| record.default_state)
}
fn ppc_isp_virtual_element_simple_state(
element: u32,
input: PpcInputSnapshot,
input_sprocket: PpcInputSprocketState,
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
) -> Option<u32> {
let record = virtual_elements
.iter()
.find(|record| record.element == element)?;
Some(ppc_isp_input_simple_state(
record.kind,
record.default_state,
input,
input_sprocket,
record.action_binding,
))
}
fn ppc_isp_read_need_record(memory: &mut PpcSectionMem, need_ptr: u32) -> Option<Vec<u8>> {
let mut record = Vec::with_capacity(usize::try_from(PPC_ISP_NEED_SIZE).ok()?);
for offset in 0..PPC_ISP_NEED_SIZE {
record.push(memory.read_u8(need_ptr.checked_add(offset)?)?);
}
Some(record)
}
fn ppc_isp_write_need_record(
memory: &mut PpcSectionMem,
element_need_ptr: u32,
need_record: &[u8],
) -> bool {
for (offset, byte) in need_record.iter().copied().enumerate() {
let Ok(offset) = u32::try_from(offset) else {
return false;
};
let Some(addr) = element_need_ptr.checked_add(offset) else {
return false;
};
if memory.write_u8(addr, byte).is_none() {
return false;
};
}
true
}
fn ppc_isp_need_record_kind(need_record: &[u8]) -> Option<u32> {
let offset = usize::try_from(PPC_ISP_NEED_KIND_OFFSET).ok()?;
let bytes: [u8; 4] = need_record.get(offset..offset + 4)?.try_into().ok()?;
Some(u32::from_be_bytes(bytes))
}
fn ppc_isp_need_record_name(need_record: &[u8]) -> String {
let len = usize::from(need_record.first().copied().unwrap_or(0))
.min(63)
.min(need_record.len().saturating_sub(1));
decode_mac_roman(&need_record[1..1 + len])
}
fn ppc_isp_default_simple_state(kind: u32) -> u32 {
match kind {
PPC_ISP_ELEMENT_KIND_AXIS => PPC_ISP_AXIS_MIDDLE,
PPC_ISP_ELEMENT_KIND_BUTTON | PPC_ISP_ELEMENT_KIND_DPAD | PPC_ISP_ELEMENT_KIND_DELTA => 0,
_ => 0,
}
}
fn ppc_isp_action_binding(kind: u32, need_name: Option<&str>) -> PpcInputSprocketActionBinding {
match kind {
PPC_ISP_ELEMENT_KIND_AXIS => {
if ppc_isp_need_name_matches(need_name, &["pitch", "look"]) {
PpcInputSprocketActionBinding::AxisPitch
} else if ppc_isp_need_name_matches(need_name, &["yaw", "turn"]) {
PpcInputSprocketActionBinding::AxisYaw
} else if ppc_isp_need_name_matches(need_name, &["walk", "horizontal"]) {
PpcInputSprocketActionBinding::AxisHorizontal
} else if ppc_isp_need_name_matches(need_name, &["climb", "vertical"]) {
PpcInputSprocketActionBinding::AxisVertical
} else {
PpcInputSprocketActionBinding::AxisDirectional
}
}
PPC_ISP_ELEMENT_KIND_BUTTON => {
if ppc_isp_need_name_matches_all(need_name, &["swivel", "left"])
|| ppc_isp_need_name_matches_all(need_name, &["camera", "left"])
{
PpcInputSprocketActionBinding::ButtonCameraLeft
} else if ppc_isp_need_name_matches_all(need_name, &["swivel", "right"])
|| ppc_isp_need_name_matches_all(need_name, &["camera", "right"])
{
PpcInputSprocketActionBinding::ButtonCameraRight
} else if ppc_isp_need_name_matches(need_name, &["jump"]) {
PpcInputSprocketActionBinding::ButtonJump
} else if ppc_isp_need_name_matches(need_name, &["fire", "attack"]) {
PpcInputSprocketActionBinding::ButtonFire
} else if ppc_isp_need_name_matches_all(need_name, &["select", "weapon"])
|| ppc_isp_need_name_matches_all(need_name, &["next", "weapon"])
{
PpcInputSprocketActionBinding::ButtonWeapon
} else if ppc_isp_need_name_matches(need_name, &["pickup", "pick up", "throw"]) {
PpcInputSprocketActionBinding::ButtonPickup
} else if ppc_isp_need_name_matches_all(need_name, &["jet", "up"]) {
PpcInputSprocketActionBinding::ButtonJetUp
} else if ppc_isp_need_name_matches_all(need_name, &["jet", "down"]) {
PpcInputSprocketActionBinding::ButtonJetDown
} else if ppc_isp_need_name_matches(need_name, &["pause", "escape"]) {
PpcInputSprocketActionBinding::ButtonPause
} else if ppc_isp_need_name_matches(need_name, &["return", "enter", "confirm"]) {
PpcInputSprocketActionBinding::ButtonConfirm
} else if ppc_isp_need_name_matches_all(need_name, &["zoom", "in"]) {
PpcInputSprocketActionBinding::ButtonZoomIn
} else if ppc_isp_need_name_matches_all(need_name, &["zoom", "out"]) {
PpcInputSprocketActionBinding::ButtonZoomOut
} else if ppc_isp_need_name_matches_all(need_name, &["camera", "mode"]) {
PpcInputSprocketActionBinding::ButtonCameraMode
} else if ppc_isp_need_name_matches_all(need_name, &["toggle", "music"])
|| ppc_isp_need_name_matches_all(need_name, &["music", "on"])
{
PpcInputSprocketActionBinding::ButtonToggleMusic
} else if ppc_isp_need_name_matches_all(need_name, &["ambient", "sound"]) {
PpcInputSprocketActionBinding::ButtonToggleAmbientSound
} else if ppc_isp_need_name_matches_all(need_name, &["raise", "volume"])
|| ppc_isp_need_name_matches_all(need_name, &["volume", "up"])
{
PpcInputSprocketActionBinding::ButtonVolumeUp
} else if ppc_isp_need_name_matches_all(need_name, &["lower", "volume"])
|| ppc_isp_need_name_matches_all(need_name, &["volume", "down"])
{
PpcInputSprocketActionBinding::ButtonVolumeDown
} else if ppc_isp_need_name_matches(need_name, &["gps"]) {
PpcInputSprocketActionBinding::ButtonToggleGps
} else if ppc_isp_need_name_matches_all(need_name, &["quit", "application"]) {
PpcInputSprocketActionBinding::ButtonQuit
} else if ppc_isp_need_name_matches(need_name, &["left"]) {
PpcInputSprocketActionBinding::ButtonLeft
} else if ppc_isp_need_name_matches(need_name, &["right"]) {
PpcInputSprocketActionBinding::ButtonRight
} else if ppc_isp_need_name_matches(need_name, &["forward", "up"]) {
PpcInputSprocketActionBinding::ButtonForward
} else if ppc_isp_need_name_matches(need_name, &["backward", "down"]) {
PpcInputSprocketActionBinding::ButtonBackward
} else {
PpcInputSprocketActionBinding::ButtonPrimary
}
}
PPC_ISP_ELEMENT_KIND_DPAD => PpcInputSprocketActionBinding::DpadDirectional,
PPC_ISP_ELEMENT_KIND_DELTA => {
if ppc_isp_need_name_matches(need_name, &["pitch", "look"]) {
PpcInputSprocketActionBinding::DeltaPitch
} else {
PpcInputSprocketActionBinding::DeltaYaw
}
}
_ => PpcInputSprocketActionBinding::Unknown,
}
}
fn ppc_isp_input_simple_state(
kind: u32,
fallback_state: u32,
input: PpcInputSnapshot,
input_sprocket: PpcInputSprocketState,
action_binding: PpcInputSprocketActionBinding,
) -> u32 {
if input_sprocket.suspended {
return fallback_state;
}
match kind {
PPC_ISP_ELEMENT_KIND_AXIS => {
if !input_sprocket.keyboard_active {
return fallback_state;
}
let (low_keys, high_keys): (&[u8], &[u8]) = if matches!(
action_binding,
PpcInputSprocketActionBinding::AxisYaw
| PpcInputSprocketActionBinding::AxisHorizontal
) {
(
&[PPC_KEY_LEFT, PPC_KEY_NUMPAD_LEFT],
&[PPC_KEY_RIGHT, PPC_KEY_NUMPAD_RIGHT],
)
} else if matches!(
action_binding,
PpcInputSprocketActionBinding::AxisPitch
| PpcInputSprocketActionBinding::AxisVertical
) {
(
&[PPC_KEY_UP, PPC_KEY_NUMPAD_UP],
&[PPC_KEY_DOWN, PPC_KEY_NUMPAD_DOWN],
)
} else {
(
&[
PPC_KEY_LEFT,
PPC_KEY_NUMPAD_LEFT,
PPC_KEY_UP,
PPC_KEY_NUMPAD_UP,
],
&[
PPC_KEY_RIGHT,
PPC_KEY_NUMPAD_RIGHT,
PPC_KEY_DOWN,
PPC_KEY_NUMPAD_DOWN,
],
)
};
let low = input.any_key_down(low_keys);
let high = input.any_key_down(high_keys);
match (low, high) {
(true, false) => PPC_ISP_AXIS_LOW,
(false, true) => PPC_ISP_AXIS_HIGH,
(false, false) => fallback_state,
(true, true) => PPC_ISP_AXIS_MIDDLE,
}
}
PPC_ISP_ELEMENT_KIND_BUTTON => {
let pressed = ppc_isp_button_pressed(input, input_sprocket, action_binding);
if pressed {
PPC_ISP_BUTTON_PRESSED
} else {
fallback_state
}
}
PPC_ISP_ELEMENT_KIND_DPAD => {
if !input_sprocket.keyboard_active {
return fallback_state;
}
let mut state = 0;
if input.any_key_down(&[PPC_KEY_UP, PPC_KEY_NUMPAD_UP]) {
state |= PPC_ISP_DPAD_UP;
}
if input.any_key_down(&[PPC_KEY_RIGHT, PPC_KEY_NUMPAD_RIGHT]) {
state |= PPC_ISP_DPAD_RIGHT;
}
if input.any_key_down(&[PPC_KEY_DOWN, PPC_KEY_NUMPAD_DOWN]) {
state |= PPC_ISP_DPAD_DOWN;
}
if input.any_key_down(&[PPC_KEY_LEFT, PPC_KEY_NUMPAD_LEFT]) {
state |= PPC_ISP_DPAD_LEFT;
}
if state == 0 {
fallback_state
} else {
state
}
}
PPC_ISP_ELEMENT_KIND_DELTA => {
if !input_sprocket.mouse_active {
return fallback_state;
}
ppc_isp_mouse_delta_fixed(input, action_binding) as u32
}
_ => fallback_state,
}
}
fn ppc_isp_mouse_delta_fixed(
input: PpcInputSnapshot,
action_binding: PpcInputSprocketActionBinding,
) -> i32 {
let center_h = (PPC_MAIN_SCREEN_WIDTH / 2) as i32;
let center_v = (PPC_MAIN_SCREEN_HEIGHT / 2) as i32;
let pixel_delta = if action_binding == PpcInputSprocketActionBinding::DeltaPitch {
center_v.saturating_sub(i32::from(input.mouse_v))
} else {
i32::from(input.mouse_h).saturating_sub(center_h)
};
pixel_delta.saturating_mul(0x0001_0000)
}
fn ppc_isp_button_pressed(
input: PpcInputSnapshot,
input_sprocket: PpcInputSprocketState,
action_binding: PpcInputSprocketActionBinding,
) -> bool {
match action_binding {
PpcInputSprocketActionBinding::ButtonLeft => {
input_sprocket.keyboard_active
&& input.any_key_down(&[PPC_KEY_LEFT, PPC_KEY_NUMPAD_LEFT])
}
PpcInputSprocketActionBinding::ButtonRight => {
input_sprocket.keyboard_active
&& input.any_key_down(&[PPC_KEY_RIGHT, PPC_KEY_NUMPAD_RIGHT])
}
PpcInputSprocketActionBinding::ButtonForward => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_UP, PPC_KEY_NUMPAD_UP])
}
PpcInputSprocketActionBinding::ButtonBackward => {
input_sprocket.keyboard_active
&& input.any_key_down(&[PPC_KEY_DOWN, PPC_KEY_NUMPAD_DOWN])
}
PpcInputSprocketActionBinding::ButtonCameraLeft => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_COMMA])
}
PpcInputSprocketActionBinding::ButtonCameraRight => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_PERIOD])
}
PpcInputSprocketActionBinding::ButtonJump => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_COMMAND])
}
PpcInputSprocketActionBinding::ButtonFire => {
(input_sprocket.mouse_active && input.mouse_button)
|| (input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_SPACE]))
}
PpcInputSprocketActionBinding::ButtonWeapon => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_SHIFT])
}
PpcInputSprocketActionBinding::ButtonPickup => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_OPTION])
}
PpcInputSprocketActionBinding::ButtonJetUp => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_A])
}
PpcInputSprocketActionBinding::ButtonJetDown => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_Z])
}
PpcInputSprocketActionBinding::ButtonPause => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_ESCAPE])
}
PpcInputSprocketActionBinding::ButtonZoomIn => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_1])
}
PpcInputSprocketActionBinding::ButtonZoomOut => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_2])
}
PpcInputSprocketActionBinding::ButtonCameraMode => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_TAB])
}
PpcInputSprocketActionBinding::ButtonToggleMusic => {
input_sprocket.keyboard_active
&& input.any_key_down(&[PPC_KEY_CONTROL, PPC_KEY_CONTROL_RIGHT])
&& input.key_down(PPC_KEY_M)
}
PpcInputSprocketActionBinding::ButtonToggleAmbientSound => {
input_sprocket.keyboard_active
&& input.any_key_down(&[PPC_KEY_CONTROL, PPC_KEY_CONTROL_RIGHT])
&& input.key_down(PPC_KEY_B)
}
PpcInputSprocketActionBinding::ButtonVolumeUp => {
input_sprocket.keyboard_active
&& input.any_key_down(&[PPC_KEY_EQUAL, PPC_KEY_NUMPAD_ADD])
}
PpcInputSprocketActionBinding::ButtonVolumeDown => {
input_sprocket.keyboard_active
&& input.any_key_down(&[PPC_KEY_MINUS, PPC_KEY_NUMPAD_SUBTRACT])
}
PpcInputSprocketActionBinding::ButtonToggleGps => {
input_sprocket.keyboard_active && input.any_key_down(&[PPC_KEY_G])
}
PpcInputSprocketActionBinding::ButtonQuit => {
input_sprocket.keyboard_active
&& input.key_down(PPC_KEY_COMMAND)
&& input.key_down(PPC_KEY_Q)
}
PpcInputSprocketActionBinding::ButtonConfirm => {
input_sprocket.keyboard_active
&& input.any_key_down(&[PPC_KEY_RETURN, PPC_KEY_NUMPAD_ENTER])
}
_ => {
(input_sprocket.mouse_active && input.mouse_button)
|| (input_sprocket.keyboard_active
&& input.any_key_down(&[PPC_KEY_SPACE, PPC_KEY_RETURN, PPC_KEY_NUMPAD_ENTER]))
}
}
}
fn ppc_isp_need_name_matches(need_name: Option<&str>, patterns: &[&str]) -> bool {
let Some(need_name) = need_name else {
return false;
};
let name = need_name.to_ascii_lowercase();
patterns.iter().any(|pattern| name.contains(pattern))
}
fn ppc_isp_need_name_matches_all(need_name: Option<&str>, patterns: &[&str]) -> bool {
let Some(need_name) = need_name else {
return false;
};
let name = need_name.to_ascii_lowercase();
patterns.iter().all(|pattern| name.contains(pattern))
}
fn ppc_isp_init(input_sprocket: &mut PpcInputSprocketState) -> i16 {
input_sprocket.initialized = true;
input_sprocket.suspended = false;
input_sprocket.keyboard_active = true;
input_sprocket.mouse_active = true;
PPC_NO_ERR
}
fn ppc_isp_stop(input_sprocket: &mut PpcInputSprocketState) -> i16 {
input_sprocket.initialized = false;
input_sprocket.suspended = false;
input_sprocket.keyboard_active = false;
input_sprocket.mouse_active = false;
PPC_NO_ERR
}
fn ppc_isp_suspend(input_sprocket: &mut PpcInputSprocketState) -> i16 {
input_sprocket.suspended = true;
PPC_NO_ERR
}
fn ppc_isp_resume(input_sprocket: &mut PpcInputSprocketState) -> i16 {
input_sprocket.initialized = true;
input_sprocket.suspended = false;
PPC_NO_ERR
}
fn ppc_isp_configure(input_sprocket: &mut PpcInputSprocketState) -> i16 {
input_sprocket.initialized = true;
input_sprocket.configure_count = input_sprocket.configure_count.saturating_add(1);
PPC_NO_ERR
}
fn ppc_isp_devices_activate(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
input_sprocket: &mut PpcInputSprocketState,
) -> i16 {
ppc_isp_devices_set_active(cpu, memory, input_sprocket, true)
}
fn ppc_isp_devices_deactivate(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
input_sprocket: &mut PpcInputSprocketState,
) -> i16 {
ppc_isp_devices_set_active(cpu, memory, input_sprocket, false)
}
fn ppc_isp_devices_set_active(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
input_sprocket: &mut PpcInputSprocketState,
active: bool,
) -> i16 {
let Some(devices) = ppc_isp_device_arguments(cpu, memory) else {
return PPC_PARAM_ERR;
};
if devices.iter().any(|device| !ppc_isp_known_device(*device)) {
return PPC_PARAM_ERR;
}
input_sprocket.initialized = true;
for device in devices {
ppc_isp_set_device_active(input_sprocket, device, active);
}
PPC_NO_ERR
}
fn ppc_isp_device_arguments(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> Option<Vec<u32>> {
let first = cpu.gpr[3];
let second = cpu.gpr[4];
if ppc_isp_known_device(first) {
return Some(vec![first]);
}
if first == 0 {
return Some(Vec::new());
}
if first <= PPC_ISP_DEVICE_COUNT {
return ppc_isp_read_device_list(memory, second, first);
}
if second <= PPC_ISP_DEVICE_COUNT {
return ppc_isp_read_device_list(memory, first, second);
}
None
}
fn ppc_isp_read_device_list(
memory: &mut PpcSectionMem,
devices_ptr: u32,
count: u32,
) -> Option<Vec<u32>> {
if count == 0 {
return Some(Vec::new());
}
if devices_ptr == 0 {
return None;
}
let mut devices = Vec::with_capacity(usize::try_from(count).ok()?);
for index in 0..count {
devices.push(memory.read_u32_be(devices_ptr.checked_add(index.checked_mul(4)?)?)?);
}
Some(devices)
}
fn ppc_isp_known_device(device: u32) -> bool {
matches!(device, PPC_ISP_KEYBOARD_DEVICE | PPC_ISP_MOUSE_DEVICE)
}
fn ppc_isp_set_device_active(
input_sprocket: &mut PpcInputSprocketState,
device: u32,
active: bool,
) -> bool {
match device {
PPC_ISP_KEYBOARD_DEVICE => {
input_sprocket.keyboard_active = active;
true
}
PPC_ISP_MOUSE_DEVICE => {
input_sprocket.mouse_active = active;
true
}
_ => false,
}
}
fn ppc_isp_device_get_definition(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let device = cpu.gpr[3];
let buffer_len = cpu.gpr[4];
let definition_ptr = cpu.gpr[5];
let (name, device_class, permanent_id) = match device {
PPC_ISP_KEYBOARD_DEVICE => (b"Keyboard".as_slice(), PPC_ISP_DEVICE_CLASS_KEYBOARD, 1),
PPC_ISP_MOUSE_DEVICE => (b"Mouse".as_slice(), PPC_ISP_DEVICE_CLASS_MOUSE, 2),
_ => return PPC_PARAM_ERR,
};
if buffer_len < PPC_ISP_DEVICE_DEFINITION_SIZE
|| definition_ptr == 0
|| !ppc_memory_can_write_bytes(memory, definition_ptr, PPC_ISP_DEVICE_DEFINITION_SIZE)
{
return PPC_PARAM_ERR;
}
// Apple InputSprocket.h 1.7 (QuickTime 6.0.2 SDK),
// ISpDevice_GetDefinition: the caller supplies sizeof(ISpDeviceDefinition)
// (92 bytes), beginning with Str63 and followed by seven UInt32 fields.
for offset in 0..PPC_ISP_DEVICE_DEFINITION_SIZE {
if memory.write_u8(definition_ptr + offset, 0).is_none() {
return PPC_PARAM_ERR;
}
}
if memory.write_u8(definition_ptr, name.len() as u8).is_none() {
return PPC_PARAM_ERR;
}
for (offset, byte) in name.iter().copied().enumerate() {
if memory
.write_u8(definition_ptr + 1 + offset as u32, byte)
.is_none()
{
return PPC_PARAM_ERR;
}
}
if memory
.write_u32_be(definition_ptr + 64, device_class)
.is_none()
|| memory
.write_u32_be(definition_ptr + 68, device_class)
.is_none()
|| memory
.write_u32_be(definition_ptr + 72, permanent_id)
.is_none()
{
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_isp_device_get_element_list(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let device = cpu.gpr[3];
let out_element_list_ptr = cpu.gpr[4];
if !ppc_isp_known_device(device)
|| out_element_list_ptr == 0
|| !ppc_memory_can_write_bytes(memory, out_element_list_ptr, 4)
{
return PPC_PARAM_ERR;
}
// InputSprocket element-list references are opaque. Keep the synthetic
// device reference as the corresponding list identity so later list APIs
// can distinguish the keyboard and mouse without exposing guest memory.
memory
.write_u32_be(out_element_list_ptr, device)
.expect("element-list output pointer was prevalidated");
PPC_NO_ERR
}
fn ppc_isp_element_list_extract(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let element_list = cpu.gpr[3];
let buffer_count = cpu.gpr[4];
let out_count_ptr = cpu.gpr[5];
let buffer_ptr = cpu.gpr[6];
let elements: &[u32] = match element_list {
PPC_ISP_KEYBOARD_DEVICE => &[PPC_ISP_KEYBOARD_ELEMENT],
PPC_ISP_MOUSE_DEVICE => &[
PPC_ISP_MOUSE_X_ELEMENT,
PPC_ISP_MOUSE_Y_ELEMENT,
PPC_ISP_MOUSE_BUTTON_ELEMENT,
],
_ => return PPC_PARAM_ERR,
};
if out_count_ptr == 0
|| !ppc_memory_can_write_bytes(memory, out_count_ptr, 4)
|| (buffer_count > 0 && buffer_ptr == 0)
{
return PPC_PARAM_ERR;
}
let copy_count = buffer_count.min(elements.len() as u32);
let Some(output_size) = copy_count.checked_mul(4) else {
return PPC_PARAM_ERR;
};
if copy_count > 0 && !ppc_memory_can_write_bytes(memory, buffer_ptr, output_size) {
return PPC_PARAM_ERR;
}
memory
.write_u32_be(out_count_ptr, elements.len() as u32)
.expect("element-list count pointer was prevalidated");
for (index, element) in elements
.iter()
.copied()
.take(copy_count as usize)
.enumerate()
{
memory
.write_u32_be(buffer_ptr + index as u32 * 4, element)
.expect("element-list buffer was prevalidated");
}
PPC_NO_ERR
}
fn ppc_isp_element_get_info(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let element = cpu.gpr[3];
let info_ptr = cpu.gpr[4];
let (label, kind, name) = match element {
PPC_ISP_KEYBOARD_ELEMENT => (
PPC_ISP_ELEMENT_LABEL_NONE,
PPC_ISP_ELEMENT_KIND_BUTTON,
b"Keyboard Key".as_slice(),
),
PPC_ISP_MOUSE_X_ELEMENT => (
PPC_ISP_ELEMENT_LABEL_CURSOR_X,
PPC_ISP_ELEMENT_KIND_DELTA,
b"Mouse X Delta".as_slice(),
),
PPC_ISP_MOUSE_Y_ELEMENT => (
PPC_ISP_ELEMENT_LABEL_CURSOR_Y,
PPC_ISP_ELEMENT_KIND_DELTA,
b"Mouse Y Delta".as_slice(),
),
PPC_ISP_MOUSE_BUTTON_ELEMENT => (
PPC_ISP_ELEMENT_LABEL_MOUSE_ONE,
PPC_ISP_ELEMENT_KIND_BUTTON,
b"Mouse Button".as_slice(),
),
_ => return PPC_PARAM_ERR,
};
if info_ptr == 0 || !ppc_memory_can_write_bytes(memory, info_ptr, PPC_ISP_ELEMENT_INFO_SIZE) {
return PPC_PARAM_ERR;
}
// ISpElementInfo is two OSTypes, a Str63, and two reserved UInt32s.
for offset in 0..PPC_ISP_ELEMENT_INFO_SIZE {
memory
.write_u8(info_ptr + offset, 0)
.expect("element info pointer was prevalidated");
}
memory.write_u32_be(info_ptr, label).unwrap();
memory.write_u32_be(info_ptr + 4, kind).unwrap();
memory.write_u8(info_ptr + 8, name.len() as u8).unwrap();
for (offset, byte) in name.iter().copied().enumerate() {
memory.write_u8(info_ptr + 9 + offset as u32, byte).unwrap();
}
PPC_NO_ERR
}
fn ppc_isp_devices_extract(cpu: &mut PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let buffer_count = cpu.gpr[3];
let out_count_ptr = cpu.gpr[4];
let buffer_ptr = cpu.gpr[5];
if out_count_ptr == 0 || (buffer_count > 0 && buffer_ptr == 0) {
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, out_count_ptr, 4) {
return PPC_PARAM_ERR;
}
let devices = [PPC_ISP_KEYBOARD_DEVICE, PPC_ISP_MOUSE_DEVICE];
let copy_count = buffer_count.min(PPC_ISP_DEVICE_COUNT);
let Some(output_size) = copy_count.checked_mul(4) else {
return PPC_PARAM_ERR;
};
if copy_count > 0 && !ppc_memory_can_write_bytes(memory, buffer_ptr, output_size) {
return PPC_PARAM_ERR;
}
memory
.write_u32_be(out_count_ptr, PPC_ISP_DEVICE_COUNT)
.unwrap();
let copy_count = usize::try_from(copy_count).unwrap();
for (index, device) in devices.iter().copied().take(copy_count).enumerate() {
if memory
.write_u32_be(buffer_ptr + (index as u32) * 4, device)
.is_none()
{
return PPC_PARAM_ERR;
}
}
PPC_NO_ERR
}
fn ppc_isp_devices_extract_by_class(cpu: &mut PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let device_class = cpu.gpr[3];
let buffer_count = cpu.gpr[4];
let out_count_ptr = cpu.gpr[5];
let buffer_ptr = cpu.gpr[6];
if out_count_ptr == 0 || (buffer_count > 0 && buffer_ptr == 0) {
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, out_count_ptr, 4) {
return PPC_PARAM_ERR;
}
let device = match device_class {
PPC_ISP_DEVICE_CLASS_KEYBOARD => Some(PPC_ISP_KEYBOARD_DEVICE),
PPC_ISP_DEVICE_CLASS_MOUSE => Some(PPC_ISP_MOUSE_DEVICE),
_ => None,
};
let device_count = u32::from(device.is_some());
let copy_count = buffer_count.min(device_count);
let Some(output_size) = copy_count.checked_mul(4) else {
return PPC_PARAM_ERR;
};
if copy_count > 0 && !ppc_memory_can_write_bytes(memory, buffer_ptr, output_size) {
return PPC_PARAM_ERR;
}
memory.write_u32_be(out_count_ptr, device_count).unwrap();
if copy_count > 0
&& memory
.write_u32_be(
buffer_ptr,
device.expect("device exists when copy count is nonzero"),
)
.is_none()
{
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_isp_element_get_simple_state(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
input: PpcInputSnapshot,
input_sprocket: PpcInputSprocketState,
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
) -> i16 {
let element = cpu.gpr[3];
let state_ptr = cpu.gpr[4];
if element == 0 || state_ptr == 0 {
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, state_ptr, 4) {
return PPC_PARAM_ERR;
}
let (Some(kind), Some(fallback_state)) =
(memory.read_u32_be(element), memory.read_u32_be(element + 4))
else {
return PPC_PARAM_ERR;
};
let need_name = ppc_isp_element_need_name(memory, element);
let action_binding = ppc_isp_element_action_binding(virtual_elements, element, kind)
.unwrap_or_else(|| ppc_isp_action_binding(kind, need_name.as_deref()));
let state =
ppc_isp_input_simple_state(kind, fallback_state, input, input_sprocket, action_binding);
if memory.write_u32_be(state_ptr, state).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_isp_simple_state_trace_entry(
import_index: u32,
pc: u32,
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
input: PpcInputSnapshot,
input_sprocket: PpcInputSprocketState,
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
) -> Option<PpcInputSprocketSimpleStateTraceEntry> {
let element = cpu.gpr[3];
let state_ptr = cpu.gpr[4];
let kind = memory.read_u32_be(element)?;
let fallback_state = memory.read_u32_be(element.checked_add(4)?)?;
let state = memory.read_u32_be(state_ptr)?;
let need_name = ppc_isp_element_need_name(memory, element).unwrap_or_default();
let action_binding = ppc_isp_element_action_binding(virtual_elements, element, kind)
.unwrap_or_else(|| ppc_isp_action_binding(kind, Some(&need_name)));
Some(PpcInputSprocketSimpleStateTraceEntry {
import_index,
pc,
element,
state_ptr,
state,
kind,
kind_name: isp_element_kind_name(kind).to_string(),
fallback_state,
need_name,
action_binding: isp_action_binding_name(action_binding).to_string(),
input,
input_sprocket,
})
}
fn ppc_isp_element_action_binding(
virtual_elements: &[PpcInputSprocketVirtualElementRecord],
element: u32,
kind: u32,
) -> Option<PpcInputSprocketActionBinding> {
virtual_elements
.iter()
.rev()
.find(|record| record.element == element && record.kind == kind)
.map(|record| record.action_binding)
}
fn ppc_isp_element_need_name(memory: &mut PpcSectionMem, element: u32) -> Option<String> {
let name_ptr = element.checked_add(PPC_ISP_ELEMENT_NEED_RECORD_OFFSET)?;
let len = usize::from(memory.read_u8(name_ptr)?).min(63);
let mut bytes = Vec::with_capacity(len);
for offset in 0..len {
bytes.push(memory.read_u8(name_ptr.checked_add(1 + offset as u32)?)?);
}
Some(decode_mac_roman(&bytes))
}
pub(super) fn ppc_rect_dimensions(top: i16, left: i16, bottom: i16, right: i16) -> (u32, u32) {
let width = i32::from(right).saturating_sub(i32::from(left)).max(1) as u32;
let height = i32::from(bottom).saturating_sub(i32::from(top)).max(1) as u32;
(width, height)
}
pub(super) fn ppc_row_bytes(width: u32, depth: u32) -> Option<u32> {
let visible_row_bytes = width.checked_mul(depth)?.div_ceil(8);
visible_row_bytes
.checked_div(16)?
.checked_add(1)?
.checked_mul(16)
}
pub(super) fn ppc_u32_to_i16_saturating(value: u32) -> i16 {
i16::try_from(value).unwrap_or(i16::MAX)
}
pub(super) fn ppc_i32_to_i16_saturating(value: i32) -> i16 {
i16::try_from(value).unwrap_or(if value < 0 { i16::MIN } else { i16::MAX })
}
fn ppc_draw_picture(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
vfs_resources: &[PpcVfsResourceRecord],
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
screen_clut: &[[u16; 3]; 256],
color_manager_clut: &mut [[u16; 3]; 256],
) -> bool {
let pic_handle = cpu.gpr[3];
let dst_rect_ptr = cpu.gpr[4];
if pic_handle == 0 || dst_rect_ptr == 0 {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] DrawPicture handle=${:08X} dstRect=${:08X} gworld=${:08X} depth=none drawn=false reason=missing-arg",
pic_handle, dst_rect_ptr, current_gworld
);
}
return false;
}
let Some(bytes) = ppc_handle_bytes(memory, handles, pic_handle) else {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] DrawPicture handle=${:08X} dstRect=${:08X} gworld=${:08X} depth=none drawn=false reason=missing-handle",
pic_handle, dst_rect_ptr, current_gworld
);
}
return false;
};
let Some(mut dst_rect) = ppc_read_rect(memory, dst_rect_ptr) else {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] DrawPicture handle=${:08X} dstRect=${:08X} gworld=${:08X} depth=none drawn=false reason=bad-rect",
pic_handle, dst_rect_ptr, current_gworld
);
}
return false;
};
let Some((_pict_offset, pict_bounds)) = ppc_qt_pict_record_offset_and_bounds(&bytes) else {
if ppc_hle_trace_enabled() {
let head = bytes
.iter()
.take(24)
.map(|byte| format!("{byte:02X}"))
.collect::<Vec<_>>()
.join("");
eprintln!(
"[PPC-TRACE] DrawPicture handle=${:08X} dstRect=${:08X} gworld=${:08X} depth=none drawn=false reason=bad-pict size={} head={}",
pic_handle,
dst_rect_ptr,
current_gworld,
bytes.len(),
head
);
}
return false;
};
if dst_rect == (0, 0, 0, 0) {
dst_rect = pict_bounds;
}
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] DrawPicture handle=${:08X} dstRect=${:08X} gworld=${:08X} depth=none drawn=false reason=missing-gworld",
pic_handle, dst_rect_ptr, current_gworld
);
}
return false;
};
let front_buffer = surface.front_buffer;
dst_rect = surface.local_rect_i16(dst_rect);
let draw_clut = ppc_live_gworld_clut(
memory,
gworlds,
current_gworld,
screen_clut,
color_manager_clut,
);
let device_ct_seed = surface
.ctable_handle
.and_then(|handle| memory.read_u32_be(handle))
.filter(|ctable| *ctable != 0)
.and_then(|ctable| memory.read_u32_be(ctable))
.unwrap_or(0);
let quilt_zero_is_opaque = ppc_quilt_picture_zero_is_opaque(vfs_resources, pic_handle);
let drawn = ppc_draw_pict_bytes_to_16bpp(
memory,
front_buffer,
&bytes,
dst_rect,
&draw_clut,
device_ct_seed,
quilt_zero_is_opaque,
);
if ppc_hle_trace_enabled() {
let (top, left, bottom, right) = dst_rect;
eprintln!(
"[PPC-TRACE] DrawPicture handle=${:08X} dstRect=${:08X} gworld=${:08X} depth={} rect=({}, {}, {}, {}) drawn={}",
pic_handle,
dst_rect_ptr,
current_gworld,
front_buffer.depth,
top,
left,
bottom,
right,
drawn
);
}
drawn
}
fn ppc_quilt_picture_zero_is_opaque(
vfs_resources: &[PpcVfsResourceRecord],
picture_handle: u32,
) -> bool {
let pict_type = u32::from_be_bytes(*b"PICT");
let img_type = u32::from_be_bytes(*b"#Img");
let Some(picture) = vfs_resources
.iter()
.find(|resource| resource.res_type == pict_type && resource.handle == picture_handle)
else {
return false;
};
vfs_resources.iter().any(|resource| {
// Quilt's #Img record distinguishes opaque-black frames (mode 3)
// from frames that retain pixel index 0 as a key for later sprite
// compositing. Converting every zero while loading destroys that key.
resource.res_type == img_type
&& resource.path.eq_ignore_ascii_case(&picture.path)
&& resource.data.get(10..12) == Some(&3u16.to_be_bytes())
})
}
fn ppc_kill_picture(
cpu: &mut PpcCpu,
allocator: &mut PpcProcessAllocatorView<'_>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) {
let pic_handle = cpu.gpr[3];
let _ = allocator.dispose_handle(
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
pic_handle,
);
}
fn ppc_dispose_tracked_handle(
handle: u32,
memory: &mut PpcSectionMem,
handles: &mut Vec<PpcHandleRecord>,
handle_states: &mut Vec<PpcHandleStateRecord>,
) -> bool {
if handle == 0 {
return false;
}
if let Some(index) = handles.iter().position(|record| record.handle == handle) {
let record = handles.remove(index);
let _ = memory.write_u32_be(record.handle, 0);
ppc_forget_handle_state(handle, handle_states);
true
} else {
false
}
}
pub(super) fn ppc_is_valid_handle(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
handle: u32,
) -> bool {
if handle == 0 {
return false;
}
if handles.iter().any(|record| record.handle == handle) {
return true;
}
let Some(ptr) = memory.read_u32_be(handle) else {
return false;
};
ptr != 0 && memory.read_u8(ptr).is_some()
}
fn ppc_forget_handle_state(handle: u32, handle_states: &mut Vec<PpcHandleStateRecord>) {
handle_states.retain(|record| record.handle != handle);
}
fn ppc_alloc_handle_with_bytes(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
bytes: &[u8],
) -> u32 {
let size = u32::try_from(bytes.len()).unwrap_or(u32::MAX);
let handle = ppc_alloc_handle(memory, heap_cursor, heap_limit, handles, size, false);
if handle == 0 {
return 0;
}
let Some(ptr) = memory.read_u32_be(handle) else {
return 0;
};
if memory.write_bytes(ptr, bytes).is_none() {
return 0;
}
handle
}
pub(super) fn ppc_copy_palette_resource(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
palette_id: i16,
) -> u32 {
let Some(index) = ppc_vfs_resource_index(
vfs_resources,
current_resource_refnum,
u32::from_be_bytes(*b"pltt"),
palette_id,
false,
) else {
return 0;
};
let resource = &vfs_resources[index].data;
let Some(entries) = resource
.get(..2)
.map(|bytes| u16::from_be_bytes([bytes[0], bytes[1]]))
else {
return 0;
};
let byte_count = 16usize.saturating_add(usize::from(entries).saturating_mul(16));
if resource.len() < byte_count {
return 0;
}
let handle = ppc_allocator_view_allocate_handle_with_bytes(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&resource[..byte_count],
);
if handle == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return 0;
}
if let Some(palette) = memory.read_u32_be(handle) {
// GetNewPalette initializes the private fields in the copied Palette
// record; only pmEntries and the ColorInfo array come from 'pltt'.
// Inside Macintosh Volume VI (1991), pp. 20-16, 20-19.
for offset in (2..16).step_by(2) {
let _ = memory.write_u16_be(palette + offset, 0);
}
for entry in 0..u32::from(entries) {
let private = palette + 16 + entry * 16 + 10;
let _ = memory.write_bytes(private, &[0; 6]);
}
}
*last_mem_error = PPC_NO_ERR;
handle
}
fn ppc_alloc_recyclable_handle_with_bytes(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
free_handle_blocks: &mut Vec<PpcHandleRecord>,
bytes: &[u8],
) -> u32 {
let size = u32::try_from(bytes.len()).unwrap_or(u32::MAX);
let handle = ppc_alloc_recyclable_handle(
memory,
heap_cursor,
heap_limit,
handles,
free_handle_blocks,
size,
false,
);
if handle == 0 {
return 0;
}
let Some(ptr) = memory.read_u32_be(handle) else {
return 0;
};
if memory.write_bytes(ptr, bytes).is_none() {
return 0;
}
handle
}
fn ppc_alloc_recyclable_handle(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
free_handle_blocks: &mut Vec<PpcHandleRecord>,
size: u32,
clear: bool,
) -> u32 {
let required = match ppc_allocation_size(size) {
Some(required) => required,
None => return 0,
};
let reusable_index = free_handle_blocks
.iter()
.enumerate()
.filter_map(|(index, record)| {
let capacity = ppc_allocation_size(record.capacity)?;
(capacity >= required).then_some((index, capacity))
})
.min_by_key(|(_, capacity)| *capacity)
.map(|(index, _)| index);
let handle = if let Some(index) = reusable_index {
let mut record = free_handle_blocks.swap_remove(index);
record.size = size;
if memory.write_u32_be(record.handle, record.ptr).is_none() {
return 0;
}
let handle = record.handle;
handles.push(record);
handle
} else {
ppc_alloc_handle(memory, heap_cursor, heap_limit, handles, size, clear)
};
if handle == 0 {
return 0;
}
if clear {
let Some(ptr) = memory.read_u32_be(handle) else {
return 0;
};
for offset in 0..required {
if memory.write_u8(ptr + offset, 0).is_none() {
return 0;
}
}
}
handle
}
fn ppc_alloc_handle(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
size: u32,
clear: bool,
) -> u32 {
if !ppc_heap_can_alloc_sequence(memory, *heap_cursor, heap_limit, &[4, size]) {
return 0;
}
let handle = ppc_heap_alloc(memory, heap_cursor, heap_limit, 4, true);
if handle == 0 {
return 0;
}
let ptr = ppc_heap_alloc(memory, heap_cursor, heap_limit, size, clear);
if ptr == 0 || memory.write_u32_be(handle, ptr).is_none() {
return 0;
}
handles.push(PpcHandleRecord {
handle,
ptr,
size,
capacity: size,
});
handle
}
fn ppc_set_handle_size(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut [PpcHandleRecord],
handle: u32,
size: u32,
) -> i16 {
let Some(record) = handles.iter_mut().find(|record| record.handle == handle) else {
return -109;
};
if size <= record.capacity {
record.size = size;
return PPC_NO_ERR;
}
let Some(old_aligned) = ppc_allocation_size(record.size) else {
return PPC_PARAM_ERR;
};
let Some(new_aligned) = ppc_allocation_size(size) else {
return PPC_MEM_FULL_ERR;
};
if let Some(old_end) = record.ptr.checked_add(old_aligned) {
if old_end == *heap_cursor {
if let Some((resize_ptr, new_end)) =
ppc_heap_allocation_bounds(memory, record.ptr, heap_limit, new_aligned)
{
if resize_ptr == record.ptr {
if new_end > old_end && memory.read_u8(old_end).is_none() {
let Ok(growth) = usize::try_from(new_end - old_end) else {
return PPC_MEM_FULL_ERR;
};
memory.add_region(old_end, vec![0; growth]);
}
for addr in old_end..new_end {
if memory.write_u8(addr, 0).is_none() {
return PPC_PARAM_ERR;
}
}
*heap_cursor = new_end;
record.size = size;
record.capacity = size;
return PPC_NO_ERR;
}
}
}
}
let new_ptr = ppc_heap_alloc(memory, heap_cursor, heap_limit, size, true);
if new_ptr == 0 {
return PPC_MEM_FULL_ERR;
}
let copy_len = record.size.min(size);
for offset in 0..copy_len {
let Some(byte) = memory.read_u8(record.ptr + offset) else {
return PPC_PARAM_ERR;
};
if memory.write_u8(new_ptr + offset, byte).is_none() {
return PPC_PARAM_ERR;
}
}
if memory.write_u32_be(handle, new_ptr).is_none() {
return PPC_PARAM_ERR;
}
record.ptr = new_ptr;
record.size = size;
record.capacity = size;
PPC_NO_ERR
}
fn ppc_handle_resize_allocation_size(
memory: &PpcSectionMem,
record: PpcHandleRecord,
heap_cursor: u32,
heap_limit: u32,
size: u32,
) -> Option<u32> {
if size <= record.capacity {
return Some(0);
}
let old_aligned = ppc_allocation_size(record.size)?;
let new_aligned = ppc_allocation_size(size)?;
if record.ptr.checked_add(old_aligned) == Some(heap_cursor)
&& ppc_heap_allocation_bounds(memory, record.ptr, heap_limit, new_aligned)
.is_some_and(|(new_ptr, _)| new_ptr == record.ptr)
{
new_aligned.checked_sub(old_aligned)
} else {
Some(new_aligned)
}
}
pub(super) fn ppc_get_resource(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
current_resource_refnum: i16,
current_only: bool,
load_data: bool,
last_resource_error: &mut i16,
) -> u32 {
let res_type = cpu.gpr[3];
let res_id = cpu.gpr[4] as u16 as i16;
let index = match ppc_vfs_resource_index(
vfs_resources,
current_resource_refnum,
res_type,
res_id,
current_only,
) {
Some(index) => index,
None => {
let system_string = (!current_only
&& res_type == u32::from_be_bytes(*b"STR "))
.then(|| crate::trap::TrapDispatcher::system_str_default_body(res_id))
.flatten();
if let Some(data) = system_string {
vfs_resources.push(PpcVfsResourceRecord {
ref_num: 0,
path: "__system__/STR ".to_string(),
res_type,
res_id,
name: Vec::new(),
data: data.to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
vfs_resources.len() - 1
} else {
// Classic Resource Manager lookups can return NIL without reporting
// an error. Mac OS 8 does so for missing IDs with both GetResource
// and Get1Resource; callers must test the returned handle.
*last_resource_error = PPC_NO_ERR;
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] {}Resource('{}', {}) current_ref={} -> NULL err={}",
if current_only { "Get1" } else { "Get" },
ppc_res_type_text(res_type),
res_id,
current_resource_refnum,
PPC_NO_ERR
);
}
return 0;
}
}
};
let handle = ppc_materialize_vfs_resource_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
index,
load_data,
last_resource_error,
);
if ppc_hle_trace_enabled() {
let record = &vfs_resources[index];
eprintln!(
"[PPC-TRACE] {}Resource('{}', {}) current_ref={} -> handle=${:08X} home_ref={} path=\"{}\" size={}",
if current_only { "Get1" } else { "Get" },
ppc_res_type_text(res_type),
res_id,
current_resource_refnum,
record.handle,
record.ref_num,
record.path,
record.data.len()
);
}
handle
}
pub(super) const PPC_ICON_SUITE_MAGIC: u32 = u32::from_be_bytes(*b"ISUT");
#[cfg(test)]
fn ppc_icon_suite_entries(memory: &mut PpcSectionMem, icon_suite: u32) -> Option<Vec<(u32, u32)>> {
let suite = memory.read_u32_be(icon_suite).filter(|ptr| *ptr != 0)?;
if memory.read_u32_be(suite)? != PPC_ICON_SUITE_MAGIC {
return None;
}
let count = usize::from(memory.read_u16_be(suite + 8)?).min(64);
let mut entries = Vec::with_capacity(count);
for index in 0..count {
let entry = suite.checked_add(10 + u32::try_from(index).ok()?.checked_mul(8)?)?;
entries.push((memory.read_u32_be(entry)?, memory.read_u32_be(entry + 4)?));
}
Some(entries)
}
fn ppc_resource_name_eq(left: &[u8], right: &[u8]) -> bool {
left.len() == right.len()
&& left.iter().zip(right).all(|(left, right)| {
if left.is_ascii() && right.is_ascii() {
left.eq_ignore_ascii_case(right)
} else {
left == right
}
})
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_get_named_resource(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut [PpcVfsResourceRecord],
current_resource_refnum: i16,
current_only: bool,
load_data: bool,
last_resource_error: &mut i16,
) -> u32 {
let res_type = cpu.gpr[3];
let Some(name) = ppc_read_pstring_bytes(memory, cpu.gpr[4]) else {
*last_resource_error = PPC_PARAM_ERR;
return 0;
};
let current_match = vfs_resources.iter().position(|record| {
record.ref_num == current_resource_refnum
&& record.res_type == res_type
&& ppc_resource_name_eq(&record.name, &name)
});
let index = if current_only || current_match.is_some() {
current_match
} else {
vfs_resources.iter().position(|record| {
record.ref_num != PPC_CLOSED_RESOURCE_REF_NUM
&& record.res_type == res_type
&& ppc_resource_name_eq(&record.name, &name)
})
};
let Some(index) = index else {
let type_exists = vfs_resources.iter().any(|record| {
record.res_type == res_type
&& if current_only {
record.ref_num == current_resource_refnum
} else {
record.ref_num != PPC_CLOSED_RESOURCE_REF_NUM
}
});
let current_map_is_empty = current_only
&& !vfs_resources
.iter()
.any(|record| record.ref_num == current_resource_refnum);
// More Macintosh Toolbox (1993), pp. 1-75--1-76: a missing name
// reports resNotFound, while an absent resource type in a populated
// map returns NIL with noErr. Mac OS 8.1 reports resNotFound for a
// newly created, wholly empty resource map; classic applications use
// that result to distinguish first-run initialization from failure.
*last_resource_error = if type_exists || current_map_is_empty {
PPC_RES_NOT_FOUND_ERR
} else {
PPC_NO_ERR
};
return 0;
};
let handle = ppc_materialize_vfs_resource_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
index,
load_data,
last_resource_error,
);
handle
}
pub(super) fn ppc_get_ind_resource(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut [PpcVfsResourceRecord],
current_resource_refnum: i16,
current_only: bool,
load_data: bool,
last_resource_error: &mut i16,
) -> u32 {
let res_type = cpu.gpr[3];
let requested_index = cpu.gpr[4] as u16 as usize;
if requested_index == 0 {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return 0;
}
let Some(index) = vfs_resources
.iter()
.enumerate()
.filter(|(_, record)| {
record.res_type == res_type
&& (!current_only || record.ref_num == current_resource_refnum)
})
.nth(requested_index - 1)
.map(|(index, _)| index)
else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Get{}IndResource('{}', {}) current_ref={} -> NULL err={}",
if current_only { "1" } else { "" },
ppc_res_type_text(res_type),
requested_index,
current_resource_refnum,
PPC_RES_NOT_FOUND_ERR
);
}
return 0;
};
let handle = ppc_materialize_vfs_resource_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
index,
load_data,
last_resource_error,
);
if ppc_hle_trace_enabled() {
let record = &vfs_resources[index];
eprintln!(
"[PPC-TRACE] Get{}IndResource('{}', {}) current_ref={} -> handle=${:08X} id={} home_ref={} path=\"{}\" size={}",
if current_only { "1" } else { "" },
ppc_res_type_text(res_type),
requested_index,
current_resource_refnum,
handle,
record.res_id,
record.ref_num,
record.path,
record.data.len()
);
}
handle
}
pub(super) fn ppc_get_ind_string(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut [PpcVfsResourceRecord],
current_resource_refnum: i16,
last_resource_error: &mut i16,
) {
let string_ptr = cpu.gpr[3];
let str_list_id = cpu.gpr[4] as u16 as i16;
let index = cpu.gpr[5] as u16 as usize;
let res_type = u32::from_be_bytes(*b"STR#");
let Some(resource_index) = ppc_vfs_resource_index(
vfs_resources,
current_resource_refnum,
res_type,
str_list_id,
false,
) else {
let _ = ppc_write_empty_pstring(memory, string_ptr);
return;
};
let handle = ppc_materialize_vfs_resource_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
resource_index,
true,
last_resource_error,
);
if handle == 0 {
let _ = ppc_write_empty_pstring(memory, string_ptr);
return;
}
let string = ppc_str_list_item(&vfs_resources[resource_index].data, index).unwrap_or_default();
if !ppc_optional_pstring_output_can_write(memory, string_ptr, &string) {
*last_resource_error = PPC_PARAM_ERR;
return;
}
let _ = ppc_write_pstring_bytes(memory, string_ptr, &string);
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_read_packed_bitmap_index(
memory: &mut PpcSectionMem,
base_addr: u32,
row_bytes: u32,
pixel_size: u16,
bounds: (i16, i16, i16, i16),
v: i16,
h: i16,
) -> Option<u8> {
let (top, left, bottom, right) = bounds;
if base_addr == 0 || v < top || v >= bottom || h < left || h >= right {
return None;
}
let y = u32::try_from(i32::from(v) - i32::from(top)).ok()?;
let x = u32::try_from(i32::from(h) - i32::from(left)).ok()?;
let row = base_addr.checked_add(y.checked_mul(row_bytes)?)?;
match pixel_size {
1 => {
let byte = memory.read_u8(row.checked_add(x / 8)?)?;
Some((byte >> (7 - (x & 7))) & 1)
}
2 => {
let byte = memory.read_u8(row.checked_add(x / 4)?)?;
Some((byte >> (6 - 2 * (x & 3))) & 3)
}
4 => {
let byte = memory.read_u8(row.checked_add(x / 2)?)?;
Some(if x & 1 == 0 { byte >> 4 } else { byte & 15 })
}
8 => memory.read_u8(row.checked_add(x)?),
_ => None,
}
}
pub(super) fn ppc_materialize_vfs_resource_handle(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
_heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut [PpcVfsResourceRecord],
index: usize,
load_data: bool,
last_resource_error: &mut i16,
) -> u32 {
if vfs_resources[index].handle == 0 {
// Inside Macintosh Volume I (1985), I-118 through I-120:
// SetResLoad(FALSE) still returns a resource Handle, but its master
// pointer remains NIL until LoadResource (or a later loading lookup).
let data = load_data.then(|| vfs_resources[index].data.clone());
let handle = process_memory_manager.new_native_resource_handle(memory, data.as_deref());
ppc_apply_process_native_resource_handle(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
handle,
);
if handle == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return 0;
}
vfs_resources[index].handle = handle;
} else if load_data && memory.read_u32_be(vfs_resources[index].handle) == Some(0) {
let data = vfs_resources[index].data.clone();
let handle = vfs_resources[index].handle;
if process_memory_manager.native_allocation(handle).is_some() {
let result = process_memory_manager.load_native_resource_handle(memory, handle, &data);
ppc_apply_process_native_resource_handle(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
handle,
);
if result != PPC_NO_ERR {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return 0;
}
} else {
// Some callers publish a stable master pointer in an ordinary PEF
// mapping. Keep that mapping authoritative while allocating its
// resource data from the shared process heap.
let size = u32::try_from(data.len()).unwrap_or(u32::MAX);
let ptr =
ppc_process_heap_alloc(process_memory_manager, memory, heap_cursor, size, false);
if ptr == 0
|| data
.iter()
.copied()
.enumerate()
.any(|(offset, byte)| memory.write_u8(ptr + offset as u32, byte).is_none())
|| memory.write_u32_be(handle, ptr).is_none()
{
*last_mem_error = PPC_MEM_FULL_ERR;
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return 0;
}
process_memory_manager.publish_external_native_resource_handle(
handle,
ptr,
*heap_cursor,
);
}
}
let handle = vfs_resources[index].handle;
process_memory_manager.set_process_handle_purgeable(handle, true);
process_memory_manager.set_process_handle_resource(handle, true);
*last_mem_error = PPC_NO_ERR;
*last_resource_error = PPC_NO_ERR;
handle
}
pub(super) fn ppc_get_res_attrs(
cpu: &mut PpcCpu,
vfs_resources: &[PpcVfsResourceRecord],
last_resource_error: &mut i16,
) -> i16 {
let handle = cpu.gpr[3];
let Some(record) = vfs_resources.iter().find(|record| record.handle == handle) else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return PPC_RES_CHANGED_ATTR as i16;
};
*last_resource_error = PPC_NO_ERR;
record.attrs as i16
}
pub(super) fn ppc_set_res_attrs(
cpu: &mut PpcCpu,
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
vfs_resources: &mut [PpcVfsResourceRecord],
last_resource_error: &mut i16,
) {
let handle = cpu.gpr[3];
let attrs = cpu.gpr[4] as u16;
let Some(record) = vfs_resources
.iter_mut()
.find(|record| record.handle == handle)
else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return;
};
record.attrs = attrs;
ppc_drop_raw_resource_data(record);
let path = record.path.clone();
ppc_mark_resource_file_contents_dirty(vfs_resource_files, &path);
*last_resource_error = PPC_NO_ERR;
}
pub(super) fn ppc_get_res_info(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_resources: &[PpcVfsResourceRecord],
last_resource_error: &mut i16,
) {
let handle = cpu.gpr[3];
let id_ptr = cpu.gpr[4];
let type_ptr = cpu.gpr[5];
let name_ptr = cpu.gpr[6];
let Some(record) = vfs_resources.iter().find(|record| record.handle == handle) else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return;
};
if !ppc_optional_output_can_write(memory, id_ptr, 2)
|| !ppc_optional_output_can_write(memory, type_ptr, 4)
|| !ppc_optional_pstring_output_can_write(memory, name_ptr, &record.name)
{
*last_resource_error = PPC_PARAM_ERR;
return;
}
if id_ptr != 0 {
let _ = memory.write_u16_be(id_ptr, record.res_id as u16);
}
if type_ptr != 0 {
let _ = memory.write_u32_be(type_ptr, record.res_type);
}
if name_ptr != 0 {
let _ = ppc_write_pstring_bytes(memory, name_ptr, &record.name);
}
*last_resource_error = PPC_NO_ERR;
}
pub(super) fn ppc_set_res_info(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
vfs_resources: &mut [PpcVfsResourceRecord],
last_resource_error: &mut i16,
) {
let handle = cpu.gpr[3];
let new_id = cpu.gpr[4] as u16 as i16;
let name_ptr = cpu.gpr[5];
let Some(record) = vfs_resources
.iter_mut()
.find(|record| record.handle == handle)
else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return;
};
if (record.attrs & PPC_RES_PROTECTED_ATTR) != 0 {
*last_resource_error = PPC_RES_ATTR_ERR;
return;
}
let Some(name) = ppc_resource_name(memory, name_ptr) else {
*last_resource_error = PPC_PARAM_ERR;
return;
};
record.res_id = new_id;
if name_ptr != 0 {
record.name = name;
}
ppc_drop_raw_resource_data(record);
let path = record.path.clone();
ppc_mark_resource_file_contents_dirty(vfs_resource_files, &path);
*last_resource_error = PPC_NO_ERR;
}
pub(super) fn ppc_home_res_file(
cpu: &mut PpcCpu,
vfs_resources: &[PpcVfsResourceRecord],
last_resource_error: &mut i16,
) -> i16 {
let handle = cpu.gpr[3];
let Some(record) = vfs_resources.iter().find(|record| record.handle == handle) else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return -1;
};
*last_resource_error = PPC_NO_ERR;
record.ref_num
}
pub(super) fn ppc_count_resources(
cpu: &mut PpcCpu,
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
current_only: bool,
last_resource_error: &mut i16,
) -> i16 {
let res_type = cpu.gpr[3];
let count = vfs_resources
.iter()
.filter(|record| {
record.res_type == res_type
&& (!current_only || record.ref_num == current_resource_refnum)
})
.count();
*last_resource_error = PPC_NO_ERR;
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] Count{}Resources('{}') current_ref={} -> {}",
if current_only { "1" } else { "" },
ppc_res_type_text(res_type),
current_resource_refnum,
count
);
}
i16::try_from(count).unwrap_or(i16::MAX)
}
pub(super) fn ppc_unique_id(
cpu: &mut PpcCpu,
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
current_only: bool,
last_resource_error: &mut i16,
) -> i16 {
let res_type = cpu.gpr[3];
*last_resource_error = PPC_NO_ERR;
for candidate in 128..=i16::MAX {
if !vfs_resources.iter().any(|record| {
record.res_type == res_type
&& record.res_id == candidate
&& (!current_only || record.ref_num == current_resource_refnum)
}) {
return candidate;
}
}
i16::MAX
}
pub(super) fn ppc_update_res_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
resource_files: &[PpcResourceFileRecord],
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
vfs_resources: &mut [PpcVfsResourceRecord],
current_resource_refnum: i16,
last_resource_error: &mut i16,
) {
let ref_num = cpu.gpr[3] as u16 as i16;
let file_exists = ref_num == 0
|| ref_num == current_resource_refnum
|| resource_files.iter().any(|file| file.ref_num == ref_num)
|| vfs_resources.iter().any(|record| record.ref_num == ref_num);
if !file_exists {
*last_resource_error = PPC_RES_F_NOT_FOUND_ERR;
return;
}
for record in vfs_resources
.iter_mut()
.filter(|record| record.ref_num == ref_num)
{
if (record.attrs & PPC_RES_CHANGED_ATTR) != 0 {
if let Some(data) = ppc_handle_bytes(memory, handles, record.handle) {
record.data = data;
}
ppc_drop_raw_resource_data(record);
}
record.attrs &= !PPC_RES_CHANGED_ATTR;
}
if ref_num != 0 {
if let Some(path) = resource_files
.iter()
.find(|file| file.ref_num == ref_num)
.map(|file| file.path.clone())
.or_else(|| {
vfs_resources
.iter()
.find(|record| record.ref_num == ref_num)
.map(|record| record.path.clone())
})
{
ppc_mark_resource_file_contents_dirty(vfs_resource_files, &path);
}
}
*last_resource_error = PPC_NO_ERR;
}
pub(super) fn ppc_vfs_resource_index(
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
res_type: u32,
res_id: i16,
current_only: bool,
) -> Option<usize> {
let current_match = vfs_resources.iter().position(|record| {
record.ref_num == current_resource_refnum
&& record.res_type == res_type
&& record.res_id == res_id
});
if current_only || current_match.is_some() {
return current_match;
}
vfs_resources.iter().position(|record| {
record.ref_num != PPC_CLOSED_RESOURCE_REF_NUM
&& record.res_type == res_type
&& record.res_id == res_id
})
}
pub(super) fn ppc_write_pstring_bytes(memory: &mut PpcSectionMem, addr: u32, bytes: &[u8]) -> bool {
let len = bytes.len().min(255);
if memory.write_u8(addr, len as u8).is_none() {
return false;
}
for (offset, byte) in bytes.iter().copied().take(len).enumerate() {
let Some(byte_addr) = addr.checked_add(1 + offset as u32) else {
return false;
};
if memory.write_u8(byte_addr, byte).is_none() {
return false;
}
}
true
}
fn ppc_write_empty_pstring(memory: &mut PpcSectionMem, addr: u32) -> bool {
addr == 0 || memory.write_u8(addr, 0).is_some()
}
fn ppc_str_list_item(data: &[u8], index: usize) -> Option<Vec<u8>> {
if index == 0 || data.len() < 2 {
return None;
}
let count = u16::from_be_bytes([data[0], data[1]]) as usize;
if index > count {
return None;
}
let mut offset = 2usize;
for item in 1..=count {
let len = *data.get(offset)? as usize;
offset += 1;
let end = offset.checked_add(len)?;
let bytes = data.get(offset..end)?;
if item == index {
return Some(bytes.to_vec());
}
offset = end;
}
None
}
fn ppc_write_event_record(
memory: &mut PpcSectionMem,
event_ptr: u32,
what: u16,
message: u32,
when: u32,
where_v: i16,
where_h: i16,
modifiers: u16,
) -> bool {
if event_ptr == 0 || !ppc_memory_can_write_bytes(memory, event_ptr, 16) {
return false;
}
memory.write_u16_be(event_ptr, what).is_some()
&& memory.write_u32_be(event_ptr + 2, message).is_some()
&& memory.write_u32_be(event_ptr + 6, when).is_some()
&& memory
.write_u16_be(event_ptr + 10, where_v as u16)
.is_some()
&& memory
.write_u16_be(event_ptr + 12, where_h as u16)
.is_some()
&& memory.write_u16_be(event_ptr + 14, modifiers).is_some()
}
fn ppc_record_event_snapshot(
startup: &mut PpcToolboxStartupState,
what: u16,
message: u32,
when: u32,
where_v: i16,
where_h: i16,
modifiers: u16,
) {
startup.last_event_record = Some(EventRecordSnapshot {
what,
message,
when,
where_v,
where_h,
modifiers,
});
if what == 8 {
startup.activation_event_seen = true;
}
if what == 6 {
startup.update_event_seen = true;
}
}
fn ppc_event_probe_result(
available: bool,
what: u16,
message: u32,
when: u32,
where_v: i16,
where_h: i16,
modifiers: u16,
) -> EventProbeResult {
EventProbeResult {
available,
record: EventRecordSnapshot {
what,
message,
when,
where_v,
where_h,
modifiers,
},
}
}
fn ppc_event_matches_mask(event_mask: u16, what: u16) -> bool {
match what {
23 => (event_mask & 0x0400) != 0,
0..=15 => (event_mask & (1u16 << what)) != 0,
_ => false,
}
}
fn ppc_current_event_modifiers(input: PpcInputSnapshot) -> u16 {
// EventRecord modifiers use the same classic bit assignments on both
// adapters. Read the shared logical key map rather than the host key
// callback so PostEvent observes the state visible to Button/GetKeys.
const BTN_STATE: u16 = 0x0080;
const CMD_KEY: u16 = 0x0100;
const SHIFT_KEY: u16 = 0x0200;
const ALPHA_LOCK: u16 = 0x0400;
const OPTION_KEY: u16 = 0x0800;
const CONTROL_KEY: u16 = 0x1000;
let mut modifiers = 0;
if !input.mouse_button {
modifiers |= BTN_STATE;
}
if crate::trap::dispatch::key_map_key_is_down(&input.key_map, 0x37) {
modifiers |= CMD_KEY;
}
if crate::trap::dispatch::key_map_key_is_down(&input.key_map, 0x38)
|| crate::trap::dispatch::key_map_key_is_down(&input.key_map, 0x3C)
{
modifiers |= SHIFT_KEY;
}
if crate::trap::dispatch::key_map_key_is_down(&input.key_map, 0x39) {
modifiers |= ALPHA_LOCK;
}
if crate::trap::dispatch::key_map_key_is_down(&input.key_map, 0x3A)
|| crate::trap::dispatch::key_map_key_is_down(&input.key_map, 0x3D)
{
modifiers |= OPTION_KEY;
}
if crate::trap::dispatch::key_map_key_is_down(&input.key_map, 0x3B)
|| crate::trap::dispatch::key_map_key_is_down(&input.key_map, 0x3E)
{
modifiers |= CONTROL_KEY;
}
modifiers
}
fn ppc_is_low_level_event(what: u16) -> bool {
matches!(what, 1..=5 | 7)
}
fn ppc_toolbox_event_priority(what: u16) -> u8 {
// Macintosh Toolbox Essentials (1992), pp. 2-18--2-19: the Event
// Manager selects by event-class priority, preserving FIFO order among
// mouse, key, and disk events rather than using one combined FIFO.
match what {
8 => 0,
1..=4 | 7 => 1,
5 => 2,
6 => 3,
15 => 4,
23 => 5,
_ => 6,
}
}
fn ppc_matching_event_index(
event_queue: &VecDeque<PpcQueuedEvent>,
event_mask: u16,
os_only: bool,
) -> Option<usize> {
let matching = event_queue.iter().enumerate().filter(|(_, event)| {
(!os_only || ppc_is_low_level_event(event.what))
&& ppc_event_matches_mask(event_mask, event.what)
});
if os_only {
matching.map(|(index, _)| index).next()
} else {
matching
.min_by_key(|(index, event)| (ppc_toolbox_event_priority(event.what), *index))
.map(|(index, _)| index)
}
}
fn ppc_peek_event(
event_queue: &VecDeque<PpcQueuedEvent>,
event_mask: u16,
input: PpcInputSnapshot,
os_only: bool,
tick_count: u32,
) -> (u16, u32, u32, i16, i16, u16, bool) {
if let Some(event) = ppc_matching_event_index(event_queue, event_mask, os_only)
.and_then(|index| event_queue.get(index))
{
return (
event.what,
event.message,
event.when,
event.where_v,
event.where_h,
event.modifiers,
true,
);
}
(0, 0, tick_count, input.mouse_v, input.mouse_h, 0, false)
}
fn ppc_dequeue_event(
event_queue: &mut VecDeque<PpcQueuedEvent>,
event_mask: u16,
input: PpcInputSnapshot,
os_only: bool,
tick_count: u32,
) -> (u16, u32, u32, i16, i16, u16, bool) {
if let Some(index) = ppc_matching_event_index(event_queue, event_mask, os_only) {
let event = event_queue.remove(index).unwrap();
return (
event.what,
event.message,
event.when,
event.where_v,
event.where_h,
event.modifiers,
true,
);
}
(0, 0, tick_count, input.mouse_v, input.mouse_h, 0, false)
}
pub(super) fn ppc_enqueue_window_update_event(
event_queue: &mut VecDeque<PpcQueuedEvent>,
window: u32,
when: u32,
input: PpcInputSnapshot,
) {
if window == 0
|| event_queue
.iter()
.any(|event| event.what == 6 && event.message == window)
{
return;
}
// Macintosh Toolbox Essentials (1992), pp. 4-65--4-67: showing a
// previously invisible window makes its content region invalid and the
// Window Manager posts an updateEvt for the application to redraw it.
event_queue.push_back(PpcQueuedEvent {
what: 6,
message: window,
when,
where_v: input.mouse_v,
where_h: input.mouse_h,
modifiers: 0,
});
}
fn ppc_enqueue_window_activation_event(
memory: &mut PpcSectionMem,
event_queue: &mut VecDeque<PpcQueuedEvent>,
window: u32,
activating: bool,
when: u32,
) {
if window == 0 {
return;
}
let active_flag = u16::from(activating);
event_queue.retain(|event| event.what != 8 || (event.modifiers & 1) != active_flag);
let _ = memory.write_u32_be(if activating { 0x0A64 } else { 0x0A68 }, window);
event_queue.push_back(PpcQueuedEvent {
what: 8,
message: window,
when,
where_v: 0,
where_h: 0,
modifiers: active_flag,
});
}
pub(super) fn ppc_enqueue_window_activation_transition(
memory: &mut PpcSectionMem,
event_queue: &mut VecDeque<PpcQueuedEvent>,
previous_front: Option<u32>,
next_front: Option<u32>,
when: u32,
) {
if previous_front == next_front {
return;
}
if let Some(previous) = previous_front {
ppc_enqueue_window_activation_event(memory, event_queue, previous, false, when);
}
if let Some(next) = next_front {
ppc_enqueue_window_activation_event(memory, event_queue, next, true, when);
}
}
pub(super) fn ppc_add_resource(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
resource_files: &[PpcResourceFileRecord],
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
current_resource_refnum: i16,
) -> i16 {
let handle = cpu.gpr[3];
let res_type = cpu.gpr[4];
let res_id = cpu.gpr[5] as u16 as i16;
let name_ptr = cpu.gpr[6];
if handle == 0 || vfs_resources.iter().any(|record| record.handle == handle) {
return PPC_ADD_RES_FAILED;
}
let Some(data) = ppc_handle_bytes(memory, handles, handle) else {
return PPC_ADD_RES_FAILED;
};
let Some(name) = ppc_resource_name(memory, name_ptr) else {
return PPC_ADD_RES_FAILED;
};
let path = ppc_resource_file_path(resource_files, current_resource_refnum);
let mut replaced_handles = Vec::new();
vfs_resources.retain(|record| {
let replaced = record.ref_num == current_resource_refnum
&& record.res_type == res_type
&& record.res_id == res_id;
if replaced {
replaced_handles.push(record.handle);
}
!replaced
});
for replaced_handle in replaced_handles {
process_memory_manager.set_process_handle_resource(replaced_handle, false);
}
vfs_resources.push(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: path.clone(),
res_type,
res_id,
name,
data,
raw_data: None,
raw_attrs: None,
attrs: PPC_RES_CHANGED_ATTR,
handle,
});
process_memory_manager.set_process_handle_resource(handle, true);
ppc_mark_resource_file_contents_dirty(vfs_resource_files, &path);
PPC_NO_ERR
}
pub(super) fn ppc_changed_resource(
cpu: &mut PpcCpu,
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
vfs_resources: &mut [PpcVfsResourceRecord],
last_resource_error: &mut i16,
) {
let handle = cpu.gpr[3];
let Some(record) = vfs_resources
.iter_mut()
.find(|record| record.handle == handle)
else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return;
};
if (record.attrs & PPC_RES_PROTECTED_ATTR) != 0 {
*last_resource_error = PPC_RES_ATTR_ERR;
return;
}
record.attrs |= PPC_RES_CHANGED_ATTR;
ppc_drop_raw_resource_data(record);
let path = record.path.clone();
ppc_mark_resource_file_contents_dirty(vfs_resource_files, &path);
*last_resource_error = PPC_NO_ERR;
}
pub(super) fn ppc_write_resource(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
vfs_resources: &mut [PpcVfsResourceRecord],
last_resource_error: &mut i16,
) {
let handle = cpu.gpr[3];
let Some(index) = vfs_resources
.iter()
.position(|record| record.handle == handle)
else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return;
};
let attrs = vfs_resources[index].attrs;
if (attrs & PPC_RES_PROTECTED_ATTR) != 0 || (attrs & PPC_RES_CHANGED_ATTR) == 0 {
*last_resource_error = PPC_NO_ERR;
return;
}
let Some(data) = ppc_handle_bytes(memory, handles, handle) else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return;
};
vfs_resources[index].data = data;
vfs_resources[index].attrs &= !PPC_RES_CHANGED_ATTR;
vfs_resources[index].raw_data = None;
vfs_resources[index].raw_attrs = None;
let path = vfs_resources[index].path.clone();
ppc_mark_resource_file_contents_dirty(vfs_resource_files, &path);
*last_resource_error = PPC_NO_ERR;
}
fn ppc_drop_raw_resource_data(record: &mut PpcVfsResourceRecord) {
record.raw_data = None;
record.raw_attrs = None;
}
pub(super) fn ppc_remove_resource(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
current_resource_refnum: i16,
last_resource_error: &mut i16,
) {
let handle = cpu.gpr[3];
let Some(index) = vfs_resources
.iter()
.position(|record| record.handle == handle)
else {
*last_resource_error = PPC_RMV_RES_FAILED;
return;
};
let record = &vfs_resources[index];
if record.ref_num != current_resource_refnum || (record.attrs & PPC_RES_PROTECTED_ATTR) != 0 {
*last_resource_error = PPC_RMV_RES_FAILED;
return;
}
let path = record.path.clone();
vfs_resources.remove(index);
process_memory_manager.set_process_handle_resource(handle, false);
ppc_mark_resource_file_contents_dirty(vfs_resource_files, &path);
*last_resource_error = PPC_NO_ERR;
}
pub(super) fn ppc_release_resource(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut [PpcVfsResourceRecord],
last_resource_error: &mut i16,
) {
let handle = cpu.gpr[3];
let Some(record) = vfs_resources
.iter_mut()
.find(|record| record.handle == handle)
else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return;
};
if (record.attrs & PPC_RES_CHANGED_ATTR) != 0 {
*last_resource_error = PPC_NO_ERR;
return;
}
// More Macintosh Toolbox Essentials (1993), pp. 1-22 and 1-107:
// ReleaseResource frees the resource data and invalidates its handle so
// the application heap can satisfy later allocations from that storage.
if ppc_dispose_process_native_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
) {
record.handle = 0;
*last_resource_error = PPC_NO_ERR;
} else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
}
}
pub(super) fn ppc_detach_resource(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
vfs_resources: &mut [PpcVfsResourceRecord],
last_resource_error: &mut i16,
) {
let handle = cpu.gpr[3];
let Some(record) = vfs_resources
.iter_mut()
.find(|record| record.handle == handle)
else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return;
};
if (record.attrs & PPC_RES_CHANGED_ATTR) != 0 {
*last_resource_error = PPC_NO_ERR;
return;
}
record.handle = 0;
process_memory_manager.set_process_handle_resource(handle, false);
*last_resource_error = PPC_NO_ERR;
}
pub(super) fn ppc_read_partial_resource(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_resources: &[PpcVfsResourceRecord],
last_resource_error: &mut i16,
) {
let handle = cpu.gpr[3];
let offset = cpu.gpr[4] as i32;
let buffer = cpu.gpr[5];
let count = cpu.gpr[6] as i32;
let Some(record) = vfs_resources
.iter()
.find(|record| record.handle == handle && record.ref_num != PPC_CLOSED_RESOURCE_REF_NUM)
else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return;
};
if offset < 0 || count < 0 {
*last_resource_error = PPC_INPUT_OUT_OF_BOUNDS_ERR;
return;
}
let Ok(start) = usize::try_from(offset) else {
*last_resource_error = PPC_INPUT_OUT_OF_BOUNDS_ERR;
return;
};
let Ok(count) = usize::try_from(count) else {
*last_resource_error = PPC_INPUT_OUT_OF_BOUNDS_ERR;
return;
};
let Some(end) = start.checked_add(count) else {
*last_resource_error = PPC_INPUT_OUT_OF_BOUNDS_ERR;
return;
};
let Some(bytes) = record.data.get(start..end) else {
*last_resource_error = PPC_INPUT_OUT_OF_BOUNDS_ERR;
return;
};
if !bytes.is_empty() && memory.write_bytes(buffer, bytes).is_none() {
*last_resource_error = PPC_PARAM_ERR;
return;
}
// More Macintosh Toolbox (1993), pp. 1-69--1-70: partial reads use
// resource-fork backing even for an empty SetResLoad(FALSE) handle, and
// still copy bytes while reporting resourceInMemory for a loaded handle.
*last_resource_error = if memory.read_u32_be(handle).unwrap_or(0) == 0 {
PPC_NO_ERR
} else {
PPC_RESOURCE_IN_MEMORY_ERR
};
}
pub(super) fn ppc_handle_bytes(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
handle: u32,
) -> Option<Vec<u8>> {
let record = handles.iter().find(|record| record.handle == handle)?;
let mut bytes = Vec::with_capacity(usize::try_from(record.size).ok()?);
for offset in 0..record.size {
bytes.push(memory.read_u8(record.ptr.checked_add(offset)?)?);
}
Some(bytes)
}
fn ppc_resource_name(memory: &mut PpcSectionMem, name_ptr: u32) -> Option<Vec<u8>> {
if name_ptr == 0 {
return Some(Vec::new());
}
let len = usize::from(memory.read_u8(name_ptr)?);
let mut name = Vec::with_capacity(len);
for offset in 0..u32::try_from(len).ok()? {
name.push(memory.read_u8(name_ptr.checked_add(1 + offset)?)?);
}
Some(name)
}
pub(super) fn minimal_pict_bytes() -> [u8; 12] {
[
0x00, 0x0c, // picSize
0x00, 0x00, 0x00, 0x00, // top, left
0x00, 0x01, 0x00, 0x01, // bottom, right
0x00, 0xff, // opEndPic
]
}
fn ppc_get_pict_info(cpu: &mut PpcCpu, memory: &mut PpcSectionMem) -> i16 {
let _pic_handle = cpu.gpr[3];
let pict_info_ptr = cpu.gpr[4];
if pict_info_ptr == 0 || !ppc_memory_can_write_bytes(memory, pict_info_ptr, PPC_PICT_INFO_SIZE)
{
return PPC_PARAM_ERR;
}
for offset in 0..PPC_PICT_INFO_SIZE {
if memory.write_u8(pict_info_ptr + offset, 0).is_none() {
return PPC_PARAM_ERR;
}
}
PPC_NO_ERR
}
fn ppc_palette_entry_color(
memory: &mut PpcSectionMem,
palette_handle: u32,
entry: u16,
) -> Option<(PpcRgbColor, bool)> {
let palette_ptr = memory.read_u32_be(palette_handle)?;
let entry_count = memory.read_u16_be(palette_ptr)?;
if palette_ptr == 0 || entry >= entry_count {
return None;
}
let info_ptr = palette_ptr
.checked_add(16)?
.checked_add(u32::from(entry).checked_mul(16)?)?;
Some((
PpcRgbColor {
red: memory.read_u16_be(info_ptr)?,
green: memory.read_u16_be(info_ptr + 2)?,
blue: memory.read_u16_be(info_ptr + 4)?,
},
memory.read_u16_be(info_ptr + 6)? & 0x0008 != 0,
))
}
#[allow(clippy::too_many_arguments)]
fn ppc_palette_to_ctab(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
toolbox_startup: &mut PpcToolboxStartupState,
palette_handle: u32,
ctable_handle: u32,
) {
// Inside Macintosh Volume VI (1991), p. 20-24: Palette2CTab copies
// every palette color and resizes the destination ColorTable to match.
// A NIL source or destination is explicitly a no-op.
let Some(palette_ptr) = (palette_handle != 0)
.then(|| memory.read_u32_be(palette_handle))
.flatten()
.filter(|ptr| *ptr != 0)
else {
return;
};
let Some(entry_count) = memory.read_u16_be(palette_ptr).map(u32::from) else {
return;
};
if ctable_handle == 0 {
return;
}
let Some(byte_count) = entry_count
.checked_mul(8)
.and_then(|entries| entries.checked_add(8))
else {
*last_mem_error = PPC_MEM_FULL_ERR;
return;
};
let resize_result = ppc_allocator_view_resize_handle(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
ctable_handle,
byte_count,
);
if resize_result != PPC_NO_ERR {
*last_mem_error = resize_result;
return;
}
let Some(ctable_ptr) = memory.read_u32_be(ctable_handle).filter(|ptr| *ptr != 0) else {
*last_mem_error = PPC_PARAM_ERR;
return;
};
let seed = ppc_next_ct_seed(toolbox_startup);
let header_written = memory.write_u32_be(ctable_ptr, seed).is_some()
&& memory.write_u16_be(ctable_ptr + 4, 0).is_some()
&& memory
.write_u16_be(
ctable_ptr + 6,
if entry_count == 0 {
u16::MAX
} else {
(entry_count - 1) as u16
},
)
.is_some();
let colors_written = (0..entry_count).all(|entry| {
let info_ptr = palette_ptr + 16 + entry * 16;
let spec_ptr = ctable_ptr + 8 + entry * 8;
let (Some(red), Some(green), Some(blue)) = (
memory.read_u16_be(info_ptr),
memory.read_u16_be(info_ptr + 2),
memory.read_u16_be(info_ptr + 4),
) else {
return false;
};
memory.write_u16_be(spec_ptr, entry as u16).is_some()
&& memory.write_u16_be(spec_ptr + 2, red).is_some()
&& memory.write_u16_be(spec_ptr + 4, green).is_some()
&& memory.write_u16_be(spec_ptr + 6, blue).is_some()
});
*last_mem_error = if header_written && colors_written {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
}
fn ppc_palette_allocated_index(
toolbox_startup: &PpcToolboxStartupState,
palette: u32,
gdevice: u32,
entry: usize,
) -> Option<u8> {
toolbox_startup
.palette_allocations
.iter()
.find(|allocation| allocation.palette == palette && allocation.gdevice == gdevice)
.and_then(|allocation| allocation.entry_mappings.get(entry).copied())
.and_then(PpcPaletteEntryMapping::index)
}
fn ppc_palette_indexed_override(
toolbox_startup: &PpcToolboxStartupState,
palette: u32,
gdevice: u32,
entry: usize,
) -> Option<Option<u8>> {
toolbox_startup
.palette_allocations
.iter()
.find(|allocation| allocation.palette == palette && allocation.gdevice == gdevice)
.and_then(|allocation| allocation.entry_mappings.get(entry).copied())
.map(|mapping| match mapping {
PpcPaletteEntryMapping::AnimatedReserved(index)
| PpcPaletteEntryMapping::Explicit(index) => Some(index),
_ => None,
})
}
fn ppc_release_palette_allocations(
toolbox_startup: &mut PpcToolboxStartupState,
palette: u32,
) -> Vec<(u32, u8, bool, bool)> {
let active_devices = toolbox_startup
.active_device_palettes
.iter()
.filter_map(|(gdevice, active_palette)| (*active_palette == palette).then_some(*gdevice))
.collect::<Vec<_>>();
toolbox_startup
.active_device_palettes
.retain(|_, active_palette| *active_palette != palette);
let mut released = Vec::new();
toolbox_startup.palette_allocations.retain(|allocation| {
if allocation.palette == palette {
released.extend(allocation.entry_mappings.iter().filter_map(|mapping| {
mapping.owned_index().map(|index| {
(
allocation.gdevice,
index,
mapping.animated_index().is_some(),
active_devices.contains(&allocation.gdevice),
)
})
}));
false
} else {
true
}
});
released
}
fn ppc_closest_available_clut_index(
red: u16,
green: u16,
blue: u16,
clut: &[[u16; 3]; 256],
unavailable: &[bool; 256],
claimed: &[bool; 256],
) -> u8 {
clut.iter()
.enumerate()
.filter(|(index, _)| !unavailable[*index] && !claimed[*index])
.min_by_key(|(_, color)| {
color[0].abs_diff(red) as u64 * color[0].abs_diff(red) as u64
+ color[1].abs_diff(green) as u64 * color[1].abs_diff(green) as u64
+ color[2].abs_diff(blue) as u64 * color[2].abs_diff(blue) as u64
})
.map_or(0, |(index, _)| index as u8)
}
pub(super) fn ppc_release_palette_allocations_and_restore(
memory: &mut PpcSectionMem,
toolbox_startup: &mut PpcToolboxStartupState,
palette: u32,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
color_manager_clut: &mut [[u16; 3]; 256],
) {
let defaults = TrapDispatcher::standard_mac_8bpp_clut();
for (gdevice, index, animated, was_active) in
ppc_release_palette_allocations(toolbox_startup, palette)
{
// Tolerant colors are replaceable, not reserved. An inactive
// palette's stale tolerant mapping must not restore or preserve a
// device cell when that palette is later disposed.
if !animated && !was_active {
continue;
}
let slot = usize::from(index);
let still_reserved = toolbox_startup
.palette_allocations
.iter()
.any(|allocation| {
allocation.gdevice == gdevice
&& allocation
.entry_mappings
.iter()
.any(|mapping| mapping.animated_index() == Some(index))
});
let still_active_owned = toolbox_startup
.active_device_palettes
.get(&gdevice)
.is_some_and(|active_palette| {
toolbox_startup
.palette_allocations
.iter()
.any(|allocation| {
allocation.gdevice == gdevice
&& allocation.palette == *active_palette
&& allocation
.entry_mappings
.iter()
.any(|mapping| mapping.owned_index() == Some(index))
})
});
let still_owned_during_active_tolerant_release = !animated
&& was_active
&& toolbox_startup
.palette_allocations
.iter()
.any(|allocation| {
allocation.gdevice == gdevice
&& allocation
.entry_mappings
.iter()
.any(|mapping| mapping.owned_index() == Some(index))
});
let protected = ppc_device_clut_protected(toolbox_startup, gdevice)[slot];
if !still_reserved
&& !still_active_owned
&& !still_owned_during_active_tolerant_release
&& !protected
{
let mut device_clut = ppc_gdevice_ctable_handle(memory, gdevice)
.and_then(|handle| ppc_read_ctable_clut(memory, handle, &defaults))
.unwrap_or(defaults);
device_clut[slot] = defaults[slot];
if gdevice == current_gdevice {
screen_clut[slot] = defaults[slot];
color_manager_clut[slot] = defaults[slot];
device_clut = *screen_clut;
}
ppc_write_device_color_table(memory, gdevice, &device_clut, toolbox_startup);
}
}
}
#[derive(Clone, Copy)]
struct PpcStolenPaletteReservation {
index: u8,
palette: u32,
entry: usize,
allocation_index: usize,
}
fn ppc_find_animated_palette_index_to_steal(
memory: &mut PpcSectionMem,
toolbox_startup: &PpcToolboxStartupState,
palette_handle: u32,
gdevice: u32,
protected: &[bool; 256],
globally_reserved: &[bool; 256],
claimed: &[bool; 256],
) -> Option<PpcStolenPaletteReservation> {
// When no unreserved cell remains for a tolerant color, the active
// palette may cancel another palette's animated reservation on the same
// device. Inside Macintosh Volume VI (1991), pp. 20-6, 20-10, 20-13.
let mut candidates = toolbox_startup
.palette_allocations
.iter()
.enumerate()
.filter(|(_, allocation)| {
allocation.gdevice == gdevice && allocation.palette != palette_handle
})
.flat_map(|(allocation_index, allocation)| {
allocation
.entry_mappings
.iter()
.copied()
.enumerate()
.filter_map(move |(entry, mapping)| {
let index = mapping.animated_index()?;
let slot = usize::from(index);
(allocation.reserved_indices.contains(&index)
&& !protected[slot]
&& !globally_reserved[slot]
&& !claimed[slot])
.then_some(PpcStolenPaletteReservation {
index,
palette: allocation.palette,
entry,
allocation_index,
})
})
})
.collect::<Vec<_>>();
candidates
.sort_unstable_by_key(|candidate| (candidate.index, candidate.palette, candidate.entry));
candidates.into_iter().find(|candidate| {
memory
.read_u32_be(candidate.palette)
.filter(|ptr| *ptr != 0)
.and_then(|ptr| ptr.checked_add(16 + candidate.entry as u32 * 16))
.and_then(|info| ppc_read_rgb_color(memory, info))
.is_some()
})
}
fn ppc_finalize_stolen_palette_reservation(
memory: &mut PpcSectionMem,
toolbox_startup: &mut PpcToolboxStartupState,
stolen: PpcStolenPaletteReservation,
screen_clut: &[[u16; 3]; 256],
unavailable: &[bool; 256],
current_reserved: &[u8],
) {
let victim_color = memory
.read_u32_be(stolen.palette)
.filter(|ptr| *ptr != 0)
.and_then(|ptr| ptr.checked_add(16 + stolen.entry as u32 * 16))
.and_then(|info| ppc_read_rgb_color(memory, info));
let Some(victim_color) = victim_color else {
return;
};
let mut victim_unavailable = *unavailable;
for index in current_reserved {
victim_unavailable[usize::from(*index)] = true;
}
let replacement = ppc_closest_available_clut_index(
victim_color.red,
victim_color.green,
victim_color.blue,
screen_clut,
&victim_unavailable,
&[false; 256],
);
let allocation = &mut toolbox_startup.palette_allocations[stolen.allocation_index];
allocation.entry_mappings[stolen.entry] = PpcPaletteEntryMapping::MatchOnly(replacement);
allocation.entry_to_index[stolen.entry] = Some(replacement);
allocation
.reserved_indices
.retain(|reserved| *reserved != stolen.index);
}
fn ppc_apply_palette(
memory: &mut PpcSectionMem,
palette_handle: u32,
gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
toolbox_startup: &mut PpcToolboxStartupState,
) -> bool {
const PALETTE_HEADER_SIZE: u32 = 16;
const PALETTE_COLOR_INFO_SIZE: u32 = 16;
const PM_TOLERANT: u16 = 0x0002;
const PM_ANIMATED: u16 = 0x0004;
const PM_EXPLICIT: u16 = 0x0008;
const PM_INHIBIT_C8: u16 = 0x2000;
let Some(palette_ptr) = memory.read_u32_be(palette_handle) else {
return false;
};
if palette_ptr == 0 {
return false;
}
let Some(entry_count) = memory.read_u16_be(palette_ptr) else {
return false;
};
let entry_count = usize::from(entry_count);
let mut entries = Vec::with_capacity(entry_count);
for entry in 0..entry_count {
let info = palette_ptr + PALETTE_HEADER_SIZE + entry as u32 * PALETTE_COLOR_INFO_SIZE;
let Some(color) = ppc_read_rgb_color(memory, info) else {
return false;
};
let (Some(usage), Some(tolerance)) =
(memory.read_u16_be(info + 6), memory.read_u16_be(info + 8))
else {
return false;
};
entries.push(([color.red, color.green, color.blue], usage, tolerance));
}
let previous = toolbox_startup
.palette_allocations
.iter()
.find(|allocation| allocation.palette == palette_handle && allocation.gdevice == gdevice)
.cloned();
let device_protected = ppc_device_clut_protected(toolbox_startup, gdevice);
let device_reserved = ppc_device_clut_reserved(toolbox_startup, gdevice);
// Rebuild from device defaults so reservations removed by a usage or
// size change cannot leave stale animated RGB values behind. Stable
// animated entries retain their recorded indexes and are written again
// below. Inside Macintosh Volume VI (1991), p. 20-10.
if let Some(previous) = &previous {
let defaults = TrapDispatcher::standard_mac_8bpp_clut();
for index in previous
.entry_mappings
.iter()
.filter_map(|mapping| mapping.owned_index())
{
let slot = usize::from(index);
let owned_elsewhere = toolbox_startup
.palette_allocations
.iter()
.any(|allocation| {
allocation.gdevice == gdevice
&& allocation.palette != palette_handle
&& allocation
.entry_mappings
.iter()
.any(|mapping| mapping.owned_index() == Some(index))
});
if !device_protected[slot] && !owned_elsewhere {
screen_clut[slot] = defaults[slot];
}
}
}
let mut unavailable = device_reserved;
for allocation in &toolbox_startup.palette_allocations {
if allocation.gdevice == gdevice && allocation.palette != palette_handle {
for index in &allocation.reserved_indices {
unavailable[usize::from(*index)] = true;
}
}
}
let mut entry_mappings = vec![PpcPaletteEntryMapping::Unallocated; entry_count];
let mut reserved = Vec::new();
let mut claimed = [false; 256];
let mut allocation_blocked = unavailable;
allocation_blocked[0] = true;
allocation_blocked[255] = true;
// Inside Macintosh Volume VI (1991), pp. 20-6, 20-8--20-12: combined
// animated/explicit and tolerant/explicit entries have priority, then
// animated and tolerant entries; courteous colors only match.
for priority in 0..5 {
for (entry, (rgb, usage, tolerance)) in entries.iter().copied().enumerate() {
if usage & PM_INHIBIT_C8 != 0 {
continue;
}
let animated = usage & PM_ANIMATED != 0;
let tolerant = usage & PM_TOLERANT != 0;
let explicit = usage & PM_EXPLICIT != 0;
let entry_priority = match (animated, tolerant, explicit) {
(true, _, true) => 0,
(false, true, true) => 1,
(true, _, false) => 2,
(false, true, false) => 3,
_ => 4,
};
if entry_priority != priority {
continue;
}
if explicit {
let index = entry as u8;
if !animated && !tolerant {
entry_mappings[entry] = PpcPaletteEntryMapping::Explicit(index);
continue;
}
let slot = usize::from(index);
if !device_protected[slot] && !allocation_blocked[slot] && !claimed[slot] {
screen_clut[slot] = rgb;
claimed[slot] = true;
if animated {
reserved.push(index);
entry_mappings[entry] = PpcPaletteEntryMapping::AnimatedReserved(index);
} else {
entry_mappings[entry] = PpcPaletteEntryMapping::TolerantInstalled(index);
}
} else if animated {
// Inside Macintosh Volume VI (1991), p. 20-13:
// unallocated animated+explicit entries are courteous.
entry_mappings[entry] =
PpcPaletteEntryMapping::MatchOnly(ppc_closest_available_clut_index(
rgb[0],
rgb[1],
rgb[2],
screen_clut,
&unavailable,
&claimed,
));
} else {
// Unallocated tolerant+explicit entries retain ordinary
// tolerant semantics and may install the color elsewhere.
let closest = ppc_closest_available_clut_index(
rgb[0],
rgb[1],
rgb[2],
screen_clut,
&unavailable,
&claimed,
);
let candidate = screen_clut[usize::from(closest)];
let difference = (0..3)
.map(|channel| rgb[channel].abs_diff(candidate[channel]))
.max()
.unwrap_or(0);
if difference <= tolerance {
entry_mappings[entry] = PpcPaletteEntryMapping::MatchOnly(closest);
} else if let Some((slot, stolen)) = (0..256)
.find(|slot| {
!device_protected[*slot]
&& !allocation_blocked[*slot]
&& !claimed[*slot]
})
.map(|slot| (slot, None))
.or_else(|| {
ppc_find_animated_palette_index_to_steal(
memory,
toolbox_startup,
palette_handle,
gdevice,
&device_protected,
&device_reserved,
&claimed,
)
.map(|stolen| (usize::from(stolen.index), Some(stolen)))
})
{
if stolen.is_some() {
unavailable[slot] = false;
}
screen_clut[slot] = rgb;
claimed[slot] = true;
entry_mappings[entry] =
PpcPaletteEntryMapping::TolerantInstalled(slot as u8);
if let Some(stolen) = stolen {
ppc_finalize_stolen_palette_reservation(
memory,
toolbox_startup,
stolen,
screen_clut,
&unavailable,
&reserved,
);
}
} else {
entry_mappings[entry] = PpcPaletteEntryMapping::MatchOnly(closest);
}
}
continue;
}
if animated {
let old = previous
.as_ref()
.and_then(|allocation| allocation.entry_mappings.get(entry))
.copied()
.and_then(PpcPaletteEntryMapping::animated_index)
.filter(|index| {
let slot = usize::from(*index);
!device_protected[slot] && !allocation_blocked[slot] && !claimed[slot]
});
let aligned = (entry < 256).then_some(entry as u8).filter(|index| {
let slot = usize::from(*index);
!device_protected[slot] && !allocation_blocked[slot] && !claimed[slot]
});
let chosen = old.or(aligned).or_else(|| {
(0..256).find_map(|slot| {
let needed_by_later_aligned_entry = slot > entry
&& slot < entries.len()
&& entries[slot].1 & PM_ANIMATED != 0
&& entries[slot].1 & PM_EXPLICIT == 0
&& entries[slot].1 & PM_INHIBIT_C8 == 0;
(!needed_by_later_aligned_entry
&& !device_protected[slot]
&& !allocation_blocked[slot]
&& !claimed[slot])
.then_some(slot as u8)
})
});
if let Some(index) = chosen {
let slot = usize::from(index);
entry_mappings[entry] = PpcPaletteEntryMapping::AnimatedReserved(index);
claimed[slot] = true;
screen_clut[slot] = rgb;
reserved.push(index);
} else {
entry_mappings[entry] =
PpcPaletteEntryMapping::MatchOnly(ppc_closest_available_clut_index(
rgb[0],
rgb[1],
rgb[2],
screen_clut,
&unavailable,
&claimed,
));
}
continue;
}
let closest = ppc_closest_available_clut_index(
rgb[0],
rgb[1],
rgb[2],
screen_clut,
&unavailable,
&claimed,
);
if tolerant {
let candidate = screen_clut[usize::from(closest)];
let difference = (0..3)
.map(|channel| rgb[channel].abs_diff(candidate[channel]))
.max()
.unwrap_or(0);
if difference <= tolerance {
entry_mappings[entry] = PpcPaletteEntryMapping::MatchOnly(closest);
continue;
}
if let Some((slot, stolen)) = (0..256)
.find(|slot| {
!device_protected[*slot] && !allocation_blocked[*slot] && !claimed[*slot]
})
.map(|slot| (slot, None))
.or_else(|| {
ppc_find_animated_palette_index_to_steal(
memory,
toolbox_startup,
palette_handle,
gdevice,
&device_protected,
&device_reserved,
&claimed,
)
.map(|stolen| (usize::from(stolen.index), Some(stolen)))
})
{
if stolen.is_some() {
unavailable[slot] = false;
}
screen_clut[slot] = rgb;
claimed[slot] = true;
entry_mappings[entry] = PpcPaletteEntryMapping::TolerantInstalled(slot as u8);
if let Some(stolen) = stolen {
ppc_finalize_stolen_palette_reservation(
memory,
toolbox_startup,
stolen,
screen_clut,
&unavailable,
&reserved,
);
}
} else {
entry_mappings[entry] = PpcPaletteEntryMapping::MatchOnly(closest);
}
} else {
entry_mappings[entry] = PpcPaletteEntryMapping::MatchOnly(closest);
}
}
}
toolbox_startup
.palette_allocations
.retain(|allocation| allocation.palette != palette_handle || allocation.gdevice != gdevice);
toolbox_startup
.palette_allocations
.push(PpcPaletteAllocation {
palette: palette_handle,
gdevice,
entry_to_index: entry_mappings
.iter()
.copied()
.map(PpcPaletteEntryMapping::index)
.collect(),
entry_mappings,
reserved_indices: reserved,
});
true
}
pub(super) fn ppc_register_gdevice(toolbox_startup: &mut PpcToolboxStartupState, gdevice: u32) {
if gdevice != 0 && !toolbox_startup.known_gdevices.contains(&gdevice) {
toolbox_startup.known_gdevices.push(gdevice);
}
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_activate_window_palette(
memory: &mut PpcSectionMem,
window: u32,
gdevice: u32,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
color_manager_clut: &mut [[u16; 3]; 256],
toolbox_startup: &mut PpcToolboxStartupState,
) -> bool {
ppc_register_gdevice(toolbox_startup, gdevice);
let defaults = TrapDispatcher::standard_mac_8bpp_clut();
let mut device_clut = if gdevice == current_gdevice {
*screen_clut
} else {
ppc_gdevice_ctable_handle(memory, gdevice)
.and_then(|handle| ppc_read_ctable_clut(memory, handle, &defaults))
.unwrap_or(defaults)
};
let assigned_palette = memory
.read_u32_be(window.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET))
.unwrap_or(0);
// Inside Macintosh Volume VI (1991), pp. 20-16, 20-19: a window with no
// assigned palette uses the application's default palette.
let palette_handle = if assigned_palette != 0 {
assigned_palette
} else {
toolbox_startup.application_palette
};
if palette_handle == 0 {
// Inside Macintosh Volume VI (1991), p. 20-16: when neither a window
// palette nor an application-default palette exists, Palette Manager
// uses the system default palette, falling back to its built-in one.
let mut default_clut = defaults;
// Merely hiding a window does not release its animated entries, so a
// default environment must retain every still-reserved device cell.
// Inside Macintosh Volume VI (1991), pp. 20-7, 20-10.
for allocation in &toolbox_startup.palette_allocations {
if allocation.gdevice == gdevice {
for index in &allocation.reserved_indices {
default_clut[usize::from(*index)] = device_clut[usize::from(*index)];
}
}
}
let protected = ppc_device_clut_protected(toolbox_startup, gdevice);
let reserved = ppc_device_clut_reserved(toolbox_startup, gdevice);
for index in 0..256 {
if protected[index] || reserved[index] {
default_clut[index] = device_clut[index];
}
}
device_clut = default_clut;
if gdevice == current_gdevice {
*screen_clut = device_clut;
*color_manager_clut = device_clut;
}
toolbox_startup.active_device_palettes.remove(&gdevice);
ppc_write_device_color_table(memory, gdevice, &device_clut, toolbox_startup);
return true;
}
let previous_device_clut = device_clut;
let applied_to_device = ppc_apply_palette(
memory,
palette_handle,
gdevice,
&mut device_clut,
toolbox_startup,
);
if !applied_to_device {
return false;
}
toolbox_startup
.active_device_palettes
.insert(gdevice, palette_handle);
if gdevice == current_gdevice {
*screen_clut = device_clut;
for index in 0..256 {
if device_clut[index] != previous_device_clut[index] {
color_manager_clut[index] = device_clut[index];
}
}
}
ppc_write_device_color_table(memory, gdevice, &device_clut, toolbox_startup);
true
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_activate_front_window_palette(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
fallback_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
color_manager_clut: &mut [[u16; 3]; 256],
toolbox_startup: &mut PpcToolboxStartupState,
) -> Option<u32> {
let front = ppc_front_visible_window(memory, gworlds);
let window = front.unwrap_or(PPC_MAIN_GWORLD);
let gdevice = front.map_or(PPC_MAIN_GDEVICE, |front| {
ppc_gworld_device(gworlds, front).unwrap_or(fallback_gdevice)
});
let assigned_palette = memory
.read_u32_be(window.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET))
.unwrap_or(0);
if assigned_palette == 0
&& toolbox_startup.application_palette == 0
&& !toolbox_startup
.active_device_palettes
.contains_key(&gdevice)
{
// Inside Macintosh Volume V (1986), p. V-143: SetEntries directly
// changes the current GDevice's color table. A front-window change
// with no Palette Manager environment must not replace those colors;
// there is no managed palette to deactivate or activate.
return Some(window);
}
ppc_activate_window_palette(
memory,
window,
gdevice,
fallback_gdevice,
screen_clut,
color_manager_clut,
toolbox_startup,
)
.then_some(window)
}
fn ppc_write_device_color_table(
memory: &mut PpcSectionMem,
gdevice_handle: u32,
clut: &[[u16; 3]; 256],
toolbox_startup: &mut PpcToolboxStartupState,
) {
// On an indexed device, ActivatePalette asks the Color Manager to modify
// the device entries needed by the active palette. The device PixMap's
// ColorTable therefore describes the same logical colors as the hardware
// CLUT used to display its pixel indexes.
// Inside Macintosh Volume VI (1991), pp. 20-15, 20-20.
let color_table = memory
.read_u32_be(gdevice_handle)
.filter(|device| *device != 0)
.and_then(|device| memory.read_u32_be(device + 22))
.filter(|pixmap_handle| *pixmap_handle != 0)
.and_then(|pixmap_handle| memory.read_u32_be(pixmap_handle))
.filter(|pixmap| *pixmap != 0)
.and_then(|pixmap| memory.read_u32_be(pixmap + 42))
.filter(|table_handle| *table_handle != 0)
.and_then(|table_handle| memory.read_u32_be(table_handle))
.filter(|table| *table != 0);
let Some(color_table) = color_table else {
return;
};
let entry_count = usize::from(memory.read_u16_be(color_table + 6).unwrap_or(255))
.saturating_add(1)
.min(clut.len());
for (index, [red, green, blue]) in clut.iter().copied().take(entry_count).enumerate() {
let entry = color_table + 8 + index as u32 * 8;
let _ = memory.write_u16_be(entry, index as u16);
let _ = memory.write_u16_be(entry + 2, red);
let _ = memory.write_u16_be(entry + 4, green);
let _ = memory.write_u16_be(entry + 6, blue);
}
let seed = ppc_next_ct_seed(toolbox_startup);
let _ = memory.write_u32_be(color_table, seed);
}
fn ppc_next_ct_seed(toolbox_startup: &mut PpcToolboxStartupState) -> u32 {
let seed = toolbox_startup.next_ct_seed.max(1024);
toolbox_startup.next_ct_seed = seed.wrapping_add(1).max(1024);
seed
}
fn ppc_device_clut_protected(
toolbox_startup: &PpcToolboxStartupState,
gdevice: u32,
) -> [bool; 256] {
if gdevice == PPC_MAIN_GDEVICE {
toolbox_startup.clut_protected
} else {
toolbox_startup
.clut_protected_by_device
.get(&gdevice)
.copied()
.unwrap_or([false; 256])
}
}
fn ppc_device_clut_reserved(toolbox_startup: &PpcToolboxStartupState, gdevice: u32) -> [bool; 256] {
if gdevice == PPC_MAIN_GDEVICE {
toolbox_startup.clut_reserved
} else {
toolbox_startup
.clut_reserved_by_device
.get(&gdevice)
.copied()
.unwrap_or([false; 256])
}
}
fn ppc_device_clut_protected_mut(
toolbox_startup: &mut PpcToolboxStartupState,
gdevice: u32,
) -> &mut [bool; 256] {
if gdevice == PPC_MAIN_GDEVICE {
&mut toolbox_startup.clut_protected
} else {
toolbox_startup
.clut_protected_by_device
.entry(gdevice)
.or_insert([false; 256])
}
}
fn ppc_device_clut_reserved_mut(
toolbox_startup: &mut PpcToolboxStartupState,
gdevice: u32,
) -> &mut [bool; 256] {
if gdevice == PPC_MAIN_GDEVICE {
&mut toolbox_startup.clut_reserved
} else {
toolbox_startup
.clut_reserved_by_device
.entry(gdevice)
.or_insert([false; 256])
}
}
fn ppc_set_clut_entry_flag(flags: &mut [bool; 256], index: i16, value: bool) {
if let Ok(index) = usize::try_from(index) {
if let Some(flag) = flags.get_mut(index) {
*flag = value;
}
}
}
fn ppc_current_gdevice_record(memory: &mut PpcSectionMem, current_gdevice: u32) -> Option<u32> {
memory
.read_u32_be(current_gdevice)
.filter(|gdevice| *gdevice != 0)
}
fn ppc_gdevice_ctable_handle(memory: &mut PpcSectionMem, current_gdevice: u32) -> Option<u32> {
ppc_gdevice_ctable_handle_with_provenance(memory, current_gdevice).handle
}
fn ppc_gdevice_ctable_handle_with_provenance(
memory: &mut PpcSectionMem,
current_gdevice: u32,
) -> PpcOptionalHandleResolution {
let Some(gdevice) = memory.read_u32_be(current_gdevice) else {
return PpcOptionalHandleResolution {
handle: None,
known: false,
};
};
if gdevice == 0 {
return PpcOptionalHandleResolution {
handle: None,
known: false,
};
}
let Some(pixmap_handle) = gdevice
.checked_add(22)
.and_then(|field| memory.read_u32_be(field))
else {
return PpcOptionalHandleResolution {
handle: None,
known: false,
};
};
if pixmap_handle == 0 {
return PpcOptionalHandleResolution {
handle: None,
known: false,
};
}
let Some(pixmap) = memory
.read_u32_be(pixmap_handle)
.filter(|pixmap| *pixmap != 0)
else {
return PpcOptionalHandleResolution {
handle: None,
known: false,
};
};
let Some(raw_handle) = pixmap
.checked_add(42)
.and_then(|field| memory.read_u32_be(field))
else {
return PpcOptionalHandleResolution {
handle: None,
known: false,
};
};
PpcOptionalHandleResolution {
handle: (raw_handle != 0).then_some(raw_handle),
known: true,
}
}
fn ppc_index_to_color(
memory: &mut PpcSectionMem,
current_gdevice: u32,
screen_clut: &[[u16; 3]; 256],
index: u32,
) -> PpcRgbColor {
// Inside Macintosh Volume V (1986), p. V-141: Index2Color reads the
// requested pixel value from the active GDevice's color table. ColorSpec
// records are stored in pixel-value order in indexed device tables.
let device_color = ppc_gdevice_ctable_handle(memory, current_gdevice).and_then(|handle| {
let table = memory.read_u32_be(handle).filter(|table| *table != 0)?;
let last_index = u32::from(memory.read_u16_be(table.checked_add(6)?)?);
if index > last_index {
return None;
}
let entry = table.checked_add(8)?.checked_add(index.checked_mul(8)?)?;
Some(PpcRgbColor {
red: memory.read_u16_be(entry.checked_add(2)?)?,
green: memory.read_u16_be(entry.checked_add(4)?)?,
blue: memory.read_u16_be(entry.checked_add(6)?)?,
})
});
device_color.unwrap_or_else(|| {
screen_clut
.get(index as usize)
.copied()
.map(|[red, green, blue]| PpcRgbColor { red, green, blue })
.unwrap_or(PPC_RGB_BLACK)
})
}
fn ppc_color_to_index(
memory: &mut PpcSectionMem,
current_gdevice: u32,
logical_screen_clut: &[[u16; 3]; 256],
color: PpcRgbColor,
) -> u32 {
let pixmap = ppc_current_gdevice_record(memory, current_gdevice)
.and_then(|gdevice| memory.read_u32_be(gdevice.checked_add(22)?))
.filter(|handle| *handle != 0)
.and_then(|handle| memory.read_u32_be(handle))
.filter(|pixmap| *pixmap != 0);
let depth = pixmap
.and_then(|pixmap| memory.read_u16_be(pixmap.checked_add(32)?))
.unwrap_or(PPC_MAIN_PIXEL_DEPTH as u16);
if depth > 8 {
return u32::from(ppc_rgb_color_to_rgb555(color));
}
if current_gdevice == PPC_MAIN_GDEVICE && depth == 8 {
// Match the main screen's logical ColorTable rather than scanning the
// independently animated hardware CLUT. A real ColorTable replacement
// changes this lookup; a hardware-only fade does not.
return u32::from(TrapDispatcher::screen_itable_index(
logical_screen_clut,
[color.red, color.green, color.blue],
));
}
let entry_count = 1usize << usize::from(depth.clamp(1, 8));
let fallback = *logical_screen_clut;
let clut = pixmap
.and_then(|pixmap| memory.read_u32_be(pixmap.checked_add(42)?))
.filter(|handle| *handle != 0)
.and_then(|handle| ppc_read_ctable_clut(memory, handle, &fallback))
.unwrap_or(fallback);
let wanted = [color.red, color.green, color.blue];
if let Some(index) = clut[..entry_count]
.iter()
.position(|entry| *entry == wanted)
{
return index as u32;
}
let mut best_index = 0usize;
let mut best_distance = u64::MAX;
for (index, entry) in clut[..entry_count].iter().enumerate() {
let red = i64::from(entry[0]) - i64::from(color.red);
let green = i64::from(entry[1]) - i64::from(color.green);
let blue = i64::from(entry[2]) - i64::from(color.blue);
let distance = (red * red + green * green + blue * blue) as u64;
if distance < best_distance {
best_index = index;
best_distance = distance;
}
}
best_index as u32
}
fn ppc_read_itable_ctable(
memory: &mut PpcSectionMem,
ctable_handle: u32,
screen_clut: &[[u16; 3]; 256],
reserved: &[bool; 256],
) -> Option<(u32, Vec<(u8, [u16; 3])>)> {
if ctable_handle == 0 {
let colors = screen_clut
.iter()
.copied()
.enumerate()
.filter(|(index, _)| !reserved[*index])
.map(|(index, rgb)| (index as u8, rgb))
.collect();
return Some((0, colors));
}
let ctable = memory
.read_u32_be(ctable_handle)
.filter(|ctable| *ctable != 0)?;
let seed = memory.read_u32_be(ctable)?;
let last_index = memory.read_u16_be(ctable.checked_add(6)?)? as i16;
let entry_count = if last_index < 0 {
0
} else {
usize::from(last_index as u16).saturating_add(1).min(256)
};
let mut colors = Vec::with_capacity(entry_count);
for slot in 0..entry_count {
let entry = ctable.checked_add(8 + slot as u32 * 8)?;
let value = memory.read_u16_be(entry)?;
let Ok(index) = u8::try_from(value) else {
continue;
};
if reserved[usize::from(index)] {
continue;
}
colors.push((
index,
[
memory.read_u16_be(entry.checked_add(2)?)?,
memory.read_u16_be(entry.checked_add(4)?)?,
memory.read_u16_be(entry.checked_add(6)?)?,
],
));
}
Some((seed, colors))
}
fn ppc_inverse_table_bytes(colors: &[(u8, [u16; 3])], resolution: u16) -> Vec<u8> {
let no_reserved_standard_indices = colors
.iter()
.enumerate()
.all(|(slot, (index, _))| usize::from(*index) == slot);
if resolution == 4 && no_reserved_standard_indices && colors.len() == 256 {
let standard = TrapDispatcher::standard_mac_8bpp_clut();
if colors
.iter()
.zip(standard.iter())
.all(|((_, actual), expected)| actual == expected)
{
return TrapDispatcher::standard_mac_8bpp_itable().to_vec();
}
}
if resolution == 4 && no_reserved_standard_indices && colors.len() == 16 {
let standard = TrapDispatcher::standard_mac_4bpp_gworld_clut();
if colors
.iter()
.zip(standard.iter())
.all(|((_, actual), expected)| actual == expected)
{
return TrapDispatcher::standard_mac_4bpp_gworld_itable().to_vec();
}
}
let entry_count = 1usize << (usize::from(resolution) * 3);
let mut table = vec![0; entry_count];
if colors.is_empty() {
return table;
}
let component_mask = (1u32 << resolution) - 1;
let component_shift = 16 - u32::from(resolution);
let cell_center = 1u32 << (15 - u32::from(resolution));
for (cell, destination) in table.iter_mut().enumerate() {
let cell = cell as u32;
let quantized_blue = cell & component_mask;
let quantized_green = (cell >> resolution) & component_mask;
let quantized_red = (cell >> (resolution * 2)) & component_mask;
let target = [
(quantized_red << component_shift) | cell_center,
(quantized_green << component_shift) | cell_center,
(quantized_blue << component_shift) | cell_center,
];
let mut best_index = colors[0].0;
let mut best_distance = u64::MAX;
for &(index, rgb) in colors {
let red = i64::from(target[0]) - i64::from(rgb[0]);
let green = i64::from(target[1]) - i64::from(rgb[1]);
let blue = i64::from(target[2]) - i64::from(rgb[2]);
let distance = (red * red + green * green + blue * blue) as u64;
if distance < best_distance {
best_index = index;
best_distance = distance;
}
}
*destination = best_index;
}
table
}
#[allow(clippy::too_many_arguments)]
fn ppc_make_itable(
cpu: &PpcCpu,
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
current_gdevice: u32,
screen_clut: &[[u16; 3]; 256],
toolbox_startup: &mut PpcToolboxStartupState,
) {
// Inside Macintosh Volume V (1986), p. V-142: MakeITable accepts only
// 3-, 4-, and 5-bit component resolution. NIL handles and a zero
// resolution select the corresponding fields of the current GDevice.
let requested_resolution = cpu.gpr[5] as u16;
let gdevice = ppc_current_gdevice_record(memory, current_gdevice);
let resolution = if requested_resolution == 0 {
gdevice
.and_then(|gdevice| memory.read_u16_be(gdevice + 10))
.unwrap_or(0)
} else {
requested_resolution
};
if !(3..=5).contains(&resolution) {
toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = PPC_C_RES_ERR);
return;
}
let explicit_ctable_handle = cpu.gpr[3];
let ctable_handle = if explicit_ctable_handle != 0 {
explicit_ctable_handle
} else {
ppc_gdevice_ctable_handle(memory, current_gdevice).unwrap_or(0)
};
let Some((seed, colors)) = ppc_read_itable_ctable(
memory,
ctable_handle,
screen_clut,
&ppc_device_clut_reserved(toolbox_startup, current_gdevice),
) else {
toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = PPC_PARAM_ERR);
return;
};
let table = ppc_inverse_table_bytes(&colors, resolution);
let Some(record_size) = u32::try_from(table.len())
.ok()
.and_then(|size| size.checked_add(6))
else {
toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = PPC_MEM_FULL_ERR);
return;
};
let explicit_itable_handle = cpu.gpr[4];
let mut itable_handle = explicit_itable_handle;
if itable_handle == 0 {
let Some(gdevice) = gdevice else {
toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = PPC_PARAM_ERR);
return;
};
itable_handle = memory.read_u32_be(gdevice + 6).unwrap_or(0);
if itable_handle == 0 {
itable_handle = ppc_allocator_view_allocate_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
record_size,
true,
);
if itable_handle == 0 || memory.write_u32_be(gdevice + 6, itable_handle).is_none() {
toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = PPC_MEM_FULL_ERR);
return;
}
}
}
let resize_result = ppc_allocator_view_resize_handle(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
itable_handle,
record_size,
);
if resize_result != PPC_NO_ERR {
toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = resize_result);
return;
}
let Some(itable) = memory
.read_u32_be(itable_handle)
.filter(|itable| *itable != 0)
else {
toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = PPC_PARAM_ERR);
return;
};
let wrote_record = memory.write_u32_be(itable, seed).is_some()
&& memory.write_u16_be(itable + 4, resolution).is_some()
&& memory.write_bytes(itable + 6, &table).is_some();
let quickdraw_error = if wrote_record {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
toolbox_startup
.last_quickdraw_error
.with_mut(|error| *error = quickdraw_error);
}
fn ppc_set_entries(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
color_manager_clut: &mut [[u16; 3]; 256],
_tick_count: u32,
toolbox_startup: &mut PpcToolboxStartupState,
) {
let clut_protected = ppc_device_clut_protected(toolbox_startup, current_gdevice);
let start = cpu.gpr[3] as u16 as i16;
let count = cpu.gpr[4] as u16 as i16;
let table = cpu.gpr[5];
if ppc_apply_set_entries(
memory,
start,
count,
table,
current_gdevice,
screen_clut,
&clut_protected,
None,
true,
toolbox_startup,
) {
// SetEntries changes the current GDevice ColorTable and invalidates
// its inverse table. Model the automatic rebuild used on the next
// indexed-color mapping operation. RestoreEntries intentionally does
// not update this logical snapshot.
*color_manager_clut = *screen_clut;
}
}
fn ppc_restore_entries(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
) {
let source_handle = cpu.gpr[3];
let requested_destination_handle = cpu.gpr[4];
let selection = cpu.gpr[5];
let Some(source) = memory
.read_u32_be(source_handle)
.filter(|source| *source != 0)
else {
return;
};
if selection == 0 {
return;
}
let request_last = memory.read_u16_be(selection).unwrap_or(u16::MAX) as i16;
if request_last < 0 {
return;
}
let source_last = usize::from(memory.read_u16_be(source + 6).unwrap_or(0));
let device_table_handle = ppc_gdevice_ctable_handle(memory, current_gdevice).unwrap_or(0);
let destination_handle = if requested_destination_handle == 0 {
device_table_handle
} else {
requested_destination_handle
};
let destination = memory
.read_u32_be(destination_handle)
.filter(|destination| *destination != 0);
let destination_last = destination
.and_then(|destination| memory.read_u16_be(destination + 6))
.map_or(255usize, usize::from);
let updates_device = requested_destination_handle == 0
|| (device_table_handle != 0 && destination_handle == device_table_handle);
// Inside Macintosh Volume V (1986), p. V-144: RestoreEntries unpacks
// the source ColorTable into the selected destination slots without
// changing the destination table seed or rebuilding its inverse table.
for source_index in 0..=usize::from(request_last as u16) {
if source_index > source_last {
break;
}
let Some(request_slot) = selection.checked_add(2 + source_index as u32 * 2) else {
break;
};
let Some(destination_index) = memory.read_u16_be(request_slot).map(|value| value as i16)
else {
break;
};
if destination_index < 0 || destination_index as usize > destination_last {
let _ = memory.write_u16_be(request_slot, u16::MAX);
continue;
}
let source_entry = source + 8 + source_index as u32 * 8;
let (Some(value), Some(red), Some(green), Some(blue)) = (
memory.read_u16_be(source_entry),
memory.read_u16_be(source_entry + 2),
memory.read_u16_be(source_entry + 4),
memory.read_u16_be(source_entry + 6),
) else {
break;
};
let destination_index = destination_index as usize;
if let Some(destination) = destination {
let destination_entry = destination + 8 + destination_index as u32 * 8;
let _ = memory.write_u16_be(destination_entry, value);
let _ = memory.write_u16_be(destination_entry + 2, red);
let _ = memory.write_u16_be(destination_entry + 4, green);
let _ = memory.write_u16_be(destination_entry + 6, blue);
}
if updates_device {
screen_clut[destination_index] = [red, green, blue];
}
}
}
fn ppc_apply_set_entries(
memory: &mut PpcSectionMem,
start: i16,
count: i16,
table: u32,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
clut_protected: &[bool; 256],
replacement_clut: Option<&[[u16; 3]; 256]>,
update_device_ctable: bool,
toolbox_startup: &mut PpcToolboxStartupState,
) -> bool {
if count < 0 || count > 255 || table == 0 {
return false;
}
// Inside Macintosh Volume V (1986), p. V-143: count is a zero-based
// last index. A nonnegative start selects consecutive entries; -1 uses
// each ColorSpec.value as its destination index. Validate every entry
// before changing the device table so an invalid request is atomic.
let mut updates = Vec::with_capacity(count as usize + 1);
for offset in 0..=count as u32 {
let Some(entry) = table.checked_add(offset.saturating_mul(8)) else {
return false;
};
let Some(value) = memory.read_u16_be(entry) else {
return false;
};
let index = if start == -1 {
usize::from(value)
} else if start >= 0 {
let Some(index) = (start as usize).checked_add(offset as usize) else {
return false;
};
index
} else {
return false;
};
if index >= screen_clut.len() {
return false;
}
let (Some(mut red), Some(mut green), Some(mut blue)) = (
entry
.checked_add(2)
.and_then(|addr| memory.read_u16_be(addr)),
entry
.checked_add(4)
.and_then(|addr| memory.read_u16_be(addr)),
entry
.checked_add(6)
.and_then(|addr| memory.read_u16_be(addr)),
) else {
return false;
};
if let Some(replacement_clut) = replacement_clut {
[red, green, blue] = replacement_clut[index];
}
if !clut_protected[index] {
updates.push((index, [red, green, blue]));
}
}
for &(index, color) in &updates {
screen_clut[index] = color;
}
let color_table = update_device_ctable
.then(|| {
memory
.read_u32_be(current_gdevice)
.filter(|device| *device != 0)
.and_then(|device| memory.read_u32_be(device + 22))
.filter(|pixmap_handle| *pixmap_handle != 0)
.and_then(|pixmap_handle| memory.read_u32_be(pixmap_handle))
.filter(|pixmap| *pixmap != 0)
.and_then(|pixmap| memory.read_u32_be(pixmap + 42))
.filter(|table_handle| *table_handle != 0)
.and_then(|table_handle| memory.read_u32_be(table_handle))
.filter(|table_ptr| *table_ptr != 0)
})
.flatten();
if let Some(color_table) = color_table {
for &(index, [red, green, blue]) in &updates {
let Some(entry) = color_table.checked_add(8 + index as u32 * 8) else {
return false;
};
let Some(red_addr) = entry.checked_add(2) else {
return false;
};
let Some(green_addr) = entry.checked_add(4) else {
return false;
};
let Some(blue_addr) = entry.checked_add(6) else {
return false;
};
let _ = memory.write_u16_be(entry, index as u16);
let _ = memory.write_u16_be(red_addr, red);
let _ = memory.write_u16_be(green_addr, green);
let _ = memory.write_u16_be(blue_addr, blue);
}
let seed = ppc_next_ct_seed(toolbox_startup);
let _ = memory.write_u32_be(color_table, seed);
}
true
}
fn ppc_restore_device_clut(
memory: &mut PpcSectionMem,
requested_gdevice: u32,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
color_manager_clut: &mut [[u16; 3]; 256],
toolbox_startup: &mut PpcToolboxStartupState,
) {
let canonical = TrapDispatcher::standard_mac_8bpp_clut();
let mut gdevices = if requested_gdevice == 0 {
let mut represented = vec![PPC_MAIN_GDEVICE, current_gdevice];
represented.extend(toolbox_startup.known_gdevices.iter().copied());
represented.extend(toolbox_startup.active_device_palettes.keys().copied());
represented.extend(
toolbox_startup
.palette_allocations
.iter()
.map(|allocation| allocation.gdevice),
);
represented.extend(toolbox_startup.clut_protected_by_device.keys().copied());
represented.extend(toolbox_startup.clut_reserved_by_device.keys().copied());
represented
} else {
vec![requested_gdevice]
};
gdevices.sort_unstable();
gdevices.dedup();
for gdevice in gdevices {
if gdevice == 0 {
continue;
}
let mut device_clut = if gdevice == current_gdevice {
*screen_clut
} else {
ppc_gdevice_ctable_handle(memory, gdevice)
.and_then(|handle| ppc_read_ctable_clut(memory, handle, &canonical))
.unwrap_or(canonical)
};
let protected = ppc_device_clut_protected(toolbox_startup, gdevice);
let reserved = ppc_device_clut_reserved(toolbox_startup, gdevice);
let mut restored = canonical;
for index in 0..256 {
if protected[index] || reserved[index] {
restored[index] = device_clut[index];
}
}
device_clut = restored;
toolbox_startup.active_device_palettes.remove(&gdevice);
toolbox_startup
.palette_allocations
.retain(|allocation| allocation.gdevice != gdevice);
ppc_write_device_color_table(memory, gdevice, &device_clut, toolbox_startup);
if gdevice == current_gdevice {
*screen_clut = device_clut;
*color_manager_clut = device_clut;
}
}
// Inside Macintosh Volume VI (1991), pp. 20-23--20-24:
// RestoreDeviceClut restores the selected device (or all for NIL) to its
// default colors and posts color updates for intersecting windows.
}
fn ppc_install_device_gamma(
memory: &mut PpcSectionMem,
vd_gamma_ptr: u32,
device_gamma: &mut crate::display::DisplayGamma,
) -> i16 {
let Some(gamma_ptr) = memory.read_u32_be(vd_gamma_ptr) else {
return PPC_PARAM_ERR;
};
if gamma_ptr == 0 {
*device_gamma = crate::display::linear_display_gamma();
return PPC_NO_ERR;
}
let (
Some(version),
Some(gamma_type),
Some(formula_size),
Some(channel_count),
Some(data_count),
Some(data_width),
) = (
memory.read_u16_be(gamma_ptr),
memory.read_u16_be(gamma_ptr.saturating_add(2)),
memory.read_u16_be(gamma_ptr.saturating_add(4)),
memory.read_u16_be(gamma_ptr.saturating_add(6)),
memory.read_u16_be(gamma_ptr.saturating_add(8)),
memory.read_u16_be(gamma_ptr.saturating_add(10)),
)
else {
return PPC_PARAM_ERR;
};
let channel_count = u32::from(channel_count);
let data_count = u32::from(data_count);
let data_width = u32::from(data_width);
if version != 0
|| gamma_type != 0
|| !matches!(channel_count, 1 | 3)
|| data_width > 8
|| data_count != (1u32 << data_width)
{
return PPC_PARAM_ERR;
}
let Some(data_base) = gamma_ptr
.checked_add(12)
.and_then(|address| address.checked_add(u32::from(formula_size)))
else {
return PPC_PARAM_ERR;
};
let shift = 8 - data_width;
let mut installed = [[0u8; 256]; 3];
for (channel, output) in installed.iter_mut().enumerate() {
let source_channel = if channel_count == 1 {
0
} else {
channel as u32
};
let Some(source_base) = source_channel
.checked_mul(data_count)
.and_then(|offset| data_base.checked_add(offset))
else {
return PPC_PARAM_ERR;
};
for (input, value) in output.iter_mut().enumerate() {
let Some(source) = source_base.checked_add((input as u32) >> shift) else {
return PPC_PARAM_ERR;
};
let Some(output_value) = memory.read_u8(source) else {
return PPC_PARAM_ERR;
};
*value = output_value;
}
}
*device_gamma = installed;
PPC_NO_ERR
}
fn ppc_driver_control(
memory: &mut PpcSectionMem,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
display_gamma: &SharedProcessDisplayGamma,
toolbox_startup: &mut PpcToolboxStartupState,
cs_code: i16,
cs_param: u32,
) -> i16 {
const CONTROL_ERR: i16 = -17;
let clut_protected = ppc_device_clut_protected(toolbox_startup, current_gdevice);
match cs_code {
2 => {
let valid = cs_param.checked_add(11).is_some_and(|end| {
ppc_memory_can_write_bytes(memory, cs_param, end - cs_param + 1)
});
if !valid {
PPC_PARAM_ERR
} else {
let _ = memory.write_u16_be(cs_param + 6, 0);
let _ = memory.write_u32_be(cs_param + 8, PPC_MAIN_SCREEN_BASE);
PPC_NO_ERR
}
}
3 | 8 => {
let request = memory.read_u32_be(cs_param);
let fields = request.and_then(|request| {
Some((
memory.read_u32_be(request)?,
memory.read_u16_be(request.checked_add(4)?)? as i16,
memory.read_u16_be(request.checked_add(6)?)? as i16,
))
});
match fields {
Some((table, start, count))
if ppc_apply_set_entries(
memory,
start,
count,
table,
current_gdevice,
screen_clut,
&clut_protected,
None,
false,
toolbox_startup,
) =>
{
// Designing Cards and Drivers, 3rd ed. (1992), pp. 245–248:
// cscSetEntries supplies values directly to the video
// device. Preserve a guest-installed gamma table, but do
// not apply the Color Manager compatibility transfer to
// presentation-ready driver entries.
display_gamma.set_implicit(crate::display::linear_display_gamma());
PPC_NO_ERR
}
_ => PPC_PARAM_ERR,
}
}
4 => memory
.read_u32_be(cs_param)
.map(|vd_gamma| {
let mut installed = display_gamma.table();
let result = ppc_install_device_gamma(memory, vd_gamma, &mut installed);
if result == PPC_NO_ERR {
display_gamma.install(installed);
}
result
})
.unwrap_or(PPC_PARAM_ERR),
_ => CONTROL_ERR,
}
}
fn ppc_control(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
display_gamma: &SharedProcessDisplayGamma,
toolbox_startup: &mut PpcToolboxStartupState,
) -> i16 {
let ref_num = cpu.gpr[3] as u16 as i16;
if ref_num != 0 {
return -21; // badUnitErr: Systemless only exposes the main display DCE.
}
// Inside Macintosh: Devices (1994), pp. 1-75--1-76: Control is the
// high-level synchronous form of PBControl and passes the driver-specific
// csParam block directly. Both entry points share the display selectors.
ppc_driver_control(
memory,
current_gdevice,
screen_clut,
display_gamma,
toolbox_startup,
cpu.gpr[4] as u16 as i16,
cpu.gpr[5],
)
}
fn ppc_pb_control(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
current_gdevice: u32,
screen_clut: &mut [[u16; 3]; 256],
display_gamma: &SharedProcessDisplayGamma,
toolbox_startup: &mut PpcToolboxStartupState,
) -> i16 {
let parameter_block = cpu.gpr[3];
let Some(cs_code_addr) = parameter_block.checked_add(26) else {
return PPC_PARAM_ERR;
};
let Some(cs_code) = memory.read_u16_be(cs_code_addr).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(cs_param) = parameter_block.checked_add(28) else {
return PPC_PARAM_ERR;
};
// Inside Macintosh: Devices (1994), pp. 1-79--1-80: PBControl uses a
// CntrlParam record with csCode at byte 26 and driver-specific csParam
// data at byte 28. The built-in display driver selectors below follow
// Designing Cards and Drivers, 3rd ed. (1992), pp. 235 and 245--248.
let result = ppc_driver_control(
memory,
current_gdevice,
screen_clut,
display_gamma,
toolbox_startup,
cs_code,
cs_param,
);
if let Some(result_addr) = parameter_block.checked_add(16) {
let _ = memory.write_u16_be(result_addr, result as u16);
}
result
}
fn ppc_pb_status(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> i16 {
const STATUS_ERR: i16 = -18;
let parameter_block = cpu.gpr[3];
let result = (|| {
let ref_num = memory.read_u16_be(parameter_block.checked_add(24)?)? as i16;
if ref_num != 0 {
return Some(-21); // badUnitErr: no matching Device Manager driver.
}
let cs_code = memory.read_u16_be(parameter_block.checked_add(26)?)? as i16;
let cs_param = parameter_block.checked_add(28)?;
// Inside Macintosh: Devices (1994), pp. 1-65 and 1-83: PBStatus
// uses CntrlParam.csCode/csParam, and selector 1 is handled by the
// Device Manager itself by returning the driver's DCE handle.
match cs_code {
1 => memory
.write_u32_be(cs_param, PPC_MAIN_DCE_HANDLE)
.map(|()| PPC_NO_ERR),
// Universal Interfaces 3.4 Video.h defines cscGetGamma (8) as a
// status request whose csParam contains a VDGammaRecord pointer;
// the driver stores its device-owned GammaTbl pointer there.
8 => {
let vd_gamma = memory.read_u32_be(cs_param)?;
memory
.write_u32_be(vd_gamma, PPC_MAIN_GAMMA_TABLE)
.map(|()| PPC_NO_ERR)
}
// Inside Macintosh: Devices (1994), p. 1-47: a driver must
// return statusErr for status selectors that it does not support.
_ => Some(STATUS_ERR),
}
})()
.unwrap_or(PPC_PARAM_ERR);
if parameter_block != 0 {
if let Some(result_addr) = parameter_block.checked_add(16) {
let _ = memory.write_u16_be(result_addr, result as u16);
}
}
result
}
fn ppc_get_ctable(
cpu: &PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
current_gworld: u32,
quickdraw_hilite_colors: &SharedProcessQuickDrawHiliteColors,
) -> u32 {
let ct_id = cpu.gpr[3] as u16 as i16;
// Imaging With QuickDraw 1994, 4-92 through 4-93: GetCTable returns a
// newly allocated ColorTable handle copied from a 'clut' resource, and
// recognizes the standard depth IDs 1, 2, 4, and 8.
let data = match ct_id {
1 | 2 | 4 | 8 => TrapDispatcher::standard_mac_indexed_clut(ct_id as u16)
.map(|(clut, entry_count)| (clut, entry_count, ct_id as u32)),
66 | 68 | 72 => {
let depth = (ct_id - 64) as u16;
let hilite = ppc_current_hilite_color(
memory,
current_gworld,
quickdraw_hilite_colors,
);
TrapDispatcher::standard_mac_enhanced_clut(
depth,
(hilite.red, hilite.green, hilite.blue),
)
.map(|(clut, entry_count)| (clut, entry_count, u32::from(depth)))
}
_ => None,
}
.map(|(clut, entry_count, seed)| {
let mut data = Vec::with_capacity(8 + entry_count * 8);
data.extend_from_slice(&seed.to_be_bytes());
data.extend_from_slice(&0u16.to_be_bytes());
data.extend_from_slice(&((entry_count - 1) as u16).to_be_bytes());
for (index, rgb) in clut.into_iter().take(entry_count).enumerate() {
data.extend_from_slice(&(index as u16).to_be_bytes());
data.extend_from_slice(&rgb[0].to_be_bytes());
data.extend_from_slice(&rgb[1].to_be_bytes());
data.extend_from_slice(&rgb[2].to_be_bytes());
}
data
})
.or_else(|| {
let index = ppc_vfs_resource_index(
vfs_resources,
current_resource_refnum,
u32::from_be_bytes(*b"clut"),
ct_id,
false,
)?;
let data = vfs_resources[index].data.clone();
(data.len() >= 8).then_some(data)
});
let Some(data) = data else {
return 0;
};
let handle = ppc_process_alloc_handle_with_bytes(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
&data,
);
*last_mem_error = if handle == 0 {
PPC_MEM_FULL_ERR
} else {
PPC_NO_ERR
};
handle
}
pub(super) fn ppc_read_ctable_clut(
memory: &mut PpcSectionMem,
ctable_handle: u32,
base_clut: &[[u16; 3]; 256],
) -> Option<[[u16; 3]; 256]> {
let ctable = memory
.read_u32_be(ctable_handle)
.filter(|ctable| *ctable != 0)?;
let flags = memory.read_u16_be(ctable.checked_add(4)?)?;
let last_entry = usize::from(memory.read_u16_be(ctable.checked_add(6)?)?);
let entry_count = last_entry.saturating_add(1).min(256);
let mut clut = *base_clut;
for slot in 0..entry_count {
let entry = ctable.checked_add(8 + slot as u32 * 8)?;
let value = usize::from(memory.read_u16_be(entry)?);
let index = if flags & 0x8000 != 0 { slot } else { value };
if index >= clut.len() {
continue;
}
clut[index] = [
memory.read_u16_be(entry.checked_add(2)?)?,
memory.read_u16_be(entry.checked_add(4)?)?,
memory.read_u16_be(entry.checked_add(6)?)?,
];
}
Some(clut)
}
fn ppc_new_pixmap(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
current_gdevice: u32,
) -> u32 {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 4-85--4-86:
// NewPixMap clones the current device PixMap except for its ColorTable.
// It allocates that handle but deliberately leaves the table uninitialized;
// the application must install a table that describes its pixels.
let source_pixmap = memory
.read_u32_be(current_gdevice)
.filter(|device| *device != 0)
.and_then(|device| memory.read_u32_be(device.checked_add(22)?))
.filter(|handle| *handle != 0)
.and_then(|handle| memory.read_u32_be(handle))
.filter(|pixmap| *pixmap != 0)
.unwrap_or(PPC_MAIN_PIXMAP);
let Some(mut pixmap_bytes) = ppc_memory_read_bytes(memory, source_pixmap, PPC_PIXMAP_SIZE)
else {
*last_mem_error = PPC_PARAM_ERR;
return 0;
};
let ctable_bytes = [0; 8];
let ctable_size = u32::try_from(ctable_bytes.len()).unwrap_or(u32::MAX);
if !ppc_heap_can_alloc_sequence(
memory,
*heap_cursor,
heap_limit,
&[4, ctable_size, 4, PPC_PIXMAP_SIZE],
) {
*last_mem_error = PPC_MEM_FULL_ERR;
return 0;
}
let ctable_handle = ppc_process_alloc_handle_with_bytes(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
&ctable_bytes,
);
let pixmap_handle = ppc_process_alloc_handle(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
PPC_PIXMAP_SIZE,
true,
);
if ctable_handle == 0 || pixmap_handle == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return 0;
}
pixmap_bytes[0..4].copy_from_slice(&0u32.to_be_bytes());
pixmap_bytes[22..26].copy_from_slice(&0x0048_0000u32.to_be_bytes());
pixmap_bytes[26..30].copy_from_slice(&0x0048_0000u32.to_be_bytes());
pixmap_bytes[42..46].copy_from_slice(&ctable_handle.to_be_bytes());
let Some(pixmap) = memory.read_u32_be(pixmap_handle) else {
*last_mem_error = PPC_PARAM_ERR;
return 0;
};
if memory.write_bytes(pixmap, &pixmap_bytes).is_none() {
*last_mem_error = PPC_PARAM_ERR;
return 0;
}
*last_mem_error = PPC_NO_ERR;
pixmap_handle
}
fn ppc_dispose_pixmap(
pixmap_handle: u32,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
indexed_screen_ctables: &mut HashMap<u32, u32>,
) {
if pixmap_handle == 0 {
return;
}
// The same reference specifies that DisposePixMap owns both the PixMap
// record and its pmTable handle. Read pmTable before invalidating pm.
let ctable_handle = memory
.read_u32_be(pixmap_handle)
.filter(|pixmap| *pixmap != 0)
.and_then(|pixmap| memory.read_u32_be(pixmap + 42))
.filter(|handle| *handle != 0)
.or_else(|| indexed_screen_ctables.remove(&pixmap_handle))
.unwrap_or(0);
if ctable_handle != 0 {
let _ = ppc_dispose_process_native_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
ctable_handle,
);
indexed_screen_ctables.retain(|_, handle| *handle != ctable_handle);
}
indexed_screen_ctables.remove(&pixmap_handle);
let _ = ppc_dispose_process_native_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
pixmap_handle,
);
}
fn ppc_text_width(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
text_font: i16,
text_size: i16,
text_face: u8,
) -> u32 {
let text_ptr = cpu.gpr[3];
let first_byte = cpu.gpr[4];
let byte_count = cpu.gpr[5];
let mut bytes = Vec::with_capacity(byte_count.min(i16::MAX as u32) as usize);
for offset in 0..byte_count {
let Some(addr) = text_ptr
.checked_add(first_byte)
.and_then(|base| base.checked_add(offset))
else {
break;
};
bytes.push(memory.read_u8(addr).unwrap_or(0));
}
ppc_text_width_bytes(text_font, text_size, text_face, &bytes).max(0) as u32
}
fn ppc_get_font_info(memory: &mut PpcSectionMem, info_ptr: u32, text_font: i16, text_size: i16) {
if info_ptr == 0 || !ppc_memory_can_write_bytes(memory, info_ptr, 8) {
return;
}
// Inside Macintosh Volume I (1985), p. I-173: FontInfo contains the
// current port font's ascent, descent, maximum advance, and leading.
let (face, numerator, denominator) = get_font_face_scale_ratio(text_font, text_size);
let metrics = face.metrics;
let _ = memory.write_u16_be(
info_ptr,
ppc_scale_font_value(i32::from(metrics.ascent), numerator, denominator) as u16,
);
let _ = memory.write_u16_be(
info_ptr + 2,
ppc_scale_font_value(i32::from(metrics.descent), numerator, denominator) as u16,
);
let _ = memory.write_u16_be(
info_ptr + 4,
ppc_scale_font_value(i32::from(metrics.wid_max), numerator, denominator) as u16,
);
let _ = memory.write_u16_be(
info_ptr + 6,
ppc_scale_font_value(i32::from(metrics.leading), numerator, denominator) as u16,
);
}
fn ppc_font_metrics(memory: &mut PpcSectionMem, metrics_ptr: u32, text_font: i16, text_size: i16) {
if metrics_ptr == 0 || !ppc_memory_can_write_bytes(memory, metrics_ptr, 20) {
return;
}
// Inside Macintosh: Text (1993), pp. 4-54--4-55: FMetricRec stores
// ascent, descent, leading, and maximum width as Fixed values, followed
// by a handle to the global width table. Systemless does not model that
// table, matching the 68k HLE by returning NIL for its handle.
let (face, numerator, denominator) = get_font_face_scale_ratio(text_font, text_size);
let metrics = face.metrics;
let to_fixed = |value: i16| -> u32 { (i32::from(value) as u32) << 16 };
let _ = memory.write_u32_be(
metrics_ptr,
to_fixed(ppc_scale_font_value(
i32::from(metrics.ascent),
numerator,
denominator,
)),
);
let _ = memory.write_u32_be(
metrics_ptr + 4,
to_fixed(ppc_scale_font_value(
i32::from(metrics.descent),
numerator,
denominator,
)),
);
let _ = memory.write_u32_be(
metrics_ptr + 8,
to_fixed(ppc_scale_font_value(
i32::from(metrics.leading),
numerator,
denominator,
)),
);
let _ = memory.write_u32_be(
metrics_ptr + 12,
to_fixed(ppc_scale_font_value(
i32::from(metrics.wid_max),
numerator,
denominator,
)),
);
let _ = memory.write_u32_be(metrics_ptr + 16, 0);
}
fn ppc_te_read_rect(memory: &mut PpcSectionMem, rect_ptr: u32) -> Option<[u16; 4]> {
Some([
memory.read_u16_be(rect_ptr)?,
memory.read_u16_be(rect_ptr.checked_add(2)?)?,
memory.read_u16_be(rect_ptr.checked_add(4)?)?,
memory.read_u16_be(rect_ptr.checked_add(6)?)?,
])
}
fn ppc_te_write_rect(memory: &mut PpcSectionMem, rect_ptr: u32, rect: [u16; 4]) -> bool {
rect.iter().copied().enumerate().all(|(index, value)| {
memory
.write_u16_be(rect_ptr + index as u32 * 2, value)
.is_some()
})
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_te_initialize_record(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
dest_rect_ptr: u32,
view_rect_ptr: u32,
current_port: u32,
tick_count: u32,
text_mode: i16,
text_size: i16,
fore_color: PpcRgbColor,
styled: bool,
) -> u32 {
let (Some(dest_rect), Some(view_rect)) = (
ppc_te_read_rect(memory, dest_rect_ptr),
ppc_te_read_rect(memory, view_rect_ptr),
) else {
return 0;
};
let te_handle = ppc_allocator_view_allocate_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
PPC_TE_REC_MIN_SIZE,
true,
);
if te_handle == 0 {
return 0;
}
let Some(te_ptr) = memory.read_u32_be(te_handle).filter(|ptr| *ptr != 0) else {
ppc_te_cleanup_handles(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&[te_handle],
);
return 0;
};
let mut allocated_handles = vec![te_handle];
let h_text = ppc_allocator_view_allocate_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
0,
true,
);
if h_text == 0 {
ppc_te_cleanup_handles(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&allocated_handles,
);
return 0;
}
allocated_handles.push(h_text);
let text_font = ppc_current_text_font(memory, current_port);
let text_face = memory
.read_u8(current_port.wrapping_add(PPC_CGRAF_PORT_TX_FACE_OFFSET))
.unwrap_or(0);
let (font_face, scale) = get_font_face_scaled(text_font, text_size);
let metrics = font_face.metrics;
let ascent = metrics.ascent.saturating_mul(scale);
let line_height = ascent
.saturating_add(metrics.descent.saturating_mul(scale))
.saturating_add(metrics.leading.saturating_mul(scale));
let _ = ppc_te_write_rect(memory, te_ptr + PPC_TE_DEST_RECT_OFFSET, dest_rect);
let _ = ppc_te_write_rect(memory, te_ptr + PPC_TE_VIEW_RECT_OFFSET, view_rect);
let _ = ppc_te_write_rect(memory, te_ptr + PPC_TE_SEL_RECT_OFFSET, dest_rect);
let _ = memory.write_u16_be(te_ptr + PPC_TE_SEL_POINT_OFFSET, dest_rect[0]);
let _ = memory.write_u16_be(te_ptr + PPC_TE_SEL_POINT_OFFSET + 2, dest_rect[1]);
let _ = memory.write_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET, 0);
let _ = memory.write_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET, 0);
let _ = memory.write_u32_be(te_ptr + PPC_TE_CARET_TIME_OFFSET, tick_count);
let _ = memory.write_u16_be(te_ptr + PPC_TE_CARET_STATE_OFFSET, 0);
let _ = memory.write_u16_be(te_ptr + PPC_TE_JUST_OFFSET, 0);
let _ = memory.write_u16_be(te_ptr + PPC_TE_LENGTH_OFFSET, 0);
let _ = memory.write_u32_be(te_ptr + PPC_TE_HTEXT_OFFSET, h_text);
let _ = memory.write_u16_be(te_ptr + PPC_TE_TX_MODE_OFFSET, text_mode as u16);
let _ = memory.write_u32_be(te_ptr + PPC_TE_IN_PORT_OFFSET, current_port);
let _ = memory.write_u16_be(te_ptr + PPC_TE_N_LINES_OFFSET, 0);
let _ = memory.write_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET, 0);
if !styled {
let _ = memory.write_u16_be(te_ptr + PPC_TE_LINE_HEIGHT_OFFSET, line_height as u16);
let _ = memory.write_u16_be(te_ptr + PPC_TE_FONT_ASCENT_OFFSET, ascent as u16);
let _ = memory.write_u16_be(te_ptr + PPC_TE_TX_FONT_OFFSET, text_font as u16);
let _ = memory.write_u8(te_ptr + PPC_TE_TX_FACE_OFFSET, text_face);
let _ = memory.write_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET, text_size as u16);
return te_handle;
}
// Inside Macintosh: Text (1993), p. 2-78: TEStyleNew installs -1 in
// txSize, lineHeight, and fontAscent, overlays a TEStyleHandle on
// txFont/txFace, and creates the null style scrap used for its lifetime.
let style_table = ppc_allocator_view_allocate_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
PPC_TE_ST_ELEMENT_SIZE,
true,
);
if style_table == 0 {
ppc_te_cleanup_handles(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&allocated_handles,
);
return 0;
}
allocated_handles.push(style_table);
let lh_table = ppc_allocator_view_allocate_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
PPC_TE_LH_ELEMENT_SIZE,
true,
);
if lh_table == 0 {
ppc_te_cleanup_handles(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&allocated_handles,
);
return 0;
}
allocated_handles.push(lh_table);
let null_scrap = ppc_allocator_view_allocate_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
PPC_TE_STYLE_SCRAP_REC_SIZE,
true,
);
if null_scrap == 0 {
ppc_te_cleanup_handles(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&allocated_handles,
);
return 0;
}
allocated_handles.push(null_scrap);
let null_style = ppc_allocator_view_allocate_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
PPC_TE_NULL_STYLE_REC_SIZE,
true,
);
if null_style == 0 {
ppc_te_cleanup_handles(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&allocated_handles,
);
return 0;
}
allocated_handles.push(null_style);
let style_handle = ppc_allocator_view_allocate_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
PPC_TE_STYLE_REC_SIZE,
true,
);
if style_handle == 0 {
ppc_te_cleanup_handles(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&allocated_handles,
);
return 0;
}
allocated_handles.push(style_handle);
if let Some(style_table_ptr) = memory.read_u32_be(style_table).filter(|ptr| *ptr != 0) {
let _ = memory.write_u16_be(style_table_ptr, 1);
let _ = memory.write_u16_be(style_table_ptr + 2, line_height as u16);
let _ = memory.write_u16_be(style_table_ptr + 4, ascent as u16);
let _ = memory.write_u16_be(style_table_ptr + 6, text_font as u16);
let _ = memory.write_u8(style_table_ptr + 8, text_face);
let _ = memory.write_u16_be(style_table_ptr + 10, text_size as u16);
let _ = memory.write_u16_be(style_table_ptr + 12, fore_color.red);
let _ = memory.write_u16_be(style_table_ptr + 14, fore_color.green);
let _ = memory.write_u16_be(style_table_ptr + 16, fore_color.blue);
}
if let Some(lh_table_ptr) = memory.read_u32_be(lh_table).filter(|ptr| *ptr != 0) {
let _ = memory.write_u16_be(lh_table_ptr, line_height as u16);
let _ = memory.write_u16_be(lh_table_ptr + 2, ascent as u16);
}
if let Some(scrap_ptr) = memory.read_u32_be(null_scrap).filter(|ptr| *ptr != 0) {
let _ = memory.write_u16_be(scrap_ptr, 0);
let _ = memory.write_u32_be(scrap_ptr + 2, 0);
let _ = memory.write_u16_be(scrap_ptr + 6, line_height as u16);
let _ = memory.write_u16_be(scrap_ptr + 8, ascent as u16);
let _ = memory.write_u16_be(scrap_ptr + 10, text_font as u16);
let _ = memory.write_u8(scrap_ptr + 12, text_face);
let _ = memory.write_u16_be(scrap_ptr + 14, text_size as u16);
let _ = memory.write_u16_be(scrap_ptr + 16, fore_color.red);
let _ = memory.write_u16_be(scrap_ptr + 18, fore_color.green);
let _ = memory.write_u16_be(scrap_ptr + 20, fore_color.blue);
}
if let Some(null_style_ptr) = memory.read_u32_be(null_style).filter(|ptr| *ptr != 0) {
let _ = memory.write_u32_be(null_style_ptr + PPC_TE_NULL_STYLE_SCRAP_OFFSET, null_scrap);
}
if let Some(style_ptr) = memory.read_u32_be(style_handle).filter(|ptr| *ptr != 0) {
let _ = memory.write_u16_be(style_ptr + PPC_TE_STYLE_N_RUNS_OFFSET, 1);
let _ = memory.write_u16_be(style_ptr + PPC_TE_STYLE_N_STYLES_OFFSET, 1);
let _ = memory.write_u32_be(style_ptr + PPC_TE_STYLE_TABLE_OFFSET, style_table);
let _ = memory.write_u32_be(style_ptr + PPC_TE_STYLE_LH_TABLE_OFFSET, lh_table);
let _ = memory.write_u32_be(style_ptr + PPC_TE_STYLE_NULL_STYLE_OFFSET, null_style);
let _ = memory.write_u16_be(style_ptr + PPC_TE_STYLE_RUNS_OFFSET, 0);
let _ = memory.write_u16_be(style_ptr + PPC_TE_STYLE_RUNS_OFFSET + 2, 0);
let _ = memory.write_u16_be(style_ptr + PPC_TE_STYLE_RUNS_OFFSET + 4, 1);
let _ = memory.write_u16_be(style_ptr + PPC_TE_STYLE_RUNS_OFFSET + 6, 0xffff);
}
let _ = memory.write_u16_be(te_ptr + PPC_TE_LINE_HEIGHT_OFFSET, 0xffff);
let _ = memory.write_u16_be(te_ptr + PPC_TE_FONT_ASCENT_OFFSET, 0xffff);
let _ = memory.write_u32_be(te_ptr + PPC_TE_TX_FONT_OFFSET, style_handle);
let _ = memory.write_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET, 0xffff);
te_handle
}
pub(super) fn ppc_te_record_ptr(memory: &mut PpcSectionMem, te_handle: u32) -> Option<u32> {
memory.read_u32_be(te_handle).filter(|ptr| *ptr != 0)
}
pub(super) fn ppc_te_text_bytes(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
te_handle: u32,
) -> Option<Vec<u8>> {
let te_ptr = ppc_te_record_ptr(memory, te_handle)?;
let text_handle = memory.read_u32_be(te_ptr + PPC_TE_HTEXT_OFFSET)?;
let text_ptr = memory.read_u32_be(text_handle)?;
let length = u32::from(memory.read_u16_be(te_ptr + PPC_TE_LENGTH_OFFSET)?);
ppc_memory_read_bytes(memory, text_ptr, length).or_else(|| {
handles
.iter()
.find(|record| record.handle == text_handle && record.size == 0)
.map(|_| Vec::new())
})
}
fn ppc_te_font_lookup_size(size: i16) -> i16 {
if size == 0 {
PPC_QD_TEXT_SIZE_SYSTEM
} else {
size.max(1)
}
}
fn ppc_te_resolved_style_from_parts(
font: i16,
face: u8,
size: i16,
color: PpcRgbColor,
line_height: i16,
ascent: i16,
) -> PpcTeResolvedStyle {
let size = ppc_te_font_lookup_size(size);
let metrics = get_font_metrics(font, size);
let fallback_height = metrics
.ascent
.saturating_add(metrics.descent)
.saturating_add(metrics.leading);
PpcTeResolvedStyle {
font,
face,
size,
color,
line_height: if line_height > 0 {
line_height
} else {
fallback_height.max(1)
},
ascent: if ascent > 0 {
ascent
} else {
metrics.ascent.max(0)
},
}
}
fn ppc_te_style_from_table_element(
memory: &mut PpcSectionMem,
style_ptr: u32,
) -> Option<PpcTeResolvedStyle> {
Some(ppc_te_resolved_style_from_parts(
memory.read_u16_be(style_ptr + 6)? as i16,
memory.read_u8(style_ptr + 8)?,
memory.read_u16_be(style_ptr + 10)? as i16,
PpcRgbColor {
red: memory.read_u16_be(style_ptr + 12)?,
green: memory.read_u16_be(style_ptr + 14)?,
blue: memory.read_u16_be(style_ptr + 16)?,
},
memory.read_u16_be(style_ptr + 2)? as i16,
memory.read_u16_be(style_ptr + 4)? as i16,
))
}
fn ppc_te_null_style_scrap_handle(memory: &mut PpcSectionMem, te_handle: u32) -> u32 {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return 0;
};
let style_handle = memory
.read_u32_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap_or(0);
let style_ptr = memory
.read_u32_be(style_handle)
.filter(|ptr| *ptr != 0)
.unwrap_or(0);
let null_style_handle = memory
.read_u32_be(style_ptr + PPC_TE_STYLE_NULL_STYLE_OFFSET)
.unwrap_or(0);
let null_style_ptr = memory
.read_u32_be(null_style_handle)
.filter(|ptr| *ptr != 0)
.unwrap_or(0);
memory
.read_u32_be(null_style_ptr + PPC_TE_NULL_STYLE_SCRAP_OFFSET)
.unwrap_or(0)
}
fn ppc_te_null_style_resolved_style(
memory: &mut PpcSectionMem,
te_handle: u32,
) -> Option<PpcTeResolvedStyle> {
let scrap_handle = ppc_te_null_style_scrap_handle(memory, te_handle);
let scrap_ptr = memory.read_u32_be(scrap_handle).filter(|ptr| *ptr != 0)?;
if memory.read_u16_be(scrap_ptr + PPC_TE_SCRAP_N_STYLES_OFFSET)? == 0 {
return None;
}
let element = scrap_ptr + PPC_TE_SCRAP_STYLE_TAB_OFFSET;
Some(ppc_te_resolved_style_from_parts(
memory.read_u16_be(element + PPC_TE_SCRAP_STYLE_FONT_OFFSET)? as i16,
memory.read_u8(element + PPC_TE_SCRAP_STYLE_FACE_OFFSET)?,
memory.read_u16_be(element + PPC_TE_SCRAP_STYLE_SIZE_OFFSET)? as i16,
PpcRgbColor {
red: memory.read_u16_be(element + PPC_TE_SCRAP_STYLE_COLOR_OFFSET)?,
green: memory.read_u16_be(element + PPC_TE_SCRAP_STYLE_COLOR_OFFSET + 2)?,
blue: memory.read_u16_be(element + PPC_TE_SCRAP_STYLE_COLOR_OFFSET + 4)?,
},
memory.read_u16_be(element + PPC_TE_SCRAP_STYLE_HEIGHT_OFFSET)? as i16,
memory.read_u16_be(element + PPC_TE_SCRAP_STYLE_ASCENT_OFFSET)? as i16,
))
}
fn ppc_te_set_null_style(
memory: &mut PpcSectionMem,
te_handle: u32,
mode: u16,
text_style_ptr: u32,
) -> bool {
if text_style_ptr == 0 {
return false;
}
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return false;
};
if memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET) != Some(0xffff) {
return false;
}
let scrap_handle = ppc_te_null_style_scrap_handle(memory, te_handle);
let Some(scrap_ptr) = memory.read_u32_be(scrap_handle).filter(|ptr| *ptr != 0) else {
return false;
};
let element = scrap_ptr + PPC_TE_SCRAP_STYLE_TAB_OFFSET;
let source_font = memory.read_u16_be(text_style_ptr).unwrap_or(0);
let source_face = memory.read_u8(text_style_ptr + 2).unwrap_or(0);
let source_size = memory.read_u16_be(text_style_ptr + 4).unwrap_or(0);
let source_color = [
memory.read_u16_be(text_style_ptr + 6).unwrap_or(0),
memory.read_u16_be(text_style_ptr + 8).unwrap_or(0),
memory.read_u16_be(text_style_ptr + 10).unwrap_or(0),
];
let _ = memory.write_u16_be(scrap_ptr + PPC_TE_SCRAP_N_STYLES_OFFSET, 1);
if mode & 0x0001 != 0 {
let _ = memory.write_u16_be(
element + PPC_TE_SCRAP_STYLE_FONT_OFFSET,
source_font,
);
}
if mode & 0x0002 != 0 {
let _ = memory.write_u8(
element + PPC_TE_SCRAP_STYLE_FACE_OFFSET,
source_face,
);
}
if mode & 0x0004 != 0 {
let _ = memory.write_u16_be(
element + PPC_TE_SCRAP_STYLE_SIZE_OFFSET,
source_size,
);
}
if mode & 0x0008 != 0 {
for (offset, color) in [0u32, 2, 4].into_iter().zip(source_color) {
let _ = memory.write_u16_be(
element + PPC_TE_SCRAP_STYLE_COLOR_OFFSET + offset,
color,
);
}
}
let font = memory
.read_u16_be(element + PPC_TE_SCRAP_STYLE_FONT_OFFSET)
.unwrap_or(0) as i16;
let size = ppc_te_font_lookup_size(
memory
.read_u16_be(element + PPC_TE_SCRAP_STYLE_SIZE_OFFSET)
.unwrap_or(0) as i16,
);
let metrics = get_font_metrics(font, size);
let _ = memory.write_u16_be(
element + PPC_TE_SCRAP_STYLE_HEIGHT_OFFSET,
metrics
.ascent
.saturating_add(metrics.descent)
.saturating_add(metrics.leading) as u16,
);
let _ = memory.write_u16_be(
element + PPC_TE_SCRAP_STYLE_ASCENT_OFFSET,
metrics.ascent as u16,
);
true
}
fn ppc_te_fallback_style(memory: &mut PpcSectionMem, te_ptr: u32) -> PpcTeResolvedStyle {
let font = memory
.read_u16_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap_or(PPC_QD_TEXT_FONT_DEFAULT as u16) as i16;
let size = memory
.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET)
.unwrap_or(PPC_QD_TEXT_SIZE_SYSTEM as u16) as i16;
let face = memory.read_u8(te_ptr + PPC_TE_TX_FACE_OFFSET).unwrap_or(0);
let size = ppc_te_font_lookup_size(size);
let (font_face, scale) = get_font_face_scaled(font, size);
let ascent = font_face.metrics.ascent.saturating_mul(scale);
let line_height = ascent
.saturating_add(font_face.metrics.descent.saturating_mul(scale))
.saturating_add(font_face.metrics.leading.saturating_mul(scale));
ppc_te_resolved_style_from_parts(font, face, size, PPC_RGB_BLACK, line_height, ascent)
}
fn ppc_te_style_at_offset(runs: &[PpcTeStyleRun], offset: usize) -> PpcTeResolvedStyle {
let mut style = runs
.first()
.map(|run| run.style)
.unwrap_or_else(|| ppc_te_resolved_style_from_parts(0, 0, 0, PPC_RGB_BLACK, 0, 0));
for run in runs {
if run.start > offset {
break;
}
style = run.style;
}
style
}
fn ppc_te_style_runs(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
te_handle: u32,
text_len: usize,
) -> Vec<PpcTeStyleRun> {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return Vec::new();
};
let fallback = ppc_te_fallback_style(memory, te_ptr);
if memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET) != Some(0xffff) {
return vec![PpcTeStyleRun {
start: 0,
style_index: 0,
style: fallback,
}];
}
let style_handle = memory
.read_u32_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap_or(0);
let Some(style_ptr) = memory.read_u32_be(style_handle).filter(|ptr| *ptr != 0) else {
return vec![PpcTeStyleRun {
start: 0,
style_index: 0,
style: fallback,
}];
};
let Some(style_table_handle) = memory
.read_u32_be(style_ptr + PPC_TE_STYLE_TABLE_OFFSET)
.filter(|handle| *handle != 0)
else {
return vec![PpcTeStyleRun {
start: 0,
style_index: 0,
style: fallback,
}];
};
let Some(style_table_ptr) = memory
.read_u32_be(style_table_handle)
.filter(|ptr| *ptr != 0)
else {
return vec![PpcTeStyleRun {
start: 0,
style_index: 0,
style: fallback,
}];
};
let n_runs = usize::from(
memory
.read_u16_be(style_ptr + PPC_TE_STYLE_N_RUNS_OFFSET)
.unwrap_or(0),
);
let n_styles = usize::from(
memory
.read_u16_be(style_ptr + PPC_TE_STYLE_N_STYLES_OFFSET)
.unwrap_or(0),
);
let max_runs = handles
.iter()
.find(|record| record.handle == style_handle)
.map(|record| {
usize::try_from(record.size.saturating_sub(PPC_TE_STYLE_RUNS_OFFSET) / 4)
.unwrap_or(usize::MAX)
})
.unwrap_or(n_runs);
let max_styles = handles
.iter()
.find(|record| record.handle == style_table_handle)
.map(|record| usize::try_from(record.size / PPC_TE_ST_ELEMENT_SIZE).unwrap_or(usize::MAX))
.unwrap_or(n_styles);
let run_count = n_runs.min(max_runs).min(4096);
let style_count = n_styles.min(max_styles).min(4096);
if run_count == 0 || style_count == 0 {
return vec![PpcTeStyleRun {
start: 0,
style_index: 0,
style: fallback,
}];
}
let mut runs = Vec::with_capacity(run_count);
for run_index in 0..run_count {
let run_ptr = style_ptr + PPC_TE_STYLE_RUNS_OFFSET + (run_index as u32 * 4);
let style_index_word = memory.read_u16_be(run_ptr + 2).unwrap_or(0xffff);
if style_index_word == 0xffff {
break;
}
let style_index = usize::from(style_index_word);
if style_index >= style_count {
continue;
}
let element_ptr = style_table_ptr + style_index as u32 * PPC_TE_ST_ELEMENT_SIZE;
let Some(style) = ppc_te_style_from_table_element(memory, element_ptr) else {
continue;
};
runs.push(PpcTeStyleRun {
start: usize::from(memory.read_u16_be(run_ptr).unwrap_or(0)).min(text_len),
style_index,
style,
});
}
if runs.is_empty() {
return vec![PpcTeStyleRun {
start: 0,
style_index: 0,
style: fallback,
}];
}
runs.sort_by_key(|run| run.start);
let mut folded: Vec<PpcTeStyleRun> = Vec::with_capacity(runs.len() + 1);
for run in runs {
if let Some(last) = folded.last_mut() {
if last.start == run.start {
*last = run;
continue;
}
if last.style == run.style {
continue;
}
}
folded.push(run);
}
if folded.first().is_none_or(|run| run.start != 0) {
folded.insert(
0,
PpcTeStyleRun {
start: 0,
style_index: 0,
style: fallback,
},
);
}
folded
}
fn ppc_te_measure_text_width_styled(
runs: &[PpcTeStyleRun],
text: &[u8],
start: usize,
end: usize,
) -> i16 {
let start = start.min(text.len());
let end = end.min(text.len());
text[start..end]
.iter()
.enumerate()
.fold(0i16, |width, (index, byte)| {
let style = ppc_te_style_at_offset(runs, start + index);
width.saturating_add(ppc_text_width_bytes(
style.font,
style.size,
style.face,
&[*byte],
))
})
}
fn ppc_te_line_metrics_for_range(runs: &[PpcTeStyleRun], start: usize, end: usize) -> (i16, i16) {
if start >= end {
let style = ppc_te_style_at_offset(runs, start);
return (style.line_height, style.ascent);
}
let mut line_height = 1i16;
let mut ascent = 0i16;
for offset in start..end {
let style = ppc_te_style_at_offset(runs, offset);
line_height = line_height.max(style.line_height);
ascent = ascent.max(style.ascent);
}
(line_height, ascent)
}
fn ppc_te_primary_font_and_size(memory: &mut PpcSectionMem, te_ptr: u32) -> (i16, i16) {
if memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET) == Some(0xffff) {
let style_handle = memory
.read_u32_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap_or(0);
let style_table = memory
.read_u32_be(style_handle)
.filter(|ptr| *ptr != 0)
.and_then(|style_ptr| memory.read_u32_be(style_ptr + PPC_TE_STYLE_TABLE_OFFSET))
.unwrap_or(0);
if let Some(table_ptr) = memory.read_u32_be(style_table).filter(|ptr| *ptr != 0) {
return (
memory.read_u16_be(table_ptr + 6).unwrap_or(0) as i16,
memory.read_u16_be(table_ptr + 10).unwrap_or(0) as i16,
);
}
}
(
memory
.read_u16_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap_or(0) as i16,
memory
.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET)
.unwrap_or(0) as i16,
)
}
pub(super) fn ppc_te_recalculate_layout(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
te_handle: u32,
) -> i16 {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return PPC_NIL_HANDLE_ERR;
};
let Some(text) = ppc_te_text_bytes(memory, handles, te_handle) else {
return PPC_PARAM_ERR;
};
let (_, left, _, right) =
ppc_read_rect(memory, te_ptr + PPC_TE_DEST_RECT_OFFSET).unwrap_or((0, 0, 0, i16::MAX));
let max_width = right.saturating_sub(left).max(1);
let styled = memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET) == Some(0xffff);
let style_runs = if styled {
ppc_te_style_runs(memory, handles, te_handle, text.len())
} else {
Vec::new()
};
let (font, size) = ppc_te_primary_font_and_size(memory, te_ptr);
let lines = crate::quickdraw::text::wrap_classic_text(&text, max_width, |index, byte| {
if styled {
let style = ppc_te_style_at_offset(&style_runs, index);
ppc_text_width_bytes(style.font, style.size, style.face, &[byte])
} else {
ppc_text_byte_advance_for_font(byte, font, size)
}
});
let starts = lines
.iter()
.map(|line| line.start.min(u16::MAX as usize) as u16)
.collect::<Vec<_>>();
let required_size = PPC_TE_REC_MIN_SIZE.max(
PPC_TE_LINE_STARTS_OFFSET
.saturating_add((starts.len() as u32).saturating_add(2).saturating_mul(2)),
);
let result = ppc_allocator_view_resize_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
te_handle,
required_size,
);
if result != PPC_NO_ERR {
return result;
}
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return PPC_PARAM_ERR;
};
let _ = memory.write_u16_be(
te_ptr + PPC_TE_N_LINES_OFFSET,
starts.len().min(u16::MAX as usize) as u16,
);
for (index, start) in starts.iter().copied().enumerate() {
let _ = memory.write_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + index as u32 * 2, start);
}
let _ = memory.write_u16_be(
te_ptr + PPC_TE_LINE_STARTS_OFFSET + starts.len() as u32 * 2,
text.len().min(u16::MAX as usize) as u16,
);
let _ = memory.write_u16_be(
te_ptr + PPC_TE_LINE_STARTS_OFFSET + starts.len().saturating_add(1) as u32 * 2,
0,
);
if styled {
let style_handle = memory
.read_u32_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap_or(0);
if let Some(style_ptr) = memory.read_u32_be(style_handle).filter(|ptr| *ptr != 0) {
let run_count = usize::from(
memory
.read_u16_be(style_ptr + PPC_TE_STYLE_N_RUNS_OFFSET)
.unwrap_or(0),
);
let _ = memory.write_u16_be(
style_ptr
.saturating_add(PPC_TE_STYLE_RUNS_OFFSET)
.saturating_add((run_count as u32).saturating_mul(4)),
text.len()
.saturating_add(1)
.min(u16::MAX as usize) as u16,
);
let _ = memory.write_u16_be(
style_ptr
.saturating_add(PPC_TE_STYLE_RUNS_OFFSET)
.saturating_add((run_count as u32).saturating_mul(4))
.saturating_add(2),
0xffff,
);
let lh_handle = memory
.read_u32_be(style_ptr + PPC_TE_STYLE_LH_TABLE_OFFSET)
.unwrap_or(0);
if lh_handle != 0 {
let required_lh_size = (lines.len().saturating_add(1) as u32)
.saturating_mul(PPC_TE_LH_ELEMENT_SIZE);
let result = ppc_allocator_view_resize_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
lh_handle,
required_lh_size,
);
if result == PPC_NO_ERR {
if let Some(lh_ptr) = memory.read_u32_be(lh_handle).filter(|ptr| *ptr != 0) {
for line_index in 0..=lines.len() {
let (line_height, ascent) = if let Some(line) = lines.get(line_index) {
ppc_te_line_metrics_for_range(
&style_runs,
line.start.min(text.len()),
line.next.min(text.len()),
)
} else {
ppc_te_line_metrics_for_range(
&style_runs,
text.len(),
text.len(),
)
};
let offset =
lh_ptr.saturating_add(line_index as u32 * PPC_TE_LH_ELEMENT_SIZE);
let _ = memory.write_u16_be(offset, line_height as u16);
let _ = memory.write_u16_be(offset + 2, ascent as u16);
}
}
}
}
}
}
PPC_NO_ERR
}
fn ppc_te_write_style_table_element(
memory: &mut PpcSectionMem,
style_ptr: u32,
style: PpcTeResolvedStyle,
) {
let _ = memory.write_u16_be(style_ptr, 1);
let _ = memory.write_u16_be(style_ptr + 2, style.line_height as u16);
let _ = memory.write_u16_be(style_ptr + 4, style.ascent as u16);
let _ = memory.write_u16_be(style_ptr + 6, style.font as u16);
let _ = memory.write_u8(style_ptr + 8, style.face);
let _ = memory.write_u16_be(style_ptr + 10, style.size as u16);
let _ = memory.write_u16_be(style_ptr + 12, style.color.red);
let _ = memory.write_u16_be(style_ptr + 14, style.color.green);
let _ = memory.write_u16_be(style_ptr + 16, style.color.blue);
}
fn ppc_te_set_style_for_range(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
te_handle: u32,
range_start: usize,
range_end: usize,
mode: u16,
text_style_ptr: u32,
) -> bool {
if text_style_ptr == 0 {
return false;
}
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return false;
};
if memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET) != Some(0xffff) {
return false;
}
let Some(text) = ppc_te_text_bytes(memory, handles, te_handle) else {
return false;
};
let text_len = text.len();
let range_start = range_start.min(text_len);
let range_end = range_end.min(text_len);
if range_start >= range_end {
return false;
}
let existing_runs = ppc_te_style_runs(memory, handles, te_handle, text_len);
if existing_runs.is_empty() {
return false;
}
let requested_face = memory.read_u8(text_style_ptr + 2).unwrap_or(0);
let toggle_face = mode & 0x0020 != 0 && mode & 0x0002 != 0;
let remove_toggled_face = toggle_face
&& existing_runs.iter().enumerate().all(|(index, run)| {
let run_end = existing_runs
.get(index + 1)
.map(|next| next.start)
.unwrap_or(text_len);
run_end <= range_start
|| run.start >= range_end
|| run.style.face & requested_face == requested_face
});
let mut transform = |mut style: PpcTeResolvedStyle| {
if mode & 0x0001 != 0 {
style.font = memory.read_u16_be(text_style_ptr).unwrap_or(0) as i16;
}
if mode & 0x0002 != 0 {
style.face = if toggle_face {
if remove_toggled_face {
style.face & !requested_face
} else {
style.face | requested_face
}
} else {
requested_face
};
}
if mode & 0x0010 != 0 {
let delta = memory.read_u16_be(text_style_ptr + 4).unwrap_or(0) as i16;
style.size = style.size.saturating_add(delta).max(1);
} else if mode & 0x0004 != 0 {
style.size = memory.read_u16_be(text_style_ptr + 4).unwrap_or(0) as i16;
}
if mode & 0x0008 != 0 {
style.color = PpcRgbColor {
red: memory
.read_u16_be(text_style_ptr + 6)
.unwrap_or(style.color.red),
green: memory
.read_u16_be(text_style_ptr + 8)
.unwrap_or(style.color.green),
blue: memory
.read_u16_be(text_style_ptr + 10)
.unwrap_or(style.color.blue),
};
}
let metrics = get_font_metrics(style.font, ppc_te_font_lookup_size(style.size));
style.size = ppc_te_font_lookup_size(style.size);
style.line_height = metrics
.ascent
.saturating_add(metrics.descent)
.saturating_add(metrics.leading)
.max(1);
style.ascent = metrics.ascent.max(0);
style
};
let old_range_end_style = ppc_te_style_at_offset(&existing_runs, range_end);
let mut merged = Vec::with_capacity(existing_runs.len() + 2);
for run in &existing_runs {
if run.start < range_start || run.start >= range_end {
merged.push((run.start, run.style));
} else {
merged.push((run.start, transform(run.style)));
}
}
if !existing_runs.iter().any(|run| run.start == range_start) {
merged.push((
range_start,
transform(ppc_te_style_at_offset(&existing_runs, range_start)),
));
}
if range_end < text_len && !existing_runs.iter().any(|run| run.start == range_end) {
merged.push((range_end, old_range_end_style));
}
merged.sort_by_key(|(start, _)| *start);
let mut folded = Vec::with_capacity(merged.len());
for (start, style) in merged {
if let Some((last_start, last_style)) = folded.last_mut() {
if *last_start == start {
*last_style = style;
continue;
}
if *last_style == style {
continue;
}
}
folded.push((start, style));
}
if folded.first().is_none_or(|(start, _)| *start != 0) {
folded.insert(0, (0, ppc_te_style_at_offset(&existing_runs, 0)));
}
let run_count = folded.len().min(u16::MAX as usize);
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return false;
};
let style_handle = memory
.read_u32_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap_or(0);
if style_handle == 0 {
return false;
}
let required_style_size =
PPC_TE_STYLE_RUNS_OFFSET.saturating_add((run_count as u32 + 1).saturating_mul(4));
if ppc_allocator_view_resize_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
style_handle,
required_style_size,
) != PPC_NO_ERR
{
return false;
}
let Some(style_ptr) = memory.read_u32_be(style_handle).filter(|ptr| *ptr != 0) else {
return false;
};
let mut style_table_handle = memory
.read_u32_be(style_ptr + PPC_TE_STYLE_TABLE_OFFSET)
.unwrap_or(0);
if style_table_handle == 0 {
style_table_handle = ppc_allocator_view_allocate_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
(run_count as u32).saturating_mul(PPC_TE_ST_ELEMENT_SIZE),
true,
);
if style_table_handle == 0 {
return false;
}
let _ = memory.write_u32_be(style_ptr + PPC_TE_STYLE_TABLE_OFFSET, style_table_handle);
}
if ppc_allocator_view_resize_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
style_table_handle,
(run_count as u32).saturating_mul(PPC_TE_ST_ELEMENT_SIZE),
) != PPC_NO_ERR
{
return false;
}
let Some(style_ptr) = memory.read_u32_be(style_handle).filter(|ptr| *ptr != 0) else {
return false;
};
let Some(style_table_ptr) = memory
.read_u32_be(style_table_handle)
.filter(|ptr| *ptr != 0)
else {
return false;
};
let _ = memory.write_u16_be(style_ptr + PPC_TE_STYLE_N_RUNS_OFFSET, run_count as u16);
let _ = memory.write_u16_be(style_ptr + PPC_TE_STYLE_N_STYLES_OFFSET, run_count as u16);
for (index, (start, style)) in folded.iter().take(run_count).enumerate() {
ppc_te_write_style_table_element(
memory,
style_table_ptr + index as u32 * PPC_TE_ST_ELEMENT_SIZE,
*style,
);
let run_ptr = style_ptr + PPC_TE_STYLE_RUNS_OFFSET + index as u32 * 4;
let _ = memory.write_u16_be(run_ptr, (*start).min(u16::MAX as usize) as u16);
let _ = memory.write_u16_be(run_ptr + 2, index as u16);
}
let sentinel = style_ptr + PPC_TE_STYLE_RUNS_OFFSET + run_count as u32 * 4;
let _ = memory.write_u16_be(
sentinel,
text_len.saturating_add(1).min(u16::MAX as usize) as u16,
);
let _ = memory.write_u16_be(sentinel + 2, 0xffff);
true
}
fn ppc_te_continuous_style(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
mode_ptr: u32,
style_ptr: u32,
te_handle: u32,
) -> bool {
if mode_ptr == 0 || style_ptr == 0 {
return false;
}
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return false;
};
let Some(text) = ppc_te_text_bytes(memory, handles, te_handle) else {
return false;
};
let requested_mode = memory.read_u16_be(mode_ptr).unwrap_or(0);
let mut start = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET)
.unwrap_or(0),
);
let mut end = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET)
.unwrap_or(0),
);
if end < start {
std::mem::swap(&mut start, &mut end);
}
start = start.min(text.len());
end = end.min(text.len());
let runs = ppc_te_style_runs(memory, handles, te_handle, text.len());
let first = if start == end {
ppc_te_null_style_resolved_style(memory, te_handle).unwrap_or_else(|| {
ppc_te_style_at_offset(
&runs,
start.saturating_sub(1).min(text.len().saturating_sub(1)),
)
})
} else {
ppc_te_style_at_offset(&runs, start)
};
let mut common_mode = requested_mode;
let mut common_face = first.face;
let mut all_faces_equal = true;
if start < end {
for offset in start..end {
let style = ppc_te_style_at_offset(&runs, offset);
if requested_mode & 0x0001 != 0 && style.font != first.font {
common_mode &= !0x0001;
}
if requested_mode & 0x0002 != 0 {
if style.face != first.face {
all_faces_equal = false;
}
common_face &= style.face;
}
if requested_mode & 0x0004 != 0 && style.size != first.size {
common_mode &= !0x0004;
}
if requested_mode & 0x0008 != 0 && style.color != first.color {
common_mode &= !0x0008;
}
}
}
if requested_mode & 0x0002 != 0 && !all_faces_equal && common_face == 0 {
common_mode &= !0x0002;
}
let _ = memory.write_u16_be(mode_ptr, common_mode);
if requested_mode & 0x0001 != 0 {
let _ = memory.write_u16_be(style_ptr, first.font as u16);
}
if requested_mode & 0x0002 != 0 {
let _ = memory.write_u8(style_ptr + 2, common_face);
}
if requested_mode & 0x0004 != 0 {
let _ = memory.write_u16_be(style_ptr + 4, first.size as u16);
}
if requested_mode & 0x0008 != 0 {
let _ = memory.write_u16_be(style_ptr + 6, first.color.red);
let _ = memory.write_u16_be(style_ptr + 8, first.color.green);
let _ = memory.write_u16_be(style_ptr + 10, first.color.blue);
}
common_mode == requested_mode
}
fn ppc_measure_text(
memory: &mut PpcSectionMem,
count: i16,
text_ptr: u32,
char_locs_ptr: u32,
text_font: i16,
text_size: i16,
text_face: u8,
) {
if count < 0 || char_locs_ptr == 0 {
return;
}
let count = count as u32;
let mut width = 0i16;
let _ = memory.write_u16_be(char_locs_ptr, 0);
for index in 0..count {
let byte = memory.read_u8(text_ptr.saturating_add(index)).unwrap_or(0);
width = width.saturating_add(ppc_text_width_bytes(
text_font,
text_size,
text_face,
&[byte],
));
let _ = memory.write_u16_be(
char_locs_ptr.saturating_add((index + 1).saturating_mul(2)),
width as u16,
);
}
}
fn ppc_te_set_text(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
te_handle: u32,
text: &[u8],
) -> i16 {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return PPC_NIL_HANDLE_ERR;
};
let text_handle = memory
.read_u32_be(te_ptr + PPC_TE_HTEXT_OFFSET)
.unwrap_or(0);
if text_handle == 0 {
return PPC_NIL_HANDLE_ERR;
}
let length = text.len().min(i16::MAX as usize);
let result = ppc_allocator_view_resize_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
text_handle,
length as u32,
);
if result != PPC_NO_ERR {
return result;
}
let Some(text_ptr) = memory.read_u32_be(text_handle) else {
return PPC_PARAM_ERR;
};
if !text.is_empty() && memory.write_bytes(text_ptr, &text[..length]).is_none() {
return PPC_PARAM_ERR;
}
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return PPC_PARAM_ERR;
};
let _ = memory.write_u16_be(te_ptr + PPC_TE_LENGTH_OFFSET, length as u16);
let _ = memory.write_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET, length as u16);
let _ = memory.write_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET, length as u16);
ppc_te_recalculate_layout(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
te_handle,
)
}
fn ppc_te_replace_selection(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
te_handle: u32,
inserted: &[u8],
) -> i16 {
let Some(mut buffer) = ppc_te_edit_buffer(memory, handles, te_handle) else {
return PPC_NIL_HANDLE_ERR;
};
buffer.replace_selection(inserted);
ppc_te_commit_edit_buffer(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
te_handle,
&buffer,
)
}
fn ppc_te_edit_buffer(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
te_handle: u32,
) -> Option<crate::text_edit::TextEditBuffer> {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return None;
};
Some(crate::text_edit::TextEditBuffer::new(
ppc_te_text_bytes(memory, handles, te_handle)?,
usize::from(memory.read_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET)?),
usize::from(memory.read_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET)?),
))
}
fn ppc_te_commit_edit_buffer(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
te_handle: u32,
buffer: &crate::text_edit::TextEditBuffer,
) -> i16 {
let result = ppc_te_set_text(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
te_handle,
buffer.text(),
);
if result != PPC_NO_ERR {
return result;
}
if let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) {
let selection = buffer.selection();
let _ = memory.write_u16_be(
te_ptr + PPC_TE_SEL_START_OFFSET,
selection.start.min(i16::MAX as usize) as u16,
);
let _ = memory.write_u16_be(
te_ptr + PPC_TE_SEL_END_OFFSET,
selection.end.min(i16::MAX as usize) as u16,
);
}
PPC_NO_ERR
}
pub(super) fn ppc_te_key(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
te_handle: u32,
key: u8,
) -> i16 {
let Some(mut buffer) = ppc_te_edit_buffer(memory, handles, te_handle) else {
return PPC_NIL_HANDLE_ERR;
};
buffer.apply_key(key);
ppc_te_commit_edit_buffer(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
te_handle,
&buffer,
)
}
fn ppc_te_line_range(
memory: &mut PpcSectionMem,
te_ptr: u32,
line: usize,
text_len: usize,
) -> Option<(usize, usize)> {
let line_count = usize::from(memory.read_u16_be(te_ptr + PPC_TE_N_LINES_OFFSET)?);
if line >= line_count {
return None;
}
let start =
usize::from(memory.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + line as u32 * 2)?)
.min(text_len);
let end = if line + 1 < line_count {
usize::from(memory.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + (line + 1) as u32 * 2)?)
.min(text_len)
} else {
text_len
};
Some((start, end.max(start)))
}
fn ppc_te_metrics(memory: &mut PpcSectionMem, te_ptr: u32) -> (i16, i16, i16, i16) {
let (font, size) = ppc_te_primary_font_and_size(memory, te_ptr);
let mut line_height = memory
.read_u16_be(te_ptr + PPC_TE_LINE_HEIGHT_OFFSET)
.unwrap_or(0) as i16;
let mut ascent = memory
.read_u16_be(te_ptr + PPC_TE_FONT_ASCENT_OFFSET)
.unwrap_or(0) as i16;
if line_height <= 0 || ascent < 0 {
let (face, scale) = get_font_face_scaled(font, size);
ascent = face.metrics.ascent.saturating_mul(scale);
line_height = ascent
.saturating_add(face.metrics.descent.saturating_mul(scale))
.saturating_add(face.metrics.leading.saturating_mul(scale));
}
(font, size, line_height.max(1), ascent.max(0))
}
fn ppc_te_point_to_offset(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
te_handle: u32,
v: i16,
h: i16,
) -> Option<usize> {
let te_ptr = ppc_te_record_ptr(memory, te_handle)?;
let text = ppc_te_text_bytes(memory, handles, te_handle)?;
let (top, left, _, right) =
ppc_read_rect(memory, te_ptr + PPC_TE_DEST_RECT_OFFSET).unwrap_or((0, 0, 0, 0));
let styled = memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET) == Some(0xffff);
let style_runs = if styled {
ppc_te_style_runs(memory, handles, te_handle, text.len())
} else {
Vec::new()
};
let (font, size, fallback_line_height, _) = ppc_te_metrics(memory, te_ptr);
let line_count = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_N_LINES_OFFSET)
.unwrap_or(0),
);
let target_v = i32::from(v.saturating_sub(top)).max(0);
let mut line = 0;
if line_count != 0 {
let mut line_top = 0i32;
for candidate in 0..line_count {
let candidate_height = if styled {
ppc_te_line_height(memory, te_ptr, candidate).max(1)
} else {
fallback_line_height
};
if target_v < line_top.saturating_add(i32::from(candidate_height))
|| candidate + 1 == line_count
{
line = candidate;
break;
}
line_top = line_top.saturating_add(i32::from(candidate_height));
}
}
let (start, end) =
ppc_te_line_range(memory, te_ptr, line, text.len()).unwrap_or((text.len(), text.len()));
let visible_end = (start..end)
.rev()
.find(|index| !matches!(text[*index], b'\r' | b'\n'))
.map_or(start, |index| index + 1);
let width = if styled {
ppc_te_measure_text_width_styled(&style_runs, &text, start, visible_end)
} else {
ppc_text_bytes_advance_for_font(&text[start..visible_end], font, size)
};
let alignment = memory.read_u16_be(te_ptr + PPC_TE_JUST_OFFSET).unwrap_or(0) as i16;
let line_left = crate::text_edit::aligned_line_left(left, right, width, alignment, 1);
let target_x = h.saturating_sub(line_left);
let mut offset = start;
let mut advance = 0i16;
for (index, byte) in text[start..visible_end].iter().copied().enumerate() {
let char_width = if styled {
let style = ppc_te_style_at_offset(&style_runs, start + index);
ppc_text_width_bytes(style.font, style.size, style.face, &[byte])
} else {
ppc_text_byte_advance_for_font(byte, font, size)
};
if target_x < advance.saturating_add(char_width / 2) {
offset = start + index;
break;
}
advance = advance.saturating_add(char_width);
offset = start + index + 1;
}
Some(offset)
}
pub(super) fn ppc_te_click(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
te_handle: u32,
v: i16,
h: i16,
extend: bool,
tick_count: u32,
) {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return;
};
let Some(text) = ppc_te_text_bytes(memory, handles, te_handle) else {
return;
};
let Some(offset) = ppc_te_point_to_offset(memory, handles, te_handle, v, h) else {
return;
};
let previous_time = memory
.read_u32_be(te_ptr + PPC_TE_CLICK_TIME_OFFSET)
.unwrap_or(0);
let previous_offset = memory
.read_u16_be(te_ptr + PPC_TE_CLICK_LOC_OFFSET)
.unwrap_or(u16::MAX);
let double_time = memory
.read_u32_be(crate::memory::globals::addr::DOUBLE_TIME)
.unwrap_or(PPC_DEFAULT_DOUBLE_TIME_TICKS);
let is_double = previous_time != 0
&& previous_offset == offset as u16
&& tick_count.wrapping_sub(previous_time) <= double_time;
let (selection_start, selection_end) = if is_double && !text.is_empty() {
let mut word_start = offset.min(text.len().saturating_sub(1));
let mut word_end = word_start;
while word_start > 0 && text[word_start - 1] > b' ' {
word_start -= 1;
}
while word_end < text.len() && text[word_end] > b' ' {
word_end += 1;
}
(word_start, word_end)
} else if extend {
let old_start = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET)
.unwrap_or(0),
);
let old_end = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET)
.unwrap_or(0),
);
if offset < old_start {
(offset, old_end)
} else {
(old_start, offset)
}
} else {
(offset, offset)
};
let _ = memory.write_u16_be(
te_ptr + PPC_TE_SEL_START_OFFSET,
selection_start.min(i16::MAX as usize) as u16,
);
let _ = memory.write_u16_be(
te_ptr + PPC_TE_SEL_END_OFFSET,
selection_end.min(i16::MAX as usize) as u16,
);
let _ = memory.write_u16_be(te_ptr + PPC_TE_SEL_POINT_OFFSET, v as u16);
let _ = memory.write_u16_be(te_ptr + PPC_TE_SEL_POINT_OFFSET + 2, h as u16);
let _ = memory.write_u16_be(te_ptr + PPC_TE_CLICK_LOC_OFFSET, offset as u16);
let _ = memory.write_u32_be(te_ptr + PPC_TE_CLICK_TIME_OFFSET, tick_count);
let _ = memory.write_u32_be(te_ptr + PPC_TE_CARET_TIME_OFFSET, tick_count);
}
#[allow(clippy::too_many_arguments)]
fn ppc_te_draw_text_box(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
port: u32,
text: &[u8],
rect_ptr: u32,
alignment: i16,
text_mode: i16,
text_size: i16,
color: PpcRgbColor,
explicit_index: Option<u8>,
) {
let Some((top, left, bottom, right)) = ppc_read_rect(memory, rect_ptr) else {
return;
};
let font = ppc_current_text_font(memory, port);
let (face, scale) = get_font_face_scaled(font, text_size);
let ascent = face.metrics.ascent.saturating_mul(scale);
let line_height = ascent
.saturating_add(face.metrics.descent.saturating_mul(scale))
.saturating_add(face.metrics.leading.saturating_mul(scale))
.max(1);
let max_width = right.saturating_sub(left).max(1);
let lines = crate::quickdraw::text::wrap_classic_text(text, max_width, |_, byte| {
ppc_text_byte_advance_for_font(byte, font, text_size)
});
for (line_index, line) in lines.into_iter().enumerate() {
let baseline = top
.saturating_add(ascent)
.saturating_add((line_index as i16).saturating_mul(line_height));
if baseline.saturating_sub(ascent) >= bottom {
break;
}
let bytes = &text[line.start..line.visible_end];
let width = ppc_text_bytes_advance_for_font(bytes, font, text_size);
let x = crate::text_edit::aligned_line_left(left, right, width, alignment, 1);
let _ = ppc_draw_text_bytes(
memory,
gworlds,
port,
(x, baseline),
font,
text_size,
text_mode,
color,
explicit_index,
bytes,
);
}
}
fn ppc_te_line_height(memory: &mut PpcSectionMem, te_ptr: u32, line: usize) -> i16 {
if memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET) != Some(0xffff) {
return memory
.read_u16_be(te_ptr + PPC_TE_LINE_HEIGHT_OFFSET)
.unwrap_or(0) as i16;
}
let line_height_table = memory
.read_u32_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.filter(|handle| *handle != 0)
.and_then(|handle| memory.read_u32_be(handle))
.filter(|ptr| *ptr != 0)
.and_then(|ptr| memory.read_u32_be(ptr + PPC_TE_STYLE_LH_TABLE_OFFSET))
.filter(|handle| *handle != 0)
.and_then(|handle| memory.read_u32_be(handle))
.filter(|ptr| *ptr != 0);
line_height_table
.and_then(|ptr| memory.read_u16_be(ptr.wrapping_add(line as u32 * 4)))
.unwrap_or(0) as i16
}
fn ppc_te_get_height(
memory: &mut PpcSectionMem,
te_handle: u32,
start_line: i32,
end_line: i32,
) -> u32 {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return 0;
};
let line_count = i32::from(
memory
.read_u16_be(te_ptr + PPC_TE_N_LINES_OFFSET)
.unwrap_or(0),
);
if start_line < 1 || end_line < start_line || line_count == 0 {
return 0;
}
let start = (start_line - 1).min(line_count) as usize;
let end = end_line.min(line_count) as usize;
let (_, _, fallback_height, _) = ppc_te_metrics(memory, te_ptr);
let height = (start..end).fold(0i32, |height, line| {
let line_height = ppc_te_line_height(memory, te_ptr, line);
height.saturating_add(i32::from(if line_height > 0 {
line_height
} else {
fallback_height
}))
});
height.max(0) as u32
}
fn ppc_te_get_point(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
te_handle: u32,
offset: u16,
) -> u32 {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return 0;
};
let text = ppc_te_text_bytes(memory, handles, te_handle).unwrap_or_default();
let offset = usize::from(offset).min(text.len());
let line_count = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_N_LINES_OFFSET)
.unwrap_or(0),
);
let mut line = 0usize;
for candidate in 1..line_count {
let start = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + candidate as u32 * 2)
.unwrap_or(u16::MAX),
);
if start <= offset {
line = candidate;
} else {
break;
}
}
let start = if line_count == 0 {
0
} else {
ppc_te_line_range(memory, te_ptr, line, text.len())
.map(|range| range.0)
.unwrap_or(0)
};
let (top, left, _, right) =
ppc_read_rect(memory, te_ptr + PPC_TE_DEST_RECT_OFFSET).unwrap_or((0, 0, 0, 0));
let styled = memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET) == Some(0xffff);
let style_runs = if styled {
ppc_te_style_runs(memory, handles, te_handle, text.len())
} else {
Vec::new()
};
let (font, size, fallback_line_height, _) = ppc_te_metrics(memory, te_ptr);
let line_end = if line_count == 0 {
0
} else {
ppc_te_line_range(memory, te_ptr, line, text.len())
.map(|range| range.1)
.unwrap_or(text.len())
};
let visible_end = (start..line_end)
.rev()
.find(|index| !matches!(text[*index], b'\r' | b'\n'))
.map_or(start, |index| index + 1);
let line_width = if styled {
ppc_te_measure_text_width_styled(&style_runs, &text, start, visible_end)
} else {
ppc_text_bytes_advance_for_font(&text[start..visible_end], font, size)
};
let alignment = memory.read_u16_be(te_ptr + PPC_TE_JUST_OFFSET).unwrap_or(0) as i16;
let line_left = crate::text_edit::aligned_line_left(left, right, line_width, alignment, 1);
let prefix_end = offset.min(visible_end);
let prefix_width = if styled {
ppc_te_measure_text_width_styled(&style_runs, &text, start, prefix_end)
} else {
ppc_text_bytes_advance_for_font(&text[start..prefix_end], font, size)
};
let h = line_left.saturating_add(prefix_width);
let mut v = top;
for previous_line in 0..line {
let previous_height = if styled {
ppc_te_line_height(memory, te_ptr, previous_line).max(1)
} else {
fallback_line_height
};
v = v.saturating_add(previous_height);
}
(u32::from(v as u16) << 16) | u32::from(h as u16)
}
fn ppc_te_scroll(memory: &mut PpcSectionMem, te_handle: u32, dh: i16, dv: i16, pinned: bool) {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return;
};
let Some((top, left, bottom, right)) = ppc_read_rect(memory, te_ptr + PPC_TE_DEST_RECT_OFFSET)
else {
return;
};
let mut next_top = top.saturating_add(dv);
let mut next_left = left.saturating_add(dh);
let height = bottom.saturating_sub(top);
let width = right.saturating_sub(left);
if pinned {
let (view_top, view_left, view_bottom, view_right) =
ppc_read_rect(memory, te_ptr + PPC_TE_VIEW_RECT_OFFSET)
.unwrap_or((top, left, bottom, right));
let line_count = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_N_LINES_OFFSET)
.unwrap_or(0),
);
let (_, _, fallback_height, _) = ppc_te_metrics(memory, te_ptr);
let content_height = (0..line_count).fold(0i16, |height, line| {
let line_height = ppc_te_line_height(memory, te_ptr, line);
height.saturating_add(if line_height > 0 {
line_height
} else {
fallback_height
})
});
next_top = if content_height <= view_bottom.saturating_sub(view_top) {
view_top
} else {
next_top.clamp(view_bottom.saturating_sub(content_height), view_top)
};
next_left = if width <= view_right.saturating_sub(view_left) {
view_left
} else {
next_left.clamp(view_right.saturating_sub(width), view_left)
};
}
let _ = ppc_write_rect(
memory,
te_ptr + PPC_TE_DEST_RECT_OFFSET,
next_top,
next_left,
next_top.saturating_add(height),
next_left.saturating_add(width),
);
}
fn ppc_te_scrap_handle(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> u32 {
let existing = memory
.read_u32_be(crate::memory::globals::addr::TE_SCRP_HANDLE)
.unwrap_or(0);
if existing != 0 && memory.read_u32_be(existing).is_some() {
return existing;
}
let handle = ppc_allocator_view_allocate_handle(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
0,
true,
);
if handle != 0 {
let _ = memory.write_u32_be(crate::memory::globals::addr::TE_SCRP_HANDLE, handle);
let _ = memory.write_u16_be(crate::memory::globals::addr::TE_SCRP_LENGTH, 0);
}
handle
}
fn ppc_te_scrap_bytes(memory: &mut PpcSectionMem) -> Vec<u8> {
let handle = memory
.read_u32_be(crate::memory::globals::addr::TE_SCRP_HANDLE)
.unwrap_or(0);
let length = usize::from(
memory
.read_u16_be(crate::memory::globals::addr::TE_SCRP_LENGTH)
.unwrap_or(0),
);
let Some(ptr) = memory.read_u32_be(handle).filter(|ptr| *ptr != 0) else {
return Vec::new();
};
u32::try_from(length)
.ok()
.and_then(|length| ppc_memory_read_bytes(memory, ptr, length))
.unwrap_or_default()
}
fn ppc_te_set_scrap_bytes(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
bytes: &[u8],
) -> i16 {
let handle = ppc_te_scrap_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
if handle == 0 {
return PPC_MEM_FULL_ERR;
}
let length = bytes.len().min(i16::MAX as usize);
let result = ppc_allocator_view_resize_handle(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
length as u32,
);
if result != PPC_NO_ERR {
return result;
}
if length != 0 {
let Some(ptr) = memory.read_u32_be(handle).filter(|ptr| *ptr != 0) else {
return PPC_PARAM_ERR;
};
if memory.write_bytes(ptr, &bytes[..length]).is_none() {
return PPC_PARAM_ERR;
}
}
let _ = memory.write_u16_be(
crate::memory::globals::addr::TE_SCRP_LENGTH,
length as u16,
);
PPC_NO_ERR
}
fn ppc_te_selected_bytes(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
te_handle: u32,
) -> Option<Vec<u8>> {
Some(
ppc_te_edit_buffer(memory, handles, te_handle)?
.selected_text()
.to_vec(),
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_te_copy_or_cut(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
te_handle: u32,
cut: bool,
) -> i16 {
let Some(selected) = ppc_te_selected_bytes(memory, handles, te_handle) else {
return PPC_NIL_HANDLE_ERR;
};
if selected.is_empty() {
return PPC_NO_ERR;
}
let result = ppc_te_set_scrap_bytes(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&selected,
);
if result != PPC_NO_ERR || !cut {
return result;
}
ppc_te_replace_selection(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
te_handle,
&[],
)
}
pub(super) fn ppc_te_draw(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
gworlds: &[PpcGWorldRecord],
te_handle: u32,
fallback_port: u32,
fallback_color: PpcRgbColor,
fore_indices: &HashMap<u32, u8>,
) {
let Some(te_ptr) = ppc_te_record_ptr(memory, te_handle) else {
return;
};
let Some(text) = ppc_te_text_bytes(memory, handles, te_handle) else {
return;
};
let (top, left, _, right) =
ppc_read_rect(memory, te_ptr + PPC_TE_DEST_RECT_OFFSET).unwrap_or((0, 0, 0, 0));
let styled = memory.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET) == Some(0xffff);
let (font, size, fallback_line_height, fallback_ascent) = ppc_te_metrics(memory, te_ptr);
let style_runs = if styled {
ppc_te_style_runs(memory, handles, te_handle, text.len())
} else {
Vec::new()
};
let port = memory
.read_u32_be(te_ptr + PPC_TE_IN_PORT_OFFSET)
.filter(|port| *port != 0 && gworlds.iter().any(|g| g.port == *port))
.unwrap_or(fallback_port);
let explicit_index = (!styled)
.then(|| fore_indices.get(&port).copied())
.flatten();
let mode = memory
.read_u16_be(te_ptr + PPC_TE_TX_MODE_OFFSET)
.unwrap_or(PPC_QD_TEXT_MODE_SRC_OR as u16) as i16;
let line_count = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_N_LINES_OFFSET)
.unwrap_or(0),
);
let active = memory
.read_u16_be(te_ptr + PPC_TE_ACTIVE_OFFSET)
.unwrap_or(0)
!= 0;
let selection_start = memory
.read_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET)
.unwrap_or(0) as usize;
let selection_end = memory
.read_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET)
.unwrap_or(0) as usize;
let view = ppc_read_rect(memory, te_ptr + PPC_TE_VIEW_RECT_OFFSET).unwrap_or((0, 0, 0, 0));
for line in 0..line_count {
let start = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + line as u32 * 2)
.unwrap_or(0),
)
.min(text.len());
let end = if line + 1 < line_count {
usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + (line + 1) as u32 * 2)
.unwrap_or(text.len() as u16),
)
.min(text.len())
} else {
text.len()
};
let mut visible_end = end;
while visible_end > start && matches!(text[visible_end - 1], b' ' | b'\r' | b'\n') {
visible_end -= 1;
}
let width = if styled {
ppc_te_measure_text_width_styled(&style_runs, &text, start, visible_end)
} else {
ppc_text_width_bytes(
font,
size,
ppc_current_text_style(memory, port),
&text[start..visible_end],
)
};
let alignment = memory.read_u16_be(te_ptr + PPC_TE_JUST_OFFSET).unwrap_or(0) as i16;
let line_left = crate::text_edit::aligned_line_left(left, right, width, alignment, 1);
let (line_height, ascent) = if styled {
ppc_te_line_metrics_for_range(&style_runs, start, end)
} else {
(fallback_line_height, fallback_ascent)
};
let baseline = top
.saturating_add(ascent)
.saturating_add((line as i16).saturating_mul(line_height));
if styled {
let mut offset = start;
let mut pen = line_left;
while offset < visible_end {
let style = ppc_te_style_at_offset(&style_runs, offset);
let run_end = style_runs
.iter()
.find(|run| run.start > offset)
.map(|run| run.start)
.unwrap_or(visible_end)
.min(visible_end)
.max(offset + 1);
let advance = ppc_draw_text_bytes_styled(
memory,
gworlds,
port,
(pen, baseline),
style.font,
style.size,
mode,
style.color,
None,
style.face,
&text[offset..run_end],
);
pen = pen.saturating_add(advance);
offset = run_end;
}
} else {
let _ = ppc_draw_text_bytes(
memory,
gworlds,
port,
(line_left, baseline),
font,
size,
mode,
fallback_color,
explicit_index,
&text[start..visible_end],
);
}
if active && selection_start != selection_end {
// Text (1993), pp. 2-51--2-52: highlight each selected line segment.
let selected_start = selection_start.min(selection_end).max(start);
let selected_end = selection_start.max(selection_end).min(visible_end);
if selected_start < selected_end {
let measure = |end| {
if styled {
ppc_te_measure_text_width_styled(&style_runs, &text, start, end)
} else {
ppc_text_bytes_advance_for_font(&text[start..end], font, size)
}
};
let selection_left = if selected_start == start && matches!(alignment, 0 | -2) {
left
} else {
line_left.saturating_add(measure(selected_start))
};
let selection_right = line_left.saturating_add(measure(selected_end));
let line_top = baseline.saturating_sub(ascent);
let selection = (
line_top.max(view.0),
selection_left.max(view.1),
line_top.saturating_add(line_height).min(view.2),
selection_right.min(view.3),
);
if !ppc_draw_themed_selection(memory, gworlds, port, selection) {
ppc_invert_rect_bounds(memory, gworlds, port, selection);
}
}
}
}
let sel_start = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_SEL_START_OFFSET)
.unwrap_or(0),
);
let sel_end = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_SEL_END_OFFSET)
.unwrap_or(0),
);
if active && sel_start == sel_end {
for line in 0..line_count {
let start = usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + line as u32 * 2)
.unwrap_or(0),
)
.min(text.len());
let end = if line + 1 < line_count {
usize::from(
memory
.read_u16_be(te_ptr + PPC_TE_LINE_STARTS_OFFSET + (line + 1) as u32 * 2)
.unwrap_or(text.len() as u16),
)
.min(text.len())
} else {
text.len()
};
if sel_start >= start && (sel_start <= end || line + 1 == line_count) {
let mut visible_end = end;
while visible_end > start && matches!(text[visible_end - 1], b' ' | b'\r' | b'\n') {
visible_end -= 1;
}
let (line_height, _) = if styled {
ppc_te_line_metrics_for_range(&style_runs, start, end)
} else {
(fallback_line_height, fallback_ascent)
};
let width = if styled {
ppc_te_measure_text_width_styled(&style_runs, &text, start, visible_end)
} else {
ppc_text_width_bytes(
font,
size,
ppc_current_text_style(memory, port),
&text[start..visible_end],
)
};
let alignment = memory.read_u16_be(te_ptr + PPC_TE_JUST_OFFSET).unwrap_or(0) as i16;
let line_left =
crate::text_edit::aligned_line_left(left, right, width, alignment, 1);
let caret_offset = sel_start.min(visible_end).max(start);
let measured = if styled {
ppc_te_measure_text_width_styled(&style_runs, &text, start, caret_offset)
} else {
ppc_text_width_bytes(
font,
size,
ppc_current_text_style(memory, port),
&text[start..caret_offset],
)
};
let mut caret_x = line_left + measured;
if caret_offset > start {
caret_x = caret_x.saturating_sub(1);
}
let line_top = top.saturating_add((line as i16).saturating_mul(line_height));
let line_bottom = line_top.saturating_add(line_height);
let _ = ppc_paint_rect_bounds(
memory,
gworlds,
port,
(line_top, caret_x, line_bottom, caret_x.saturating_add(1)),
if ppc_ui_theme(gworlds) != UiThemeId::ClassicSystem7 {
ppc_theme_rgb(ppc_ui_theme(gworlds).provider().palette().selection)
} else if styled {
ppc_te_style_at_offset(&style_runs, caret_offset).color
} else {
fallback_color
},
explicit_index,
);
break;
}
}
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_te_cleanup_handles(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
allocated: &[u32],
) {
for handle in allocated.iter().copied().rev() {
ppc_te_forget_handle(
allocator.as_deref_mut(),
None,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
);
}
}
pub(super) fn ppc_te_forget_handle(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
legacy_handle_states: Option<&mut Vec<PpcHandleStateRecord>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
handle: u32,
) {
if handle == 0 {
return;
}
if let Some(allocator) = allocator {
let _ = allocator.dispose_handle(
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
);
} else {
if let Some(index) = handles.iter().position(|record| record.handle == handle) {
handles.remove(index);
let _ = memory.write_u32_be(handle, 0);
}
if let Some(handle_states) = legacy_handle_states {
ppc_forget_handle_state(handle, handle_states);
}
}
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_te_dispose(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
mut legacy_handle_states: Option<&mut Vec<PpcHandleStateRecord>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
te_handle: u32,
) {
let Some(te_ptr) = memory.read_u32_be(te_handle).filter(|ptr| *ptr != 0) else {
return;
};
let h_text = memory
.read_u32_be(te_ptr + PPC_TE_HTEXT_OFFSET)
.unwrap_or(0);
let styled = memory
.read_u16_be(te_ptr + PPC_TE_TX_SIZE_OFFSET)
.is_some_and(|size| size == 0xffff);
if styled {
let style_handle = memory
.read_u32_be(te_ptr + PPC_TE_TX_FONT_OFFSET)
.unwrap_or(0);
if let Some(style_ptr) = memory.read_u32_be(style_handle).filter(|ptr| *ptr != 0) {
let style_table = memory
.read_u32_be(style_ptr + PPC_TE_STYLE_TABLE_OFFSET)
.unwrap_or(0);
let lh_table = memory
.read_u32_be(style_ptr + PPC_TE_STYLE_LH_TABLE_OFFSET)
.unwrap_or(0);
let null_style = memory
.read_u32_be(style_ptr + PPC_TE_STYLE_NULL_STYLE_OFFSET)
.unwrap_or(0);
let null_scrap = memory
.read_u32_be(null_style)
.filter(|ptr| *ptr != 0)
.and_then(|ptr| memory.read_u32_be(ptr + PPC_TE_NULL_STYLE_SCRAP_OFFSET))
.unwrap_or(0);
for nested in [style_table, lh_table, null_scrap, null_style, style_handle] {
ppc_te_forget_handle(
allocator.as_deref_mut(),
legacy_handle_states.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
nested,
);
}
}
}
ppc_te_forget_handle(
allocator.as_deref_mut(),
legacy_handle_states.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
h_text,
);
ppc_te_forget_handle(
allocator,
legacy_handle_states,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
te_handle,
);
}
fn ppc_menu_handle_bytes(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
menu_handle: u32,
) -> Option<Vec<u8>> {
let record = handles.iter().find(|record| record.handle == menu_handle)?;
let ptr = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0)?;
ppc_memory_read_bytes(memory, ptr, record.size)
}
fn ppc_replace_menu_bytes_with_allocator(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
menu_handle: u32,
bytes: &[u8],
) -> i16 {
ppc_allocator_view_replace_handle_bytes(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
menu_handle,
bytes,
)
}
#[cfg(test)]
fn ppc_replace_menu_bytes(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
menu_handle: u32,
bytes: &[u8],
) -> i16 {
let mut last_mem_error = PPC_NO_ERR;
ppc_replace_menu_bytes_with_allocator(
None,
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
menu_handle,
bytes,
)
}
fn ppc_mutate_menu_items_in_place(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
menu_handle: u32,
mutation: impl FnOnce(&mut MenuItems) -> bool,
) -> bool {
let Some(original) = ppc_menu_handle_bytes(memory, handles, menu_handle) else {
return false;
};
let Some(mut items) = MenuItems::decode(&original) else {
return false;
};
if !mutation(&mut items) {
return false;
}
let Some(bytes) = items.rebuild(&original) else {
return false;
};
let Some(menu) = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0) else {
return false;
};
bytes.len() <= original.len() && memory.write_bytes(menu, &bytes).is_some()
}
pub(super) fn ppc_decode_menu_items(bytes: &[u8]) -> Option<(usize, u32, Vec<PpcMenuItemDefinition>)> {
let decoded = MenuItems::decode(bytes)?;
Some((decoded.first_item, decoded.enable_flags, decoded.items))
}
#[allow(clippy::too_many_arguments)]
fn ppc_alloc_new_menu(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
menu_proc: u32,
menu_id: i16,
title_ptr: u32,
) -> u32 {
let title = ppc_read_pascal_string(memory, title_ptr).unwrap_or_default();
// Macintosh Toolbox Essentials (1992), pp. 3-105--3-106: NewMenu
// creates an empty standard MenuRecord, loads the standard MDEF if
// necessary, and stores its Handle in MenuInfo.menuProc.
let bytes = new_standard_menu_record(menu_id, menu_proc, &title);
ppc_allocator_view_allocate_handle_with_bytes(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&bytes,
)
}
#[cfg(test)]
fn ppc_new_menu(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
_free_handle_blocks: &mut Vec<PpcHandleRecord>,
menu_id: i16,
title_ptr: u32,
) -> u32 {
let mut last_mem_error = PPC_NO_ERR;
ppc_alloc_new_menu(
None,
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
0,
menu_id,
title_ptr,
)
}
fn ppc_menu_item_attribute_address(
memory: &mut PpcSectionMem,
menu_handle: u32,
item: i16,
attribute_offset: u32,
) -> Option<u32> {
let (item_addr, item_len) = ppc_menu_item(memory, menu_handle, item)?;
item_addr
.checked_add(1 + u32::from(item_len))?
.checked_add(attribute_offset)
}
fn ppc_get_item_cmd(cpu: &PpcCpu, memory: &mut PpcSectionMem) {
let menu_handle = cpu.gpr[3];
let item = cpu.gpr[4] as u16 as i16;
let cmd_char_ptr = cpu.gpr[5];
if cmd_char_ptr == 0 || !ppc_memory_can_write_bytes(memory, cmd_char_ptr, 2) {
return;
}
let command = ppc_menu_item(memory, menu_handle, item)
.and_then(|(item_addr, item_len)| {
let command_offset = 2u32.checked_add(u32::from(item_len))?;
memory.read_u8(item_addr.checked_add(command_offset)?)
})
.unwrap_or(0);
let _ = memory.write_u16_be(cmd_char_ptr, u16::from(command));
}
fn ppc_set_item_cmd(cpu: &PpcCpu, memory: &mut PpcSectionMem, handles: &[PpcHandleRecord]) {
// Inside Macintosh Volume V (1986), p. V-244: SetItemCmd installs the
// command-key byte, including $1B for a hierarchical submenu.
ppc_mutate_menu_items_in_place(memory, handles, cpu.gpr[3], |items| {
items.set_command(cpu.gpr[4] as u16 as i16, cpu.gpr[5] as u8)
});
}
fn ppc_get_item_mark(cpu: &PpcCpu, memory: &mut PpcSectionMem) {
let mark_ptr = cpu.gpr[5];
if mark_ptr == 0 || !ppc_memory_can_write_bytes(memory, mark_ptr, 2) {
return;
}
let mark = ppc_menu_item_attribute_address(memory, cpu.gpr[3], cpu.gpr[4] as u16 as i16, 2)
.and_then(|address| memory.read_u8(address))
.unwrap_or(0);
let _ = memory.write_u16_be(mark_ptr, u16::from(mark));
}
fn ppc_count_menu_items(memory: &mut PpcSectionMem, menu_handle: u32) -> u16 {
ppc_menu_items_from_memory(memory, menu_handle)
.map(|items| items.item_count())
.unwrap_or(0)
}
fn ppc_get_menu_item_text(cpu: &PpcCpu, memory: &mut PpcSectionMem) {
let menu_handle = cpu.gpr[3];
let item = cpu.gpr[4] as u16 as i16;
let item_string = cpu.gpr[5];
if item_string == 0 {
return;
}
let text = ppc_menu_item(memory, menu_handle, item)
.and_then(|(item_addr, item_len)| {
ppc_memory_read_bytes(memory, item_addr.checked_add(1)?, u32::from(item_len))
})
.unwrap_or_default();
let _ = ppc_write_pstring_bytes(memory, item_string, &text);
}
fn ppc_set_menu_item_text_with_allocator(
cpu: &PpcCpu,
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> i16 {
let Some(original) = ppc_menu_handle_bytes(memory, handles, cpu.gpr[3]) else {
return PPC_NIL_HANDLE_ERR;
};
let Some(mut items) = MenuItems::decode(&original) else {
return PPC_PARAM_ERR;
};
let item_number = cpu.gpr[4] as u16 as i16;
let text = ppc_read_pascal_string(memory, cpu.gpr[5]).unwrap_or_default();
if !items.set_text(item_number, &text) {
return PPC_NO_ERR;
}
let Some(bytes) = items.rebuild(&original) else {
return PPC_PARAM_ERR;
};
ppc_replace_menu_bytes_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
cpu.gpr[3],
&bytes,
)
}
#[cfg(test)]
fn ppc_set_menu_item_text(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
) -> i16 {
let mut last_mem_error = PPC_NO_ERR;
ppc_set_menu_item_text_with_allocator(
cpu,
None,
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
)
}
fn ppc_delete_menu_item_with_allocator(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
menu_handle: u32,
item_number: i16,
) -> i16 {
let Some(original) = ppc_menu_handle_bytes(memory, handles, menu_handle) else {
return PPC_NIL_HANDLE_ERR;
};
let Some(menu_id) = original
.get(..2)
.map(|bytes| i16::from_be_bytes([bytes[0], bytes[1]]))
else {
return PPC_PARAM_ERR;
};
let Some(mut items) = MenuItems::decode(&original) else {
return PPC_PARAM_ERR;
};
if !items.delete(item_number) {
return PPC_NO_ERR;
}
let Some(bytes) = items.rebuild(&original) else {
return PPC_PARAM_ERR;
};
let result = ppc_replace_menu_bytes_with_allocator(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
menu_handle,
&bytes,
);
if result == PPC_NO_ERR {
ppc_filter_menu_color_table_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
|id, item| id != menu_id || item != item_number,
);
}
result
}
#[cfg(test)]
fn ppc_delete_menu_item(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
menu_handle: u32,
item_number: i16,
) -> i16 {
let mut last_mem_error = PPC_NO_ERR;
ppc_delete_menu_item_with_allocator(
None,
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
menu_handle,
item_number,
)
}
fn ppc_insert_menu_items_with_allocator(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
menu_handle: u32,
data_ptr: u32,
after_item: i16,
) -> i16 {
let Some(original) = ppc_menu_handle_bytes(memory, handles, menu_handle) else {
return PPC_NIL_HANDLE_ERR;
};
let Some(mut items) = MenuItems::decode(&original) else {
return PPC_PARAM_ERR;
};
let data = ppc_read_pascal_string(memory, data_ptr).unwrap_or_default();
if after_item == i16::MAX {
items.append_specs(&data);
} else {
items.insert_specs(&data, after_item);
}
let Some(bytes) = items.rebuild(&original) else {
return PPC_PARAM_ERR;
};
ppc_replace_menu_bytes_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
menu_handle,
&bytes,
)
}
#[cfg(test)]
fn ppc_insert_menu_items(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
menu_handle: u32,
data_ptr: u32,
after_item: i16,
) -> i16 {
let mut last_mem_error = PPC_NO_ERR;
ppc_insert_menu_items_with_allocator(
None,
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
menu_handle,
data_ptr,
after_item,
)
}
fn ppc_resource_menu_indices(
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
requested_type: u32,
) -> Vec<usize> {
let font_type = u32::from_be_bytes(*b"FONT");
let resource_types = if requested_type == font_type {
[Some(u32::from_be_bytes(*b"FOND")), Some(font_type)]
} else {
[Some(requested_type), None]
};
let mut seen = std::collections::HashSet::new();
let mut indices = Vec::new();
for resource_type in resource_types.into_iter().flatten() {
for current in [true, false] {
for (index, resource) in resources.iter().enumerate() {
if resource.res_type != resource_type
|| resource.ref_num == PPC_CLOSED_RESOURCE_REF_NUM
|| resource.name.is_empty()
|| (resource.ref_num == current_resource_refnum) != current
{
continue;
}
if seen.insert((resource_type, resource.res_id)) {
indices.push(index);
}
}
}
}
indices
}
fn ppc_insert_resource_menu_names_with_allocator(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
menu_handle: u32,
names: Vec<Vec<u8>>,
after_item: i16,
) -> i16 {
let Some(original) = ppc_menu_handle_bytes(memory, handles, menu_handle) else {
return PPC_NIL_HANDLE_ERR;
};
let Some(mut items) = MenuItems::decode(&original) else {
return PPC_PARAM_ERR;
};
if !items.insert_resource_names(names, after_item) {
return PPC_NO_ERR;
}
let Some(bytes) = items.rebuild(&original) else {
return PPC_PARAM_ERR;
};
ppc_replace_menu_bytes_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
menu_handle,
&bytes,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_insert_resource_menu(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
resources: &mut [PpcVfsResourceRecord],
current_resource_refnum: i16,
resource_policy: &SharedProcessResourcePolicy,
last_resource_error: &mut i16,
menu_handle: u32,
requested_type: u32,
after_item: i16,
) -> i16 {
// AppendResMenu and InsertResMenu force SetResLoad(TRUE) and read every
// matching resource before returning. Macintosh Toolbox Essentials
// (1992), pp. 3-101--3-104.
resource_policy.set_res_load(true);
let indices = ppc_resource_menu_indices(resources, current_resource_refnum, requested_type);
let mut names = Vec::with_capacity(indices.len());
for index in indices {
let name = resources[index].name.clone();
if ppc_materialize_vfs_resource_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
resources,
index,
true,
last_resource_error,
) == 0
{
return *last_mem_error;
}
names.push(name);
}
if requested_type == u32::from_be_bytes(*b"FONT") {
for &(id, name) in crate::quickdraw::fonts::FONT_NAMES {
if id != crate::quickdraw::fonts::FONT_APPLICATION {
names.push(crate::mac_roman::encode_mac_roman_lossy(name));
}
}
}
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
ppc_insert_resource_menu_names_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
menu_handle,
names,
after_item,
)
}
fn ppc_set_menu_item_enabled(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
menu_handle: u32,
item: i16,
enabled: bool,
) {
ppc_mutate_menu_items_in_place(memory, handles, menu_handle, |items| {
items.set_enabled(item, enabled)
});
}
fn ppc_set_item_mark(cpu: &PpcCpu, memory: &mut PpcSectionMem, handles: &[PpcHandleRecord]) {
ppc_mutate_menu_items_in_place(memory, handles, cpu.gpr[3], |items| {
items.set_mark(cpu.gpr[4] as u16 as i16, cpu.gpr[5] as u8)
});
}
fn ppc_check_menu_item(cpu: &PpcCpu, memory: &mut PpcSectionMem, handles: &[PpcHandleRecord]) {
let menu_handle = cpu.gpr[3];
let item = cpu.gpr[4] as u16 as i16;
let checked = cpu.gpr[5] & 0xff != 0;
// Inside Macintosh Volume I (1985), pp. I-345 and I-358: a compiled
// MENU item stores icon, command-key, mark, and style bytes after its
// Pascal text. CheckItem uses the standard checkmark glyph ($12).
ppc_mutate_menu_items_in_place(memory, handles, menu_handle, |items| {
items.set_mark(item, if checked { 0x12 } else { 0 })
});
}
fn ppc_menu_resource_data<'a>(
resources: &'a [PpcVfsResourceRecord],
current_resource_refnum: i16,
resource_type: &[u8; 4],
resource_id: i16,
) -> Option<&'a [u8]> {
let index = ppc_vfs_resource_index(
resources,
current_resource_refnum,
u32::from_be_bytes(*resource_type),
resource_id,
false,
)?;
Some(&resources.get(index)?.data)
}
fn ppc_menu_item_appearance(
memory: &mut PpcSectionMem,
menu_handle: u32,
item: i16,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> PpcTrackedMenuItemAppearance {
let is_separator = ppc_menu_item_is_separator(memory, menu_handle, item);
let icon = ppc_menu_item_attribute_address(memory, menu_handle, item, 0)
.and_then(|address| memory.read_u8(address))
.unwrap_or(0);
let command = ppc_menu_item_attribute_address(memory, menu_handle, item, 1)
.and_then(|address| memory.read_u8(address))
.unwrap_or(0);
let style = ppc_menu_item_attribute_address(memory, menu_handle, item, 3)
.and_then(|address| memory.read_u8(address))
.unwrap_or(0);
// Resource access and bitmap ownership remain PowerPC adapter work; the
// standard MDEF's resource priority, selector interpretation, and
// geometry are shared with the 68k gateway. Macintosh Toolbox Essentials
// (1992), pp. 3-45--3-46 and 3-62--3-63.
let resource_id = standard_menu_icon_resource_id(icon, command);
let color_icon = resource_id
.and_then(|resource_id| {
ppc_menu_resource_data(resources, current_resource_refnum, b"cicn", resource_id)
})
.and_then(|data| ColorIconLayout::decode(data).map(|layout| (data, layout)));
let icon_kind = standard_menu_icon_kind(
icon,
command,
color_icon.map(|(_data, layout)| (layout.width, layout.height)),
);
let tracked_icon = match icon_kind {
StandardMenuIconKind::None => None,
StandardMenuIconKind::Color { .. } => {
color_icon.map(|(data, _layout)| PpcTrackedMenuIcon::CIcon(data.to_vec()))
}
StandardMenuIconKind::Small => resource_id
.and_then(|resource_id| {
ppc_menu_resource_data(resources, current_resource_refnum, b"SICN", resource_id)
})
.filter(|data| data.len() >= 32)
.map(|data| PpcTrackedMenuIcon::SmallIcon(data.to_vec())),
StandardMenuIconKind::Normal | StandardMenuIconKind::Reduced => resource_id
.and_then(|resource_id| {
ppc_menu_resource_data(resources, current_resource_refnum, b"ICON", resource_id)
})
.filter(|data| data.len() >= 128)
.map(|data| PpcTrackedMenuIcon::Icon {
data: data.to_vec(),
reduced: icon_kind == StandardMenuIconKind::Reduced,
}),
};
PpcTrackedMenuItemAppearance {
height: if is_separator {
STANDARD_MENU_SEPARATOR_HEIGHT
} else {
icon_kind.row_height(QuickDrawTextStyle::from_bits(style))
},
icon_kind,
icon: tracked_icon,
}
}
fn ppc_menu_item_appearances(
memory: &mut PpcSectionMem,
menu_handle: u32,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> Vec<PpcTrackedMenuItemAppearance> {
let mut items = (1..=ppc_count_menu_items(memory, menu_handle) as i16)
.map(|item| {
(
ppc_menu_item_appearance(
memory,
menu_handle,
item,
resources,
current_resource_refnum,
),
ppc_menu_item_is_separator(memory, menu_handle, item),
)
})
.collect::<Vec<_>>();
let laid_out = laid_out_menu_item_count(&items, |(_appearance, separator)| *separator);
items.truncate(laid_out);
items
.into_iter()
.map(|(appearance, _separator)| appearance)
.collect()
}
fn ppc_tracked_menu_item_height(
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
item: i16,
) -> i16 {
ppc_tracked_menu_rows(state).height(item, 16)
}
fn ppc_tracked_menu_item_offset(
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
item: i16,
) -> i16 {
ppc_tracked_menu_rows(state).offset(item)
}
fn ppc_menu_appearance_height(appearances: &[PpcTrackedMenuItemAppearance]) -> i16 {
ppc_menu_rows_for_appearances(appearances).total_height()
}
fn ppc_tracked_menu_rows(
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
) -> MenuRows {
ppc_menu_rows_for_appearances(state.item_appearances())
}
fn ppc_menu_rows_for_appearances(appearances: &[PpcTrackedMenuItemAppearance]) -> MenuRows {
MenuRows::new(appearances.iter().map(|appearance| MenuRow {
height: appearance.height,
selectable: true,
}))
}
#[cfg(test)]
fn ppc_calc_menu_size(memory: &mut PpcSectionMem, menu_handle: u32) {
ppc_calc_menu_size_with_resources(memory, menu_handle, &[], 0);
}
fn ppc_calc_menu_size_with_resources(
memory: &mut PpcSectionMem,
menu_handle: u32,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) {
let Some(menu) = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0) else {
return;
};
let appearances =
ppc_menu_item_appearances(memory, menu_handle, resources, current_resource_refnum);
let width = standard_menu_width((1..=appearances.len()).filter_map(|item| {
let item = i16::try_from(item).ok()?;
let (address, len) = ppc_menu_item(memory, menu_handle, item)?;
let text = ppc_memory_read_bytes(memory, address + 1, u32::from(len)).unwrap_or_default();
let command = ppc_menu_item_attribute_address(memory, menu_handle, item, 1)
.and_then(|address| memory.read_u8(address))
.unwrap_or(0);
let icon = appearances
.get(usize::try_from(item - 1).ok()?)
.map(|appearance| appearance.icon_kind.width())
.unwrap_or(0);
Some(StandardMenuItemWidth {
text: standard_menu_text_advance(&text),
icon,
command,
})
}));
let rows = ppc_menu_rows_for_appearances(&appearances);
let height = standard_menu_height(
&rows,
(PPC_MAIN_SCREEN_HEIGHT as i16)
.saturating_sub(memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap_or(20) as i16),
);
let _ = memory.write_u16_be(menu + 2, width as u16);
let _ = memory.write_u16_be(menu + 4, height as u16);
}
fn ppc_dispatch_calc_menu_size(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
toolbox_startup: &mut PpcToolboxStartupState,
) -> PpcImportAction {
let menu_handle = cpu.gpr[3];
if let Some(action) = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
toolbox_startup,
MenuDefinitionInvocation::size(menu_handle),
cpu.lr,
) {
return action;
}
ppc_calc_menu_size_with_resources(memory, menu_handle, resources, current_resource_refnum);
PpcImportAction::ReturnPreserve
}
#[allow(clippy::too_many_arguments)]
fn ppc_dispatch_native_menu_definition(
cpu: &mut PpcCpu,
process_memory_manager: Option<&mut ProcessNativeMemoryManager>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
resources: &[PpcVfsResourceRecord],
toolbox_startup: &mut PpcToolboxStartupState,
invocation: MenuDefinitionInvocation,
final_pc: u32,
) -> Option<PpcImportAction> {
ppc_dispatch_native_menu_definition_with_return(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
resources,
toolbox_startup,
invocation,
final_pc,
PpcNativeReturnGpr3::Preserve,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_dispatch_native_menu_definition_with_return(
cpu: &mut PpcCpu,
mut process_memory_manager: Option<&mut ProcessNativeMemoryManager>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
_heap_limit: u32,
resources: &[PpcVfsResourceRecord],
toolbox_startup: &mut PpcToolboxStartupState,
invocation: MenuDefinitionInvocation,
final_pc: u32,
return_gpr3: PpcNativeReturnGpr3,
) -> Option<PpcImportAction> {
let menu_build = toolbox_startup.execution.calls().menu_bar_build();
let tracking_root = toolbox_startup.execution.menu().entry_id();
let final_pc = if menu_build.is_some() && invocation.message == MenuDefinitionMessage::Size {
PPC_GUEST_CALL_RETURN_PC
} else {
final_pc
};
let target = ppc_menu_definition_target(cpu, memory, resources, invocation.menu_handle)?;
let manager = process_memory_manager.as_deref_mut()?;
// The emulated callback owns its wrapper and stack as well as its
// by-reference arguments. Nested calls must not reuse a live gateway.
let workspace_size = match target.isa {
GuestIsa::PowerPc => 10,
GuestIsa::M68k => PPC_MIXED_MODE_M68K_STACK_SIZE + 96,
};
let scratch = manager.new_native_scratch(memory, workspace_size);
if scratch == 0 {
return None;
}
if let Some(heap) = manager.native_heap_state() {
*heap_cursor = heap.heap_cursor;
}
let completion = crate::menu_manager::MenuDefinitionCompletion::pending();
let operation = crate::menu_manager::MenuDefinitionOperation {
scratch,
completion: completion.clone(),
};
let prepared = (|| {
memory.write_bytes(scratch, &invocation.scratch_bytes())?;
let call = invocation.call(scratch);
match target.isa {
GuestIsa::PowerPc => {
let effect = GuestCallEffect::call_guest(
GuestCallRequest::for_task(
toolbox_startup.execution.calls().current_task(),
GuestCallTarget {
isa: target.isa,
entry: target.entry,
rtoc: target.rtoc,
},
)
.with_powerpc_arguments(
crate::guest_call::PowerPcArguments::from_slice(&call.native_arguments())?,
),
GuestCallContinuation::to_powerpc(
PPC_GUEST_CALL_RETURN_PC,
final_pc,
cpu.gpr[2],
return_gpr3,
),
);
toolbox_startup
.execution
.calls()
.activate_powerpc_effect_with_operation(
cpu,
memory,
effect,
Some(scratch),
Some(crate::guest_call::ManagerContinuation::Menu(
crate::guest_call::MenuManagerContinuation::Definition(operation),
)),
)
.then_some(PpcImportAction::Continue)
}
GuestIsa::M68k => ppc_begin_m68k_menu_definition(
cpu,
memory,
toolbox_startup,
target,
call,
final_pc,
return_gpr3,
operation,
),
}
})();
if prepared.is_none() {
manager.release_native_scratch(scratch);
return None;
}
if let Some(id) = tracking_root {
toolbox_startup.execution.bind_menu_definition_completion(
id,
invocation,
completion.clone(),
);
}
if invocation.message == MenuDefinitionMessage::Size {
if let Some(id) = menu_build {
toolbox_startup
.execution
.calls()
.bind_menu_bar_build_completion(id, invocation.menu_handle, completion);
}
}
prepared
}
#[allow(clippy::too_many_arguments)]
fn ppc_begin_m68k_menu_definition(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
startup: &mut PpcToolboxStartupState,
target: GuestProcedure,
call: crate::menu_manager::MenuDefinitionCall,
final_pc: u32,
return_gpr3: PpcNativeReturnGpr3,
operation: crate::menu_manager::MenuDefinitionOperation,
) -> Option<PpcImportAction> {
// `MyMenuDef` is a no-result Pascal stack routine with parameter sizes
// 2, 4, 4, 4, and 4 bytes. The Mixed Mode ProcInfo encoding is therefore
// $0000FF80. Macintosh Toolbox Essentials (1992), pp. 3-148--3-151;
// Inside Macintosh: PowerPC System Software (1994), pp. 2-12--2-16.
if target.proc_info != 0 && target.proc_info != MenuDefinitionInvocation::PASCAL_PROC_INFO {
return None;
}
let stack_top = operation
.scratch
.checked_add(PPC_MIXED_MODE_M68K_STACK_SIZE + 96)?;
let return_pc = PPC_GUEST_CALL_RETURN_PC;
let frame =
crate::execution_m68k::M68kMenuDefinitionFrame::new(call, target.entry, stack_top, false)?;
memory.write_bytes(frame.entry, &frame.image)?;
memory.write_u32_be(frame.entry - 4, return_pc)?;
let mut registers = crate::guest_call::M68kRegisterState::default();
registers.address[5] = PPC_DATA_BASE;
let effect = GuestCallEffect::call_guest(
GuestCallRequest::for_task(
startup.execution.calls().current_task(),
GuestCallTarget {
isa: target.isa,
entry: target.entry,
rtoc: target.rtoc,
},
)
.with_m68k_request(crate::guest_call::M68kCallRequest {
entry: frame.entry,
initial_sp: frame.entry - 4,
final_sp: frame.entry,
registers,
result: None,
}),
GuestCallContinuation::to_powerpc(return_pc, final_pc, cpu.gpr[2], return_gpr3),
);
if !startup.execution.calls().begin_m68k_operation(
effect,
operation.scratch,
crate::guest_call::ManagerContinuation::Menu(
crate::guest_call::MenuManagerContinuation::Definition(operation),
),
) {
return None;
}
Some(PpcImportAction::Halt)
}
fn ppc_menu_definition_target(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
resources: &[PpcVfsResourceRecord],
menu_handle: u32,
) -> Option<GuestProcedure> {
let (proc_ptr, resource_backed) =
ppc_custom_menu_definition_proc(memory, resources, menu_handle)?;
let raw_isa = if resource_backed {
GuestIsa::M68k
} else {
GuestIsa::PowerPc
};
let target = resolve_guest_procedure(
memory,
proc_ptr,
cpu.gpr[2],
None,
GuestIsa::PowerPc,
raw_isa,
)?;
memory.read_u16_be(target.entry)?;
Some(target)
}
fn ppc_custom_menu_definition_proc(
memory: &mut PpcSectionMem,
resources: &[PpcVfsResourceRecord],
menu_handle: u32,
) -> Option<(u32, bool)> {
let menu_ptr = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0)?;
let menu_proc = memory.read_u32_be(menu_ptr + 6).unwrap_or(0);
let proc_ptr = memory.read_u32_be(menu_proc).unwrap_or(0);
let resource_id = resources
.iter()
.find(|resource| {
resource.res_type == u32::from_be_bytes(*b"MDEF") && resource.handle == menu_proc
})
.map(|resource| resource.res_id);
let is_standard = resource_id == Some(0)
|| ppc_memory_read_bytes(memory, proc_ptr, STANDARD_MENU_DEFINITION_SHIM.len() as u32)
.is_some_and(|bytes| bytes == STANDARD_MENU_DEFINITION_SHIM);
if is_standard || menu_proc == 0 || proc_ptr == 0 {
return None;
}
Some((proc_ptr, resource_id.is_some()))
}
fn ppc_menu_uses_guest_definition(
memory: &mut PpcSectionMem,
resources: &[PpcVfsResourceRecord],
menu_handle: u32,
) -> bool {
ppc_custom_menu_definition_proc(memory, resources, menu_handle).is_some()
}
fn ppc_menu_item_enabled(memory: &mut PpcSectionMem, menu_handle: u32, item: i16) -> bool {
let Some(menu) = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0) else {
return false;
};
let flags = memory.read_u32_be(menu + 10).unwrap_or(0);
flags & 1 != 0 && (item > 31 || item > 0 && flags & (1u32 << item) != 0)
}
fn ppc_menu_item_is_separator(memory: &mut PpcSectionMem, menu_handle: u32, item: i16) -> bool {
ppc_menu_item(memory, menu_handle, item)
.is_some_and(|(address, len)| len == 1 && memory.read_u8(address + 1) == Some(b'-'))
}
fn ppc_menu_item_is_selectable(memory: &mut PpcSectionMem, menu_handle: u32, item: i16) -> bool {
ppc_menu_item_enabled(memory, menu_handle, item)
&& !ppc_menu_item_is_separator(memory, menu_handle, item)
}
fn ppc_guest_menu_snapshot(memory: &mut PpcSectionMem, menu_list_handle: u32) -> GuestMenuSnapshot {
let menu_list = ppc_menu_list_definition(memory, menu_list_handle).unwrap_or_default();
menu_list.guest_snapshot(|menu_handle| {
let menu = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0)?;
Some(MenuSnapshotRecord {
id: memory.read_u16_be(menu)? as i16,
title: ppc_read_pascal_string(memory, menu + 14)?,
items: ppc_menu_items_from_memory(memory, menu_handle)?,
})
})
}
fn ppc_menu_selection_result(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
menu_id: i16,
item_number: i16,
) -> Option<u32> {
ppc_guest_menu_snapshot(memory, menu_list_handle).selectable_result(menu_id, item_number)
}
#[allow(clippy::too_many_arguments)]
fn ppc_step_menu_tracking(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
toolbox_startup: &mut PpcToolboxStartupState,
current_gworld: &mut u32,
current_gdevice: &mut u32,
input: PpcInputSnapshot,
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> Option<PpcImportAction> {
let action = ppc_step_menu_tracking_body(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
gworlds,
screen_clut,
toolbox_startup,
current_gworld,
current_gdevice,
input,
vfs_resources,
current_resource_refnum,
)?;
if matches!(action, PpcImportAction::Yield(_)) {
let Some(key) = toolbox_startup
.execution
.request_menu_hook(input.mouse_button)
else {
return Some(action);
};
let pointer = memory.read_u32_be(0x0a30).unwrap_or(0);
if let Some(target) = resolve_guest_procedure(
memory,
pointer,
cpu.gpr[2],
None,
GuestIsa::PowerPc,
GuestIsa::M68k,
) {
if target.proc_info == 0 {
let return_value = PpcNativeReturnGpr3::Set(cpu.gpr[3]);
let operation = crate::guest_call::MenuHookOperation::pending(key);
let callback = match target.isa {
GuestIsa::PowerPc => {
let effect = GuestCallEffect::call_guest(
GuestCallRequest::for_task(
toolbox_startup.execution.calls().current_task(),
GuestCallTarget {
isa: target.isa,
entry: target.entry,
rtoc: target.rtoc,
},
)
.with_powerpc_arguments(
crate::guest_call::PowerPcArguments::from_slice(&[])?,
),
GuestCallContinuation::to_powerpc(
PPC_GUEST_CALL_RETURN_PC,
PPC_GUEST_CALL_RETURN_PC,
cpu.gpr[2],
return_value,
),
);
toolbox_startup.execution.calls()
.activate_powerpc_effect_with_operation(
cpu,
memory,
effect,
None,
Some(crate::guest_call::ManagerContinuation::Menu(
crate::guest_call::MenuManagerContinuation::Hook(
operation.clone(),
),
)),
)
.then_some(PpcImportAction::Continue)
}
GuestIsa::M68k => ppc_begin_m68k_universal_proc_with_operation(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
toolbox_startup,
target,
0,
None,
Vec::new(),
PPC_GUEST_CALL_RETURN_PC,
return_value,
crate::guest_call::ManagerContinuation::Menu(
crate::guest_call::MenuManagerContinuation::Hook(operation.clone()),
),
),
};
if let Some(callback) = callback {
assert!(toolbox_startup
.execution
.bind_menu_hook(key, operation.completion.clone()));
ppc_preserve_menu_callback_port(
toolbox_startup,
*current_gworld,
*current_gdevice,
);
return Some(callback);
}
}
}
}
Some(action)
}
#[allow(clippy::too_many_arguments)]
fn ppc_step_menu_tracking_body(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
toolbox_startup: &mut PpcToolboxStartupState,
current_gworld: &mut u32,
current_gdevice: &mut u32,
input: PpcInputSnapshot,
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> Option<PpcImportAction> {
let call = toolbox_startup.execution.menu().context().call?;
let MenuTrackingOrigin::PowerPc {
stack_pointer,
return_address,
} = call.origin
else {
return None;
};
cpu.gpr[1] = stack_pointer;
cpu.lr = return_address;
match call.request {
MenuTrackingRequest::MenuSelect { initial_point } => cpu.gpr[3] = initial_point,
MenuTrackingRequest::PopUp(request) => {
cpu.gpr[3] = request.menu_handle;
cpu.gpr[4] = request.anchor.0 as u16 as u32;
cpu.gpr[5] = request.anchor.1 as u16 as u32;
cpu.gpr[6] = request.requested_item as u16 as u32;
}
}
cpu.pc = PPC_GUEST_CALL_RETURN_PC;
let handles = process_memory_manager.native_handle_records().to_vec();
let current_menu_list = ppc_current_menu_list(memory);
match call.request {
MenuTrackingRequest::PopUp(_) => {
let menu_color_bytes = ppc_menu_color_table_bytes(memory, &handles);
let menu_colors = MenuColorTable::new(&menu_color_bytes);
if toolbox_startup.execution.menu().context().caller_isa() == Some(GuestIsa::M68k) {
// A classic MenuSelect owns this process continuation. A
// nested native call must not consume its origin ABI frame.
Some(PpcImportAction::Return(0))
} else if toolbox_startup.active_menu_definition().is_some() {
if toolbox_startup
.execution
.menu()
.context()
.native_popup()
.is_some()
{
Some(ppc_continue_custom_popup_menu_tracking(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
current_gworld,
current_gdevice,
input,
vfs_resources,
))
} else {
Some(PpcImportAction::Return(0))
}
} else if toolbox_startup.execution.menu().is_none() {
if let Some(action) = ppc_begin_custom_popup_menu_tracking(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
toolbox_startup,
current_gworld,
current_gdevice,
input,
vfs_resources,
) {
Some(action)
} else {
Some(ppc_dispatch_pop_up_menu_select(
cpu,
memory,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
input,
vfs_resources,
current_resource_refnum,
))
}
} else {
Some(ppc_dispatch_pop_up_menu_select(
cpu,
memory,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
input,
vfs_resources,
current_resource_refnum,
))
}
}
MenuTrackingRequest::MenuSelect { .. } => {
let menu_color_bytes = ppc_menu_color_table_bytes(memory, &handles);
let menu_colors = MenuColorTable::new(&menu_color_bytes);
if toolbox_startup.execution.menu().context().caller_isa() == Some(GuestIsa::M68k) {
// A classic MenuSelect owns this process continuation. A
// nested native call must not consume its origin ABI frame.
Some(PpcImportAction::Return(0))
} else if toolbox_startup.active_menu_definition().is_some() {
Some(ppc_continue_custom_menu_bar_tracking(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
current_gworld,
current_gdevice,
input,
vfs_resources,
current_resource_refnum,
))
} else if toolbox_startup
.execution
.menu()
.as_ref()
.is_some_and(|state| state.kind == MenuTrackingKind::MenuBar && state.is_flashing())
{
let mut state = toolbox_startup.execution.take_menu_state().unwrap();
let step = state.advance_flash_at(
memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.unwrap_or(0),
);
if matches!(step, MenuFlashStep::Wait | MenuFlashStep::Inactive) {
toolbox_startup.execution.set_menu_state(Some(state));
return Some(PpcImportAction::Yield(u64::MAX));
}
if let MenuFlashStep::Complete(result) = step {
toolbox_startup.execution.set_menu_state(Some(state));
let result = ppc_complete_menu_bar_tracking_with_colors(
memory,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
result,
)
.unwrap_or(result);
ppc_restore_menu_definition_port(
toolbox_startup,
current_gworld,
current_gdevice,
);
return Some(PpcImportAction::Return(result));
}
if let Some(selected) = ppc_deepest_highlighted_menu_item(&state) {
ppc_redraw_standard_menu_tracking_flash(
memory,
gworlds,
screen_clut,
menu_colors,
&state,
selected,
step == MenuFlashStep::Highlight(true),
);
}
toolbox_startup.execution.set_menu_state(Some(state));
Some(PpcImportAction::Yield(u64::MAX))
} else if toolbox_startup
.execution
.menu()
.as_ref()
.is_some_and(|state| state.kind != MenuTrackingKind::MenuBar)
{
Some(PpcImportAction::Return(0))
} else if let Some((menu_id, item_number)) =
toolbox_startup.pending_native_menu_selection.take()
{
let result =
ppc_menu_selection_result(memory, current_menu_list, menu_id, item_number)
.unwrap_or(0);
let result = ppc_complete_menu_bar_tracking_with_colors(
memory,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
result,
)
.unwrap_or_else(|| {
ppc_set_menu_command_highlight_with_colors(
memory,
gworlds,
current_menu_list,
result,
None,
screen_clut,
menu_colors,
toolbox_startup.host_menu_bar_hidden,
);
result
});
ppc_restore_menu_definition_port(toolbox_startup, current_gworld, current_gdevice);
Some(PpcImportAction::Return(result))
} else if input.mouse_button {
if toolbox_startup.execution.menu().is_none() {
if let Some(action) = ppc_begin_custom_menu_bar_tracking(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
current_gworld,
current_gdevice,
cpu.gpr[3],
vfs_resources,
) {
return Some(action);
}
}
ppc_track_menu_while_held_with_resources(
memory,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
cpu.gpr[3],
input,
vfs_resources,
current_resource_refnum,
);
if let Some(invocation) = toolbox_startup
.active_menu_definition()
.and_then(MenuDefinitionTracking::pending_invocation)
{
toolbox_startup.execution.with_menu_context_mut(|context| {
context
.call
.get_or_insert(ppc_menu_select_call(cpu, cpu.gpr[3]));
});
ppc_prepare_menu_definition_port(
toolbox_startup,
current_gworld,
current_gdevice,
);
if let Some(action) = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
vfs_resources,
toolbox_startup,
invocation,
cpu.pc,
) {
return Some(action);
}
if let Some(state) = toolbox_startup.execution.take_menu_state() {
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
toolbox_startup.clear_active_menu_definition();
toolbox_startup
.execution
.with_menu_context_mut(|context| context.clear_native_menu());
ppc_restore_menu_definition_port(
toolbox_startup,
current_gworld,
current_gdevice,
);
return Some(PpcImportAction::Return(0));
}
if toolbox_startup
.execution
.menu()
.as_ref()
.is_some_and(|state| state.kind == MenuTrackingKind::MenuBar)
{
Some(PpcImportAction::Yield(u64::MAX))
} else {
Some(PpcImportAction::Return(0))
}
} else {
// MenuSelect owns one interaction from the supplied mouse-down
// point until release. Even when the host observes release on
// this first execution slice, create and finish the same
// retained tracking state rather than deriving an item from a
// separate fixed-height shortcut. Macintosh Toolbox Essentials
// (1992), pp. 3-114--3-116.
let mut tracking_updated = false;
if toolbox_startup.execution.menu().is_none() {
if let Some(action) = ppc_begin_custom_menu_bar_tracking(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
current_gworld,
current_gdevice,
cpu.gpr[3],
vfs_resources,
) {
return Some(action);
}
ppc_track_menu_while_held_with_resources(
memory,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
cpu.gpr[3],
input,
vfs_resources,
current_resource_refnum,
);
tracking_updated = true;
}
if !tracking_updated {
if let Some(mut state) = toolbox_startup.execution.take_menu_state() {
ppc_update_menu_tracking(
memory,
gworlds,
screen_clut,
menu_colors,
current_menu_list,
&mut state,
input,
vfs_resources,
current_resource_refnum,
);
toolbox_startup.execution.set_menu_state(Some(state));
}
}
if let Some(state) = toolbox_startup.execution.menu().as_ref() {
if let Some((menu_handle, item)) = ppc_tracked_menu_selection(memory, state) {
let menu_id = memory
.read_u32_be(menu_handle)
.filter(|ptr| *ptr != 0)
.and_then(|menu| memory.read_u16_be(menu))
.unwrap_or(0);
let result = (u32::from(menu_id) << 16) | u32::from(item as u16);
if result != 0 {
let tick = memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.unwrap_or(0);
let flashes = memory
.read_u16_be(crate::memory::globals::addr::MENU_FLASH)
.unwrap_or(crate::memory::globals::DEFAULT_MENU_FLASH_COUNT);
if toolbox_startup
.execution
.begin_menu_flash(tick, flashes, result)
.unwrap()
{
return Some(PpcImportAction::Yield(u64::MAX));
}
}
}
}
let result = ppc_finish_menu_bar_tracking_with_colors(
memory,
gworlds,
screen_clut,
menu_colors,
toolbox_startup,
input,
)
.unwrap_or_else(|| {
ppc_set_menu_command_highlight_with_colors(
memory,
gworlds,
current_menu_list,
0,
None,
screen_clut,
menu_colors,
toolbox_startup.host_menu_bar_hidden,
);
0
});
ppc_restore_menu_definition_port(toolbox_startup, current_gworld, current_gdevice);
Some(PpcImportAction::Return(result))
}
}
}
}
fn ppc_menu_select_call(cpu: &PpcCpu, initial_point: u32) -> MenuTrackingCall {
MenuTrackingCall {
request: MenuTrackingRequest::MenuSelect { initial_point },
origin: MenuTrackingOrigin::PowerPc {
stack_pointer: cpu.gpr[1],
return_address: cpu.lr,
},
}
}
fn ppc_popup_menu_call(cpu: &PpcCpu) -> MenuTrackingCall {
MenuTrackingCall {
request: MenuTrackingRequest::PopUp(PopupMenuRequest {
menu_handle: cpu.gpr[3],
anchor: (cpu.gpr[4] as u16 as i16, cpu.gpr[5] as u16 as i16),
requested_item: cpu.gpr[6] as u16 as i16,
}),
origin: MenuTrackingOrigin::PowerPc {
stack_pointer: cpu.gpr[1],
return_address: cpu.lr,
},
}
}
fn ppc_popup_menu_is_inserted(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
menu_handle: u32,
) -> bool {
ppc_menu_list_definition(memory, menu_list_handle).is_some_and(|menu_list| {
menu_list
.hierarchical_handles()
.any(|candidate| candidate == menu_handle)
})
}
fn ppc_popup_menu_layout_with_resources(
memory: &mut PpcSectionMem,
request: PopupMenuRequest,
front: PpcFrontBuffer,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> Option<(i16, i16, i16, i16, i16, i16)> {
let menu_handle = request.menu_handle;
let menu = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0)?;
let count = i16::try_from(ppc_count_menu_items(memory, menu_handle)).ok()?;
if count <= 0 || front.width <= 1 || front.height <= 1 {
return None;
}
ppc_calc_menu_size_with_resources(memory, menu_handle, resources, current_resource_refnum);
let appearances =
ppc_menu_item_appearances(memory, menu_handle, resources, current_resource_refnum);
let rows = ppc_menu_rows_for_appearances(&appearances);
let layout = standard_popup_menu_layout(
&rows,
i16::try_from(memory.read_u16_be(menu + 2)?.max(32)).ok()?,
(
ppc_u32_to_i16_saturating(front.width),
ppc_u32_to_i16_saturating(front.height),
),
request.anchor,
request.requested_item,
)?;
Some((
layout.left,
layout.top,
layout.width,
layout.height,
layout.highlighted_item,
layout.content_top,
))
}
#[allow(clippy::too_many_arguments)]
fn ppc_begin_custom_popup_menu_tracking(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
startup: &mut PpcToolboxStartupState,
current_gworld: &mut u32,
current_gdevice: &mut u32,
input: PpcInputSnapshot,
resources: &[PpcVfsResourceRecord],
) -> Option<PpcImportAction> {
let menu_handle = cpu.gpr[3];
let call = ppc_popup_menu_call(cpu);
let menu_list = ppc_current_menu_list(memory);
if !input.mouse_button || !ppc_popup_menu_is_inserted(memory, menu_list, menu_handle) {
return None;
}
ppc_menu_definition_target(cpu, memory, resources, menu_handle)?;
startup.execution.with_menu_context_mut(|context| {
context.definition = Some(call.popup_request().unwrap().begin_definition());
context.call.get_or_insert(call);
});
ppc_prepare_menu_definition_port(startup, current_gworld, current_gdevice);
let invocation = startup
.active_menu_definition()
.and_then(MenuDefinitionTracking::pending_invocation)?;
let action = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
startup,
invocation,
cpu.pc,
);
if action.is_none() {
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
}
action
}
#[allow(clippy::too_many_arguments)]
fn ppc_continue_custom_popup_menu_tracking(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
startup: &mut PpcToolboxStartupState,
current_gworld: &mut u32,
current_gdevice: &mut u32,
input: PpcInputSnapshot,
resources: &[PpcVfsResourceRecord],
) -> PpcImportAction {
let Some(call) = startup.execution.menu().context().native_popup() else {
startup.clear_active_menu_definition();
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
return PpcImportAction::Return(0);
};
let completed = match startup
.with_active_menu_definition_mut(MenuDefinitionTracking::complete_callback)
.transpose()
{
Ok(completed) => completed.flatten(),
Err(()) => {
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(0);
}
};
if startup
.execution
.menu()
.as_ref()
.is_some_and(|state| state.is_flashing())
{
let tick = memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.unwrap_or(0);
let step = startup.execution.advance_menu_flash(tick).unwrap();
if matches!(step, MenuFlashStep::Wait | MenuFlashStep::Inactive) {
return PpcImportAction::Yield(u64::MAX);
}
if let MenuFlashStep::Complete(result) = step {
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(result);
}
let invocation = startup
.active_menu_definition()
.and_then(MenuDefinitionTracking::pending_invocation)
.unwrap();
if let Some(action) = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
startup,
invocation,
cpu.pc,
) {
return action;
}
}
if completed == Some(MenuDefinitionMessage::PopUp) {
let Some(front) = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD) else {
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(0);
};
let definition = startup.active_menu_definition().unwrap().clone();
let (top, left, bottom, right) = definition.menu_rect();
let Some(mut state) = ppc_begin_tracked_menu_with_appearances(
memory,
front,
MenuTrackingKind::PopUp,
definition.menu_handle(),
left,
top,
top,
right.saturating_sub(left),
bottom.saturating_sub(top),
0,
Vec::new(),
) else {
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(0);
};
if ppc_draw_tracked_menu_chrome(
memory,
gworlds,
screen_clut,
menu_colors,
StandardMenuPaneKind::PopUp,
&state,
)
.is_none()
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(0);
}
state.definition = startup
.execution
.with_menu_context_mut(|context| context.definition.take());
startup.execution.set_menu_state(Some(state));
startup
.with_active_menu_definition_mut(|definition| definition.draw())
.unwrap();
let invocation = startup
.active_menu_definition()
.and_then(MenuDefinitionTracking::pending_invocation)
.unwrap();
if let Some(action) = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
startup,
invocation,
cpu.pc,
) {
return action;
}
} else {
let hit_point = (u32::from(input.mouse_v as u16) << 16) | u32::from(input.mouse_h as u16);
let choose = startup
.with_active_menu_definition_mut(|definition| definition.choose(hit_point))
.flatten();
if let Some(invocation) = choose {
if let Some(action) = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
startup,
invocation,
cpu.pc,
) {
return action;
}
} else if input.mouse_button {
return PpcImportAction::Yield(u64::MAX);
} else if let Some(definition) = startup.active_menu_definition().cloned() {
let item = definition.which_item();
let menu_id = memory
.read_u32_be(definition.menu_handle())
.filter(|ptr| *ptr != 0)
.and_then(|menu| memory.read_u16_be(menu))
.unwrap_or(0);
let result = if item > 0 {
(u32::from(menu_id) << 16) | u32::from(item as u16)
} else {
0
};
if result != 0 {
let tick = memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.unwrap_or(0);
let flashes = memory
.read_u16_be(crate::memory::globals::addr::MENU_FLASH)
.unwrap_or(crate::memory::globals::DEFAULT_MENU_FLASH_COUNT);
let flash_enabled = startup
.execution
.begin_menu_flash(tick, flashes, result)
.unwrap();
if !flash_enabled {
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(result);
}
return PpcImportAction::Yield(u64::MAX);
}
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(result);
}
}
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
PpcImportAction::Return(0)
}
#[allow(clippy::too_many_arguments)]
fn ppc_dispatch_pop_up_menu_select(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
startup: &mut PpcToolboxStartupState,
input: PpcInputSnapshot,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> PpcImportAction {
let menu_handle = cpu.gpr[3];
let call = ppc_popup_menu_call(cpu);
let current_menu_list = ppc_current_menu_list(memory);
if let Some(state) = startup.execution.menu().as_ref() {
if startup.execution.menu().context().caller_isa() == Some(GuestIsa::M68k) {
// A classic MenuSelect owns this process continuation. A nested
// native call must not consume its save-under or origin ABI frame.
return PpcImportAction::Return(0);
}
if state.kind != MenuTrackingKind::PopUp
|| startup.execution.menu().context().native_popup() != Some(call)
|| state.menu_handle != menu_handle
{
// A callback may enter a different modal menu routine while an
// outer import is parked. Never let that nested call consume the
// outer routine's save-under or eventual result.
return PpcImportAction::Return(0);
}
let live_front = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD);
if live_front.map(MenuTrackingSurface::from) != state.front_buffer {
// A changed PixMap/depth makes the saved coordinates unsafe to
// write. Abandon the overlay without touching either buffer.
startup.execution.set_menu_state(None);
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
return PpcImportAction::Return(0);
}
if !ppc_popup_menu_is_inserted(memory, current_menu_list, menu_handle) {
let Some(state) = startup.execution.take_menu_state() else {
return PpcImportAction::Return(0);
};
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
return PpcImportAction::Return(0);
}
if state.is_flashing() {
let Some(mut state) = startup.execution.take_menu_state() else {
return PpcImportAction::Return(0);
};
let step = state.advance_flash_at(
memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.unwrap_or(0),
);
if matches!(step, MenuFlashStep::Wait | MenuFlashStep::Inactive) {
startup.execution.set_menu_state(Some(state));
return PpcImportAction::Yield(u64::MAX);
}
if let MenuFlashStep::Complete(result) = step {
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
return PpcImportAction::Return(result);
}
let visible_item = if step == MenuFlashStep::Highlight(true) {
state.highlighted_item
} else {
0
};
ppc_redraw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
&state,
visible_item,
);
startup.execution.set_menu_state(Some(state));
return PpcImportAction::Yield(u64::MAX);
}
let Some(mut state) = startup.execution.take_menu_state() else {
return PpcImportAction::Return(0);
};
// Popup tracking uses the same retained MenuRows state as MenuSelect.
// In particular, this updates content_top and the scrolling globals
// while the pointer sits on an indicator; deriving only a hit item
// leaves long popup menus visually stuck at their initial viewport.
ppc_update_menu_tracking(
memory,
gworlds,
screen_clut,
menu_colors,
current_menu_list,
&mut state,
input,
resources,
current_resource_refnum,
);
let highlighted_item = state.highlighted_item;
if !input.mouse_button {
if highlighted_item == 0 {
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
return PpcImportAction::Return(0);
}
let menu_id = memory
.read_u32_be(menu_handle)
.filter(|ptr| *ptr != 0)
.and_then(|menu| memory.read_u16_be(menu))
.unwrap_or(0);
let result = (u32::from(menu_id) << 16) | u32::from(highlighted_item as u16);
state.set_flash_tick(
memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.unwrap_or(0),
);
let flash_enabled = state.begin_flash(
memory
.read_u16_be(crate::memory::globals::addr::MENU_FLASH)
.unwrap_or(crate::memory::globals::DEFAULT_MENU_FLASH_COUNT),
result,
);
if !flash_enabled {
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
return PpcImportAction::Return(result);
}
ppc_redraw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
&state,
highlighted_item,
);
startup.execution.set_menu_state(Some(state));
return PpcImportAction::Yield(u64::MAX);
}
ppc_redraw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
&state,
highlighted_item,
);
startup.execution.set_menu_state(Some(state));
return PpcImportAction::Yield(u64::MAX);
}
if !input.mouse_button || !ppc_popup_menu_is_inserted(memory, current_menu_list, menu_handle) {
return PpcImportAction::Return(0);
}
let Some(front) = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD) else {
return PpcImportAction::Return(0);
};
let Some((popup_left, popup_top, popup_width, popup_height, requested_item, content_top)) =
ppc_popup_menu_layout_with_resources(
memory,
call.popup_request().unwrap(),
front,
resources,
current_resource_refnum,
)
else {
return PpcImportAction::Return(0);
};
let highlighted_item = if ppc_menu_item_is_selectable(memory, menu_handle, requested_item) {
requested_item
} else {
0
};
let appearances =
ppc_menu_item_appearances(memory, menu_handle, resources, current_resource_refnum);
let Some(state) = ppc_begin_tracked_menu_with_appearances(
memory,
front,
MenuTrackingKind::PopUp,
menu_handle,
popup_left,
popup_top,
content_top,
popup_width,
popup_height,
highlighted_item,
appearances,
) else {
return PpcImportAction::Return(0);
};
let rows = ppc_menu_tracking_rows(memory, &state);
ppc_write_menu_scrolling_globals(memory, &rows, content_top);
ppc_draw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
StandardMenuPaneKind::PopUp,
&state,
highlighted_item,
);
startup.execution.set_menu_state(Some(state));
startup
.execution
.with_menu_context_mut(|context| {
context.call.get_or_insert(call);
});
PpcImportAction::Yield(u64::MAX)
}
fn ppc_menu_key(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
key: u8,
) -> Option<MenuKeySelection> {
ppc_menu_list_definition(memory, menu_list_handle)?
.menu_key_selection(key, |menu_handle| ppc_menu_key_menu(memory, menu_handle))
}
fn ppc_menu_key_menu(memory: &mut PpcSectionMem, menu_handle: u32) -> Option<MenuKeyMenu> {
let menu = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0)?;
let flags = memory.read_u32_be(menu + 10)?;
let items = (1..=ppc_count_menu_items(memory, menu_handle))
.map(|item| {
let item = item as i16;
MenuKeyItem {
command: ppc_menu_item_attribute_address(memory, menu_handle, item, 1)
.and_then(|address| memory.read_u8(address))
.unwrap_or(0),
mark: ppc_menu_item_attribute_address(memory, menu_handle, item, 2)
.and_then(|address| memory.read_u8(address))
.unwrap_or(0),
enabled: item > 31 || flags & (1u32 << item) != 0,
}
})
.collect();
Some(MenuKeyMenu {
id: memory.read_u16_be(menu)? as i16,
enabled: flags & 1 != 0,
items,
})
}
fn ppc_menu_handle_at_title_point(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
initial_point: u32,
) -> Option<(u32, i16)> {
let initial_v = (initial_point >> 16) as u16 as i16;
let initial_h = initial_point as u16 as i16;
let menu_bar_height = memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap_or(20) as i16;
if initial_v < 0 || initial_v >= menu_bar_height {
return None;
}
let (menu_handle, title_left) = ppc_menu_list_definition(memory, menu_list_handle)?
.regular_title_at_horizontal(initial_h)?;
memory
.read_u32_be(menu_handle)
.filter(|menu| *menu != 0)
.map(|_| (menu_handle, title_left))
}
#[cfg(test)]
fn ppc_menu_tracking_hit(
memory: &mut PpcSectionMem,
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
input: PpcInputSnapshot,
) -> Option<i16> {
let rows = ppc_menu_tracking_rows(memory, state);
let rect = (
state.popup_top(),
state.popup_left(),
state.popup_top().saturating_add(state.popup_height()),
state.popup_left().saturating_add(state.popup_width()),
);
let inside = input.mouse_v >= rect.0
&& input.mouse_v < rect.2
&& input.mouse_h >= rect.1
&& input.mouse_h < rect.3;
(inside
|| rows
.pointer_scroll_direction(rect, state.content_top(), (input.mouse_v, input.mouse_h))
.is_some())
.then(|| rows.tracking_item_at_point(rect, state.content_top(), (input.mouse_v, input.mouse_h)))
}
fn ppc_menu_tracking_rows(
memory: &mut PpcSectionMem,
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
) -> MenuRows {
MenuRows::new(
state
.item_appearances()
.iter()
.enumerate()
.map(|(index, appearance)| {
let item = i16::try_from(index + 1).unwrap_or(i16::MAX);
MenuRow {
height: appearance.height,
selectable: ppc_menu_item_is_selectable(memory, state.menu_handle(), item),
}
}),
)
}
fn ppc_write_menu_scrolling_globals(memory: &mut PpcSectionMem, rows: &MenuRows, content_top: i16) {
ppc_write_menu_scrolling_bounds(
memory,
content_top,
content_top.saturating_add(rows.total_height()),
);
}
fn ppc_write_menu_scrolling_bounds(
memory: &mut PpcSectionMem,
content_top: i16,
content_bottom: i16,
) {
let _ = memory.write_u16_be(
crate::memory::globals::addr::TOP_MENU_ITEM,
content_top as u16,
);
let _ = memory.write_u16_be(
crate::memory::globals::addr::AT_MENU_BOTTOM,
content_bottom as u16,
);
}
fn ppc_write_standard_menu_choice(memory: &mut PpcSectionMem, menu_handle: u32, item_number: i16) {
let Some(menu_id) = memory
.read_u32_be(menu_handle)
.filter(|menu| *menu != 0)
.and_then(|menu| memory.read_u16_be(menu))
.map(|menu_id| menu_id as i16)
else {
return;
};
let _ = memory.write_u32_be(
crate::memory::globals::addr::MENU_DISABLE,
menu_choice_value(menu_id, item_number),
);
}
#[cfg(test)]
fn ppc_menu_tracking_item(
memory: &mut PpcSectionMem,
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
input: PpcInputSnapshot,
) -> i16 {
ppc_menu_tracking_hit(memory, state, input).unwrap_or(0)
}
#[allow(clippy::too_many_arguments)]
fn ppc_begin_tracked_menu_with_appearances(
memory: &mut PpcSectionMem,
front: PpcFrontBuffer,
kind: MenuTrackingKind,
menu_handle: u32,
popup_left: i16,
popup_top: i16,
content_top: i16,
popup_width: i16,
popup_height: i16,
highlighted_item: i16,
item_appearances: Vec<PpcTrackedMenuItemAppearance>,
) -> Option<PpcMenuTracking> {
if popup_left < 0 || popup_top < 0 || popup_width <= 0 || popup_height <= 0 {
return None;
}
let saved_width = popup_width.checked_add(1)?;
let saved_height = popup_height.checked_add(1)?;
let saved_right = i32::from(popup_left).checked_add(i32::from(saved_width))?;
let saved_bottom = i32::from(popup_top).checked_add(i32::from(saved_height))?;
if saved_right > i32::try_from(front.width).ok()?
|| saved_bottom > i32::try_from(front.height).ok()?
{
return None;
}
let saved_len =
usize::try_from(i32::from(saved_width).checked_mul(i32::from(saved_height))?).ok()?;
let mut saved_pixels = Vec::with_capacity(saved_len);
for y in 0..i32::from(saved_height) {
for x in 0..i32::from(saved_width) {
saved_pixels.push(ppc_quickdraw_read_pixel(
memory,
front,
(i32::from(popup_left) + x, i32::from(popup_top) + y),
)?);
}
}
let mut saved_pixels = crate::memory::SavedPixels::from(saved_pixels);
for y in 0..i32::from(saved_height) {
for x in 0..i32::from(saved_width) {
ppc_capture_saved_detail(
memory,
front,
(i32::from(popup_left) + x, i32::from(popup_top) + y),
&mut saved_pixels,
(y * i32::from(saved_width) + x) as usize,
);
}
}
Some(PpcMenuTracking {
kind,
menu_handle,
popup_left,
popup_top,
content_top,
scroll_direction: None,
popup_width,
popup_height,
highlighted_item,
definition: None,
flash_remaining: 0,
flash_tick: None,
flash_deadline: 0,
flash_result: 0,
saved_width,
saved_height,
front_buffer: Some(front.into()),
saved_pixels: saved_pixels.into(),
item_appearances,
submenus: Vec::new(),
})
}
fn ppc_restore_tracked_menu(
memory: &mut PpcSectionMem,
surface: Option<MenuTrackingSurface>,
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
) {
let Some(surface) = surface else {
return;
};
if Some(surface) != state.front_buffer() {
return;
}
let front = PpcFrontBuffer::from(surface);
let mut index = 0usize;
for y in 0..i32::from(state.saved_height()) {
for x in 0..i32::from(state.saved_width()) {
if let Some(pixel) = state.saved_pixels().get(index).copied() {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(
i32::from(state.popup_left()) + x,
i32::from(state.popup_top()) + y,
),
pixel,
);
ppc_restore_saved_detail(
memory,
front,
(
i32::from(state.popup_left()) + x,
i32::from(state.popup_top()) + y,
),
state.saved_pixels(),
index,
);
}
index += 1;
}
}
}
fn ppc_restore_menu_tracking(
memory: &mut PpcSectionMem,
surface: Option<MenuTrackingSurface>,
state: &PpcMenuTracking,
) {
for submenu in state.submenus.iter().rev() {
ppc_restore_tracked_menu(memory, surface, submenu);
}
ppc_restore_tracked_menu(memory, surface, state);
}
pub(super) fn ppc_physical_screen_color_pixel(
front: PpcFrontBuffer,
color: PpcRgbColor,
screen_clut: &[[u16; 3]; 256],
) -> Option<u16> {
match front.depth {
depth @ (1 | 2 | 4 | 8) => Some(u16::from(ppc_rgb_color_to_index_in_clut(
color,
screen_clut,
ppc_indexed_depth_entry_count(depth)?,
))),
16 => Some(ppc_rgb_color_to_rgb555(color)),
_ => None,
}
}
fn ppc_menu_rgb(rgb: [u16; 3]) -> PpcRgbColor {
PpcRgbColor {
red: rgb[0],
green: rgb[1],
blue: rgb[2],
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_draw_tracked_menu_icon(
memory: &mut PpcSectionMem,
front: PpcFrontBuffer,
screen_clut: &[[u16; 3]; 256],
icon: &PpcTrackedMenuIcon,
top: i16,
left: i16,
content_pixel: u16,
) {
// The shared standard-MDEF sampler owns monochrome resource validation,
// reduced-ICON scaling, and SICN first-image selection. This adapter owns
// retained resource bytes and framebuffer writes. Macintosh Toolbox
// Essentials (1992), pp. 3-45--3-46 and 3-62--3-63.
let monochrome = match icon {
PpcTrackedMenuIcon::Icon { data, reduced } => Some((
data,
if *reduced {
StandardMenuIconKind::Reduced
} else {
StandardMenuIconKind::Normal
},
)),
PpcTrackedMenuIcon::SmallIcon(data) => Some((data, StandardMenuIconKind::Small)),
PpcTrackedMenuIcon::CIcon(_) => None,
};
if let Some((data, kind)) = monochrome {
let Some(layout) = MonochromeMenuIconLayout::for_kind(kind, Some(data.len())) else {
return;
};
for y in 0..layout.height {
for x in 0..layout.width {
if layout
.sample_with(|offset| data.get(offset).copied(), x, y)
.unwrap_or(false)
{
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(i32::from(left) + x as i32, i32::from(top) + y as i32),
content_pixel,
);
}
}
}
return;
}
// Compiled color icons retain their ColorTable mapping through the active
// device table. Imaging With QuickDraw (1994), pp. 4-105--4-106.
match icon {
PpcTrackedMenuIcon::CIcon(data) => {
let Some(layout) = ColorIconLayout::decode(data) else {
return;
};
for y in 0..usize::try_from(layout.height).unwrap_or_default() {
for x in 0..usize::try_from(layout.width).unwrap_or_default() {
if !layout
.mask_bit_with(|offset| data.get(offset).copied(), x, y)
.unwrap_or(false)
{
continue;
}
let pixel = if front.depth == 1 {
layout
.monochrome_bit_with(|offset| data.get(offset).copied(), x, y)
.filter(|set| *set)
.map(|_| content_pixel)
} else {
layout
.rgb_with(|offset| data.get(offset).copied(), x, y)
.map(|[red, green, blue]| PpcRgbColor { red, green, blue })
.and_then(|rgb| {
ppc_physical_screen_color_pixel(front, rgb, screen_clut)
})
};
if let Some(pixel) = pixel {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(i32::from(left) + x as i32, i32::from(top) + y as i32),
pixel,
);
}
}
}
}
PpcTrackedMenuIcon::Icon { .. } | PpcTrackedMenuIcon::SmallIcon(_) => unreachable!(),
}
}
/// Draw the Menu Manager-owned structure and erase a menu's contents before
/// either the standard or an application-defined MDEF draws its items.
/// Macintosh Toolbox Essentials (1992), pp. 3-90 and 3-148--3-150.
fn ppc_draw_tracked_menu_chrome(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
kind: StandardMenuPaneKind,
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
) -> Option<(PpcFrontBuffer, u16, u16)> {
let Some(front) = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD) else {
return None;
};
let menu_id = memory
.read_u32_be(state.menu_handle())
.filter(|ptr| *ptr != 0)
.and_then(|menu| memory.read_u16_be(menu))
.unwrap_or(0) as i16;
let theme = ppc_ui_theme(gworlds);
let background_rgb = if theme == UiThemeId::ClassicSystem7 {
ppc_menu_rgb(menu_colors.dropdown_background(menu_id))
} else {
ppc_theme_rgb(theme.provider().palette().window_background)
};
let (Some(background), Some(black)) = (
ppc_physical_screen_color_pixel(front, background_rgb, screen_clut),
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, screen_clut),
) else {
return None;
};
let chrome = StandardMenuChrome::new(kind, state.dropdown_rect())?;
for y in 0..i32::from(state.popup_height()) {
for x in 0..i32::from(state.popup_width()) {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(
i32::from(state.popup_left()) + x,
i32::from(state.popup_top()) + y,
),
background,
);
}
}
chrome.for_each_frame_pixel(|x, y| {
let _ = ppc_quickdraw_write_raw_pixel(memory, front, (i32::from(x), i32::from(y)), black);
});
// Macintosh Toolbox Essentials (1992), pp. 3-122--3-123: the standard
// menu definition draws a one-pixel shadow below and to the right of the
// menu. The saved rectangle includes those pixels so closing the menu is
// byte-for-byte reversible even for packed destinations.
chrome.for_each_shadow_pixel(|x, y| {
let _ = ppc_quickdraw_write_raw_pixel(memory, front, (i32::from(x), i32::from(y)), black);
});
Some((front, background, black))
}
fn ppc_draw_tracked_menu(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
kind: StandardMenuPaneKind,
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
selected: i16,
) {
let Some((front, background, black)) =
ppc_draw_tracked_menu_chrome(memory, gworlds, screen_clut, menu_colors, kind, state)
else {
return;
};
let theme = ppc_ui_theme(gworlds);
let palette = theme.provider().palette();
let rect = state.dropdown_rect();
let rows = ppc_menu_tracking_rows(memory, state);
let (scroll_up, scroll_down) = rows.scroll_indicators(rect, state.content_top());
let visible_item_top = state
.popup_top()
.saturating_add(if scroll_up { 16 } else { 0 });
let visible_item_bottom = state
.popup_top()
.saturating_add(state.popup_height())
.saturating_sub(if scroll_down { 16 } else { 0 });
for y in 1..i32::from(state.popup_height()).saturating_sub(1) {
let absolute_y = state
.popup_top()
.saturating_add(i16::try_from(y).unwrap_or(i16::MAX));
let indicator = (scroll_up && absolute_y < visible_item_top)
|| (scroll_down && absolute_y >= visible_item_bottom);
if indicator {
for x in 1..i32::from(state.popup_width()).saturating_sub(1) {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(
i32::from(state.popup_left()) + x,
i32::from(state.popup_top()) + y,
),
black,
);
}
}
}
let popup_bottom = state.popup_top().saturating_add(state.popup_height());
for item in 1..=i16::try_from(state.item_appearances().len()).unwrap_or(i16::MAX) {
let Some((address, len)) = ppc_menu_item(memory, state.menu_handle(), item) else {
continue;
};
let text = ppc_memory_read_bytes(memory, address + 1, u32::from(len)).unwrap_or_default();
let row_top = state
.content_top()
.saturating_add(ppc_tracked_menu_item_offset(state, item));
let row_height = ppc_tracked_menu_item_height(state, item);
if row_top.saturating_add(row_height) <= state.popup_top() {
continue;
}
if row_top >= popup_bottom.saturating_sub(1) {
break;
}
if row_top < visible_item_top || row_top.saturating_add(row_height) > visible_item_bottom {
continue;
}
let row_bottom = row_top.saturating_add(row_height).min(popup_bottom - 1);
let command = memory.read_u8(address + 2 + u32::from(len)).unwrap_or(0);
let mark = memory.read_u8(address + 3 + u32::from(len)).unwrap_or(0);
let style = memory.read_u8(address + 4 + u32::from(len)).unwrap_or(0);
let menu_id = memory
.read_u32_be(state.menu_handle())
.filter(|ptr| *ptr != 0)
.and_then(|menu| memory.read_u16_be(menu))
.unwrap_or(0) as i16;
let item_colors = menu_colors.item_colors(menu_id, item);
let is_separator = text == b"-";
let is_hierarchical = command == 0x1b && mark != 0;
let has_command_key = command > 0x20;
let dimmed = !ppc_menu_item_enabled(memory, state.menu_handle(), item) || is_separator;
let highlighted = item == selected && !dimmed;
let dimmed_color = MenuColorTable::dimmed(item_colors.name, item_colors.background);
let component = |foreground: [u16; 3]| {
let rgb = if theme != UiThemeId::ClassicSystem7 {
ppc_theme_components(if highlighted {
palette.frame_light
} else if dimmed {
palette.accent
} else {
palette.frame_dark
})
} else if highlighted {
item_colors.background
} else if dimmed && front.depth != 1 {
dimmed_color
} else {
foreground
};
let rgb = ppc_menu_rgb(rgb);
let pixel = ppc_physical_screen_color_pixel(front, rgb, screen_clut).unwrap_or(black);
let explicit =
ppc_indexed_depth_entry_count(front.depth).and_then(|_| u8::try_from(pixel).ok());
(rgb, pixel, explicit)
};
let (mark_color, _mark_pixel, mark_index) = component(item_colors.mark);
let (name_color, name_pixel, name_index) = component(item_colors.name);
let (command_color, command_pixel, command_index) = component(item_colors.command);
if highlighted {
let selected_background = ppc_physical_screen_color_pixel(
front,
if theme == UiThemeId::ClassicSystem7 {
ppc_menu_rgb(item_colors.name)
} else {
ppc_theme_rgb(palette.selection)
},
screen_clut,
)
.unwrap_or(black);
for y in row_top..row_bottom {
for x in state.popup_left().saturating_add(1)
..state
.popup_left()
.saturating_add(state.popup_width())
.saturating_sub(1)
{
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(i32::from(x), i32::from(y)),
selected_background,
);
}
}
}
let metrics = get_font_metrics(PPC_QD_TEXT_FONT_DEFAULT, PPC_QD_TEXT_SIZE_SYSTEM);
let appearance = usize::try_from(item.saturating_sub(1))
.ok()
.and_then(|index| state.item_appearances().get(index));
let layout = standard_menu_item_layout(
(
state.popup_left(),
state.popup_left().saturating_add(state.popup_width()),
),
(row_top, row_height),
appearance
.map(|appearance| appearance.icon_kind)
.unwrap_or(StandardMenuIconKind::None),
mark != 0,
(metrics.ascent, metrics.descent),
kind == StandardMenuPaneKind::PullDown,
);
let text_baseline = layout.text_baseline;
if is_separator {
let separator_y = layout.separator_y;
for x in 1..state.popup_width().saturating_sub(1) {
if front.depth == 1
&& !standard_menu_gray_pattern_is_ink(
state.popup_left().saturating_add(x),
separator_y,
)
{
continue;
}
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(
i32::from(state.popup_left().saturating_add(x)),
i32::from(separator_y),
),
name_pixel,
);
}
continue;
}
// Standard menu items reserve a left mark/icon column. A submenu's
// mark byte is its menu ID, so it is represented by the triangle on
// the right instead of being drawn as a marking character.
// Macintosh Toolbox Essentials (1992), pp. 3-12--3-13.
if mark != 0 && !is_hierarchical {
let mark_char = if mark == 0x12 {
'\u{2713}'
} else {
char::from(mark)
};
ppc_draw_text_chars(
memory,
gworlds,
PPC_MAIN_GWORLD,
(layout.mark_left, text_baseline),
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
PPC_QD_TEXT_MODE_SRC_OR,
mark_color,
mark_index,
std::iter::once(mark_char),
);
}
if let Some(icon) = appearance.and_then(|appearance| appearance.icon.as_ref()) {
ppc_draw_tracked_menu_icon(
memory,
front,
screen_clut,
icon,
row_top,
layout.icon_left,
name_pixel,
);
}
let mode = PPC_QD_TEXT_MODE_SRC_OR;
let _ = ppc_draw_text_bytes_styled(
memory,
gworlds,
PPC_MAIN_GWORLD,
(layout.text_left, text_baseline),
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
mode,
name_color,
name_index,
style,
&text,
);
if is_hierarchical {
for_each_standard_hierarchy_indicator_pixel(
layout.indicator_left,
layout.indicator_mid_y,
|x, y| {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(i32::from(x), i32::from(y)),
command_pixel,
);
},
);
} else if has_command_key {
ppc_draw_text_chars(
memory,
gworlds,
PPC_MAIN_GWORLD,
(layout.command_left, text_baseline),
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
mode,
command_color,
command_index,
['\u{2318}', char::from(command)],
);
}
// On a one-bit device the standard MDEF dims the complete item with
// the 50-percent gray pattern because no intermediate color exists.
// Macintosh Toolbox Essentials (1992), pp. 3-13 and 3-150.
if dimmed && front.depth == 1 {
for y in row_top..row_bottom {
for x in state.popup_left().saturating_add(1)
..state
.popup_left()
.saturating_add(state.popup_width())
.saturating_sub(1)
{
if !standard_menu_gray_pattern_is_ink(x, y) {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(i32::from(x), i32::from(y)),
background,
);
}
}
}
}
}
// Scrolling indicators replace the first/last visible item positions.
// Inside Macintosh Volume V (1986), pp. V-248--V-249.
let center_x = state.popup_left().saturating_add(state.popup_width() / 2);
if scroll_up {
for_each_standard_scroll_up_indicator_pixel(center_x, state.popup_top(), |x, y| {
let _ =
ppc_quickdraw_write_raw_pixel(memory, front, (i32::from(x), i32::from(y)), black);
});
}
if scroll_down {
for_each_standard_scroll_down_indicator_pixel(
center_x,
state.popup_top().saturating_add(state.popup_height()),
|x, y| {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front,
(i32::from(x), i32::from(y)),
black,
);
},
);
}
}
fn ppc_redraw_tracked_menu(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
state: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
visible_item: i16,
) -> bool {
let Some(front) = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD) else {
return false;
};
if Some(MenuTrackingSurface::from(front)) != state.front_buffer() {
return false;
}
ppc_restore_tracked_menu(memory, Some(front.into()), state);
ppc_draw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
StandardMenuPaneKind::PopUp,
state,
visible_item,
);
true
}
fn ppc_submenu_handle_for_item(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
parent_menu_handle: u32,
parent_item: i16,
) -> Option<u32> {
let parent_items = ppc_menu_items_from_memory(memory, parent_menu_handle)?;
ppc_menu_list_definition(memory, menu_list_handle)?.submenu_handle_for_item(
&parent_items,
parent_item,
|handle| {
memory
.read_u32_be(handle)
.filter(|menu| *menu != 0)
.and_then(|menu| memory.read_u16_be(menu))
.map(|menu_id| menu_id as i16)
},
)
}
fn ppc_menu_item_is_hierarchical(memory: &mut PpcSectionMem, menu_handle: u32, item: i16) -> bool {
ppc_menu_items_from_memory(memory, menu_handle)
.is_some_and(|items| items.item_is_hierarchical(item))
}
#[cfg(test)]
fn ppc_begin_submenu_tracking(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
front: PpcFrontBuffer,
parent: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
parent_item: i16,
) -> Option<PpcSubmenuTracking> {
let menu_handle =
ppc_submenu_handle_for_item(memory, menu_list_handle, parent.menu_handle(), parent_item)?;
ppc_begin_submenu_tracking_with_resources(
memory,
front,
parent,
parent_item,
menu_handle,
&[],
0,
)
}
fn ppc_begin_submenu_tracking_with_resources(
memory: &mut PpcSectionMem,
front: PpcFrontBuffer,
parent: &impl TrackedMenuPaneView<
MenuRef = u32,
Surface = Option<MenuTrackingSurface>,
Pixel = u16,
Appearance = PpcTrackedMenuItemAppearance,
>,
parent_item: i16,
menu_handle: u32,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> Option<PpcSubmenuTracking> {
let custom_definition = ppc_menu_uses_guest_definition(memory, resources, menu_handle);
if !custom_definition {
ppc_calc_menu_size_with_resources(memory, menu_handle, resources, current_resource_refnum);
}
let item_appearances = if custom_definition {
Vec::new()
} else {
ppc_menu_item_appearances(memory, menu_handle, resources, current_resource_refnum)
};
let menu = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0)?;
let front_width = ppc_u32_to_i16_saturating(front.width);
let front_height = ppc_u32_to_i16_saturating(front.height);
let desired_width = if custom_definition {
memory.read_u16_be(menu + 2)? as i16
} else {
i16::try_from(memory.read_u16_be(menu + 2)?.max(32)).ok()?
};
let desired_height = if custom_definition {
memory.read_u16_be(menu + 4)? as i16
} else {
ppc_menu_appearance_height(&item_appearances)
};
let menu_bar_height = memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap_or(20) as i16;
let layout = standard_submenu_layout(
parent.dropdown_rect(),
ppc_tracked_menu_item_offset(parent, parent_item),
desired_width,
desired_height,
(front_width, front_height),
menu_bar_height,
)?;
let popup_left = layout.left;
let popup_top = layout.top;
let popup_width = layout.width;
let popup_height = layout.height;
let saved_width = popup_width.checked_add(1)?;
let saved_height = popup_height.checked_add(1)?;
let saved_len =
usize::try_from(i32::from(saved_width).checked_mul(i32::from(saved_height))?).ok()?;
let mut saved_pixels = Vec::with_capacity(saved_len);
for y in 0..i32::from(saved_height) {
for x in 0..i32::from(saved_width) {
saved_pixels.push(ppc_quickdraw_read_pixel(
memory,
front,
(i32::from(popup_left) + x, i32::from(popup_top) + y),
)?);
}
}
let mut saved_pixels = crate::memory::SavedPixels::from(saved_pixels);
for y in 0..i32::from(saved_height) {
for x in 0..i32::from(saved_width) {
ppc_capture_saved_detail(
memory,
front,
(i32::from(popup_left) + x, i32::from(popup_top) + y),
&mut saved_pixels,
(y * i32::from(saved_width) + x) as usize,
);
}
}
Some(PpcSubmenuTracking {
parent_item,
menu_handle,
popup_left,
popup_top,
content_top: layout.content_top,
scroll_direction: None,
popup_width,
popup_height,
highlighted_item: 0,
definition: custom_definition
.then(|| MenuDefinitionTracking::begin_draw(menu_handle, layout.rect())),
saved_width,
saved_height,
front_buffer: Some(front.into()),
saved_pixels: saved_pixels.into(),
item_appearances,
})
}
fn ppc_ensure_tracked_submenu(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
state: &mut PpcMenuTracking,
request: SubmenuRequest<u32>,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) {
let resolved_child = ppc_submenu_handle_for_item(
memory,
menu_list_handle,
request.parent_handle,
request.parent_item,
);
let (token, closed) = match state.reconcile_submenu(request, resolved_child) {
SubmenuReconciliation::Stale | SubmenuReconciliation::Keep => return,
SubmenuReconciliation::Closed {
panes_deepest_first,
} => {
for submenu in panes_deepest_first {
ppc_restore_tracked_menu(memory, submenu.front_buffer, &submenu);
}
return;
}
SubmenuReconciliation::Open {
token,
panes_deepest_first,
} => (token, panes_deepest_first),
};
for submenu in closed {
ppc_restore_tracked_menu(memory, submenu.front_buffer, &submenu);
}
let request = token.request();
let submenu_handle = token.child_handle();
let Some(front) = state.front_buffer.map(PpcFrontBuffer::from) else {
return;
};
let submenu = match request.parent {
MenuTrackingPane::Submenu(depth) => {
let Some(parent) = state.submenus.get(depth).cloned() else {
return;
};
ppc_begin_submenu_tracking_with_resources(
memory,
front,
&parent,
request.parent_item,
submenu_handle,
resources,
current_resource_refnum,
)
}
MenuTrackingPane::Root => ppc_begin_submenu_tracking_with_resources(
memory,
front,
state,
request.parent_item,
submenu_handle,
resources,
current_resource_refnum,
),
};
if let Some(submenu) = submenu {
if let Err(submenu) = state.install_submenu(token, submenu) {
if !submenu.saved_pixels.is_empty() {
ppc_restore_tracked_menu(memory, submenu.front_buffer, &submenu);
}
}
}
}
fn ppc_draw_open_tracked_submenus(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
state: &PpcMenuTracking,
) {
for submenu in &state.submenus {
if submenu.definition.is_some() {
let _ = ppc_draw_tracked_menu_chrome(
memory,
gworlds,
screen_clut,
menu_colors,
StandardMenuPaneKind::Hierarchical,
submenu,
);
} else {
ppc_draw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
StandardMenuPaneKind::Hierarchical,
submenu,
submenu.highlighted_item,
);
}
}
}
// The standard MDEF alternately highlights and unhighlights only the chosen
// leaf while its parent hierarchy remains open. MenuFlash supplies the repeat
// count. Macintosh Toolbox Essentials (1992), pp. 3-115 and 3-142.
fn ppc_redraw_standard_menu_tracking_flash(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
state: &PpcMenuTracking,
selected: (u32, i16),
visible: bool,
) {
ppc_restore_menu_tracking(memory, state.front_buffer, state);
let root_item = if !visible && selected.0 == state.menu_handle {
0
} else {
state.highlighted_item
};
ppc_draw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
state.kind.into(),
state,
root_item,
);
for submenu in &state.submenus {
let visible_item = if !visible && selected.0 == submenu.menu_handle {
0
} else {
submenu.highlighted_item
};
ppc_draw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
StandardMenuPaneKind::Hierarchical,
submenu,
visible_item,
);
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_update_menu_tracking(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
menu_list_handle: u32,
state: &mut PpcMenuTracking,
input: PpcInputSnapshot,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) {
let point = (input.mouse_v, input.mouse_h);
let root_rows = ppc_menu_tracking_rows(memory, state);
let submenu_rows = state
.submenus
.iter()
.map(|submenu| Some(ppc_menu_tracking_rows(memory, submenu)))
.collect::<Vec<_>>();
let Some(update) = state.track_standard_pointer(&root_rows, &submenu_rows, point) else {
return;
};
let submenu_request = update.submenu_request();
ppc_write_standard_menu_choice(memory, update.menu_handle, update.pointer.menu_choice_item);
for submenu in update.closed_panes_deepest_first {
ppc_restore_tracked_menu(memory, submenu.front_buffer, &submenu);
}
match update.pane {
MenuTrackingPane::Root => ppc_draw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
state.kind.into(),
state,
update.pointer.item,
),
MenuTrackingPane::Submenu(depth) if update.pointer.scrolled => {
let submenu = &state.submenus[depth];
ppc_draw_tracked_menu(
memory,
gworlds,
screen_clut,
menu_colors,
StandardMenuPaneKind::Hierarchical,
submenu,
submenu.highlighted_item,
);
}
MenuTrackingPane::Submenu(_) => {}
}
if let Some(request) = submenu_request {
ppc_ensure_tracked_submenu(
memory,
menu_list_handle,
state,
request,
resources,
current_resource_refnum,
);
}
ppc_write_menu_scrolling_bounds(memory, update.content_top, update.content_bottom);
ppc_draw_open_tracked_submenus(memory, gworlds, screen_clut, menu_colors, state);
}
fn ppc_tracked_menu_selection(
memory: &mut PpcSectionMem,
state: &PpcMenuTracking,
) -> Option<(u32, i16)> {
state.selection(|menu_handle, item| {
ppc_menu_item_is_selectable(memory, menu_handle, item)
&& !ppc_menu_item_is_hierarchical(memory, menu_handle, item)
})
}
fn ppc_deepest_highlighted_menu_item(state: &PpcMenuTracking) -> Option<(u32, i16)> {
state
.submenus
.iter()
.rev()
.find_map(|submenu| {
(submenu.highlighted_item > 0)
.then_some((submenu.menu_handle, submenu.highlighted_item))
})
.or_else(|| {
(state.highlighted_item > 0).then_some((state.menu_handle, state.highlighted_item))
})
}
#[cfg(test)]
fn ppc_begin_menu_bar_tracking(
memory: &mut PpcSectionMem,
front: PpcFrontBuffer,
menu_handle: u32,
title_left: i16,
) -> Option<PpcMenuTracking> {
ppc_begin_menu_bar_tracking_with_resources(memory, front, menu_handle, title_left, &[], 0)
}
fn ppc_begin_menu_bar_tracking_with_resources(
memory: &mut PpcSectionMem,
front: PpcFrontBuffer,
menu_handle: u32,
title_left: i16,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> Option<PpcMenuTracking> {
ppc_calc_menu_size_with_resources(memory, menu_handle, resources, current_resource_refnum);
let item_appearances =
ppc_menu_item_appearances(memory, menu_handle, resources, current_resource_refnum);
let menu = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0)?;
let menu_bar_height = memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap_or(20) as i16;
let front_width = ppc_u32_to_i16_saturating(front.width);
let front_height = ppc_u32_to_i16_saturating(front.height);
let desired_width = i16::try_from(memory.read_u16_be(menu + 2)?.max(32)).unwrap_or(i16::MAX);
let desired_height = ppc_menu_appearance_height(&item_appearances);
let layout = standard_pull_down_menu_layout(
desired_width,
desired_height,
(front_width, front_height),
title_left,
menu_bar_height,
)?;
ppc_begin_tracked_menu_with_appearances(
memory,
front,
MenuTrackingKind::MenuBar,
menu_handle,
layout.left,
layout.top,
layout.content_top,
layout.width,
layout.height,
0,
item_appearances,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_begin_custom_menu_bar_tracking(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
startup: &mut PpcToolboxStartupState,
current_gworld: &mut u32,
current_gdevice: &mut u32,
initial_point: u32,
resources: &[PpcVfsResourceRecord],
) -> Option<PpcImportAction> {
let menu_list = ppc_current_menu_list(memory);
let front = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)?;
let (menu_handle, title_left) =
ppc_menu_handle_at_title_point(memory, menu_list, initial_point)?;
ppc_menu_definition_target(cpu, memory, resources, menu_handle)?;
let menu = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0)?;
let menu_bar_height = memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap_or(20) as i16;
let layout = standard_pull_down_menu_layout(
memory.read_u16_be(menu + 2)? as i16,
memory.read_u16_be(menu + 4)? as i16,
(
ppc_u32_to_i16_saturating(front.width),
ppc_u32_to_i16_saturating(front.height),
),
title_left,
menu_bar_height,
)?;
let mut state = ppc_begin_tracked_menu_with_appearances(
memory,
front,
MenuTrackingKind::MenuBar,
menu_handle,
layout.left,
layout.top,
layout.content_top,
layout.width,
layout.height,
0,
Vec::new(),
)?;
state.definition = Some(MenuDefinitionTracking::begin_draw(
menu_handle,
state.dropdown_rect(),
));
let menu_id = memory.read_u16_be(menu).unwrap_or(0) as i16;
ppc_set_menu_title_highlight_with_colors(
memory,
gworlds,
menu_list,
menu_id,
screen_clut,
menu_colors,
startup.host_menu_bar_hidden,
);
ppc_draw_tracked_menu_chrome(
memory,
gworlds,
screen_clut,
menu_colors,
StandardMenuPaneKind::PullDown,
&state,
)?;
startup.execution.set_menu_state(Some(state));
startup.execution.with_menu_context_mut(|context| {
context
.call
.get_or_insert(ppc_menu_select_call(cpu, initial_point));
});
ppc_prepare_menu_definition_port(startup, current_gworld, current_gdevice);
let invocation = startup
.active_menu_definition()
.and_then(MenuDefinitionTracking::pending_invocation)?;
let action = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
startup,
invocation,
cpu.pc,
);
if action.is_none() {
if let Some(state) = startup.execution.take_menu_state() {
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_menu());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
ppc_set_menu_command_highlight_with_colors(
memory,
gworlds,
menu_list,
0,
None,
screen_clut,
menu_colors,
startup.host_menu_bar_hidden,
);
}
action
}
#[allow(clippy::too_many_arguments)]
fn ppc_continue_custom_menu_bar_tracking(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
startup: &mut PpcToolboxStartupState,
current_gworld: &mut u32,
current_gdevice: &mut u32,
input: PpcInputSnapshot,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> PpcImportAction {
let Some(call) = startup.execution.menu().context().native_menu() else {
startup.clear_active_menu_definition();
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
return PpcImportAction::Return(0);
};
let Some(completed) = startup
.with_active_menu_definition_mut(MenuDefinitionTracking::complete_callback)
else {
cpu.lr = call.origin.return_address();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_menu());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
return PpcImportAction::Return(0);
};
let completed = match completed {
Ok(completed) => completed,
Err(()) => {
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_menu());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(0);
}
};
if completed == Some(MenuDefinitionMessage::Choose) {
let active_submenu = startup.execution.menu().as_ref().and_then(|state| {
match state.active_definition_pane() {
Some(MenuDefinitionPane::Submenu(depth)) => state
.submenus
.get(depth)
.map(|submenu| submenu.dropdown_rect()),
_ => None,
}
});
if let Some((top, left, bottom, right)) = active_submenu {
if input.mouse_v < top
|| input.mouse_v >= bottom
|| input.mouse_h < left
|| input.mouse_h >= right
{
let menu_list = ppc_current_menu_list(memory);
if let Some(mut state) = startup.execution.take_menu_state() {
ppc_update_menu_tracking(
memory,
gworlds,
screen_clut,
menu_colors,
menu_list,
&mut state,
input,
resources,
current_resource_refnum,
);
startup.execution.set_menu_state(Some(state));
}
if startup.active_menu_definition().is_none() {
startup
.execution
.with_menu_context_mut(|context| context.clear_native_menu());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Yield(u64::MAX);
}
if let Some(invocation) = startup
.active_menu_definition()
.and_then(MenuDefinitionTracking::pending_invocation)
{
if let Some(action) = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
startup,
invocation,
cpu.pc,
) {
return action;
}
}
}
}
}
if startup
.execution
.menu()
.as_ref()
.is_some_and(|state| state.is_flashing())
{
let tick = memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.unwrap_or(0);
let step = startup.execution.advance_menu_flash(tick).unwrap();
if matches!(step, MenuFlashStep::Wait | MenuFlashStep::Inactive) {
return PpcImportAction::Yield(u64::MAX);
}
if let MenuFlashStep::Complete(result) = step {
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
let menu_list = ppc_current_menu_list(memory);
ppc_set_menu_command_highlight_with_colors(
memory,
gworlds,
menu_list,
result,
None,
screen_clut,
menu_colors,
startup.host_menu_bar_hidden,
);
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_menu());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(result);
}
let invocation = startup
.active_menu_definition()
.and_then(MenuDefinitionTracking::pending_invocation)
.unwrap();
if let Some(action) = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
startup,
invocation,
cpu.pc,
) {
return action;
}
}
let hit_point = (u32::from(input.mouse_v as u16) << 16) | u32::from(input.mouse_h as u16);
let invocation = startup
.with_active_menu_definition_mut(|definition| {
definition.choose(hit_point)?;
definition.pending_invocation()
})
.flatten();
if let Some(invocation) = invocation {
if let Some(action) = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
startup,
invocation,
cpu.pc,
) {
return action;
}
let menu_list = ppc_current_menu_list(memory);
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_menu());
ppc_set_menu_command_highlight_with_colors(
memory,
gworlds,
menu_list,
0,
None,
screen_clut,
menu_colors,
startup.host_menu_bar_hidden,
);
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(0);
}
if input.mouse_button {
return PpcImportAction::Yield(u64::MAX);
}
let definition = startup.active_menu_definition().unwrap().clone();
let item = definition.which_item();
let menu_handle = definition.menu_handle();
let menu_id = memory
.read_u32_be(menu_handle)
.filter(|ptr| *ptr != 0)
.and_then(|menu| memory.read_u16_be(menu))
.unwrap_or(0);
let result = if item > 0 {
(u32::from(menu_id) << 16) | u32::from(item as u16)
} else {
0
};
if result != 0 {
let tick = memory
.read_u32_be(crate::memory::globals::addr::TICKS)
.unwrap_or(0);
let flashes = memory
.read_u16_be(crate::memory::globals::addr::MENU_FLASH)
.unwrap_or(crate::memory::globals::DEFAULT_MENU_FLASH_COUNT);
let flash_enabled = startup
.execution
.begin_menu_flash(tick, flashes, result)
.unwrap();
if !flash_enabled {
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
let menu_list = ppc_current_menu_list(memory);
ppc_set_menu_command_highlight_with_colors(
memory,
gworlds,
menu_list,
result,
None,
screen_clut,
menu_colors,
startup.host_menu_bar_hidden,
);
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_menu());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
return PpcImportAction::Return(result);
}
return PpcImportAction::Yield(u64::MAX);
}
if let Some(state) = startup.execution.take_menu_state() {
if ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
.map(MenuTrackingSurface::from)
== state.front_buffer
{
ppc_restore_menu_tracking(memory, state.front_buffer, &state);
}
}
let menu_list = ppc_current_menu_list(memory);
ppc_set_menu_command_highlight_with_colors(
memory,
gworlds,
menu_list,
result,
None,
screen_clut,
menu_colors,
startup.host_menu_bar_hidden,
);
startup.clear_active_menu_definition();
startup
.execution
.with_menu_context_mut(|context| context.clear_native_menu());
ppc_restore_menu_definition_port(startup, current_gworld, current_gdevice);
cpu.lr = call.origin.return_address();
PpcImportAction::Return(result)
}
#[cfg(test)]
fn ppc_track_menu_while_held(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
startup: &mut PpcToolboxStartupState,
initial_point: u32,
input: PpcInputSnapshot,
) {
ppc_track_menu_while_held_with_resources(
memory,
gworlds,
screen_clut,
MenuColorTable::new(&[]),
startup,
initial_point,
input,
&[],
0,
);
}
#[allow(clippy::too_many_arguments)]
fn ppc_track_menu_while_held_with_resources(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
startup: &mut PpcToolboxStartupState,
initial_point: u32,
input: PpcInputSnapshot,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) {
let current_menu_list = ppc_current_menu_list(memory);
let Some(front) = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD) else {
return;
};
if startup
.execution
.menu()
.as_ref()
.is_some_and(|state| state.kind != MenuTrackingKind::MenuBar)
{
return;
}
if startup.host_menu_bar_hidden {
if let Some(previous) = startup.execution.take_menu_state() {
if previous.front_buffer == Some(front.into()) {
ppc_restore_menu_tracking(memory, Some(front.into()), &previous);
}
}
let _ = memory.write_u16_be(PPC_THE_MENU_ADDR, 0);
return;
}
if let Some(previous) = startup.execution.take_menu_state() {
if previous.front_buffer != Some(front.into()) {
ppc_restore_menu_tracking(memory, previous.front_buffer, &previous);
let _ = memory.write_u16_be(PPC_THE_MENU_ADDR, 0);
let _ = ppc_draw_menu_bar_with_colors(
memory,
gworlds,
current_menu_list,
screen_clut,
menu_colors,
);
return;
}
// MenuSelect keeps tracking while the button is held. Crossing a
// regular title closes the old dropdown and opens the new title's
// menu, including a disabled menu whose items can only be examined.
// Macintosh Toolbox Essentials (1992), pp. 3-6--3-7 and 3-115.
let live_point = (u32::from(input.mouse_v as u16) << 16) | u32::from(input.mouse_h as u16);
let switched = ppc_menu_handle_at_title_point(memory, current_menu_list, live_point)
.filter(|(menu_handle, _)| *menu_handle != previous.menu_handle);
if let Some((menu_handle, title_left)) = switched {
ppc_restore_menu_tracking(memory, Some(front.into()), &previous);
startup.execution.set_menu_state(
ppc_begin_menu_bar_tracking_with_resources(
memory,
front,
menu_handle,
title_left,
resources,
current_resource_refnum,
),
);
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
} else {
startup.execution.set_menu_state(Some(previous));
}
} else {
let Some((menu_handle, title_left)) =
ppc_menu_handle_at_title_point(memory, current_menu_list, initial_point)
else {
return;
};
let Some(state) = ppc_begin_menu_bar_tracking_with_resources(
memory,
front,
menu_handle,
title_left,
resources,
current_resource_refnum,
) else {
return;
};
startup.execution.set_menu_state(Some(state));
startup
.execution
.with_menu_context_mut(|context| context.clear_native_popup());
}
let active_menu_id = startup.execution.menu().as_ref().and_then(|state| {
memory
.read_u32_be(state.menu_handle)
.filter(|menu| *menu != 0)
.and_then(|menu| memory.read_u16_be(menu))
.map(|menu_id| menu_id as i16)
});
if let Some(active_menu_id) = active_menu_id {
ppc_set_menu_title_highlight_with_colors(
memory,
gworlds,
current_menu_list,
active_menu_id,
screen_clut,
menu_colors,
startup.host_menu_bar_hidden,
);
}
if let Some(mut state) = startup.execution.take_menu_state() {
// MenuSelect highlights the title and tracks the pointer until the
// button is released, displaying the selected item inversely. A
// hierarchical title opens its installed submenu while remaining
// highlighted. Macintosh Toolbox Essentials (1992), pp. 3-38--3-39,
// 3-43--3-45, and 3-122.
ppc_update_menu_tracking(
memory,
gworlds,
screen_clut,
menu_colors,
current_menu_list,
&mut state,
input,
resources,
current_resource_refnum,
);
startup.execution.set_menu_state(Some(state));
}
}
fn ppc_finish_menu_bar_tracking_with_colors(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
startup: &mut PpcToolboxStartupState,
_input: PpcInputSnapshot,
) -> Option<u32> {
if startup
.execution
.menu()
.as_ref()
.is_some_and(|state| state.kind != MenuTrackingKind::MenuBar)
{
return None;
}
let state = startup.execution.menu().as_ref()?;
let selection = (!startup.host_menu_bar_hidden)
.then(|| ppc_tracked_menu_selection(memory, state))
.flatten();
let result = selection
.and_then(|(menu_handle, item)| {
memory
.read_u32_be(menu_handle)
.filter(|ptr| *ptr != 0)
.and_then(|menu| memory.read_u16_be(menu))
.map(|menu_id| (u32::from(menu_id) << 16) | u32::from(item as u16))
})
.unwrap_or(0);
ppc_complete_menu_bar_tracking_with_colors(
memory,
gworlds,
screen_clut,
menu_colors,
startup,
result,
)
}
fn ppc_complete_menu_bar_tracking_with_colors(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
startup: &mut PpcToolboxStartupState,
result: u32,
) -> Option<u32> {
let current_menu_list = ppc_current_menu_list(memory);
let state = startup.execution.take_menu_state()?;
if let Some(front) = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD) {
if Some(MenuTrackingSurface::from(front)) == state.front_buffer {
ppc_restore_menu_tracking(memory, Some(front.into()), &state);
}
}
// Macintosh Toolbox Essentials (1992), pp. 3-89 and 3-115--3-116: a
// valid MenuSelect result leaves the originating regular title visibly
// highlighted, but TheMenu contains the selected submenu's ID. Releasing
// over a disabled item, divider, the menu bar, or no menu clears both.
// Macintosh Toolbox Essentials (1992), pp. 3-115--3-116.
ppc_set_menu_command_highlight_with_colors(
memory,
gworlds,
current_menu_list,
result,
None,
screen_clut,
menu_colors,
startup.host_menu_bar_hidden,
);
if result == 0 && !startup.host_menu_bar_hidden {
let _ = ppc_draw_menu_bar_with_colors(
memory,
gworlds,
current_menu_list,
screen_clut,
menu_colors,
);
}
Some(result)
}
#[cfg(test)]
fn ppc_finish_menu_bar_tracking(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
startup: &mut PpcToolboxStartupState,
input: PpcInputSnapshot,
) -> Option<u32> {
if let Some(mut state) = startup.execution.take_menu_state() {
let menu_list = ppc_current_menu_list(memory);
ppc_update_menu_tracking(
memory,
gworlds,
screen_clut,
MenuColorTable::new(&[]),
menu_list,
&mut state,
input,
&[],
0,
);
startup.execution.set_menu_state(Some(state));
}
ppc_finish_menu_bar_tracking_with_colors(
memory,
gworlds,
screen_clut,
MenuColorTable::new(&[]),
startup,
input,
)
}
/// Materialize one resource-backed menu for both `GetMenu` and `GetNewMBar`.
/// Unlike raw Resource Manager lookup, `GetMenu` reads both the MENU and its
/// definition procedure into memory. Macintosh Toolbox Essentials (1992),
/// pp. 3-106--3-107 and 3-111--3-112.
#[allow(clippy::too_many_arguments)]
fn ppc_load_menu_resource(
menu_id: i16,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
current_resource_refnum: i16,
last_resource_error: &mut i16,
) -> u32 {
let menu_type = u32::from_be_bytes(*b"MENU");
let Some(index) = ppc_vfs_resource_index(
vfs_resources,
current_resource_refnum,
menu_type,
menu_id,
false,
) else {
*last_resource_error = PPC_NO_ERR;
return 0;
};
let handle = ppc_materialize_vfs_resource_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
index,
true,
last_resource_error,
);
if handle != 0
&& !ppc_resolve_menu_definition(
handle,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
last_resource_error,
)
{
return 0;
}
if handle != 0 {
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
ppc_load_menu_color_resource_with_allocator(
menu_id,
Some(&mut allocator),
None,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
);
}
handle
}
/// Load the MDEF resource whose Handle belongs in `MenuInfo.menuProc`.
/// `NewMenu` loads the standard definition procedure, while `GetMenu` loads
/// the definition resource named by the compiled MENU placeholder. Macintosh
/// Toolbox Essentials (1992), pp. 3-95--3-96 and 3-105--3-107.
#[allow(clippy::too_many_arguments)]
fn ppc_menu_definition_handle(
mdef_id: i16,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
current_resource_refnum: i16,
last_resource_error: &mut i16,
) -> u32 {
let mdef_type = u32::from_be_bytes(*b"MDEF");
let index = match ppc_vfs_resource_index(
vfs_resources,
current_resource_refnum,
mdef_type,
mdef_id,
false,
) {
Some(index) => index,
None if mdef_id == 0 => {
vfs_resources.push(PpcVfsResourceRecord {
ref_num: 0,
path: "__system__/MDEF".to_string(),
res_type: mdef_type,
res_id: 0,
name: Vec::new(),
data: STANDARD_MENU_DEFINITION_SHIM.to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
vfs_resources.len() - 1
}
None => {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return 0;
}
};
ppc_materialize_vfs_resource_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
index,
true,
last_resource_error,
)
}
/// Replace a compiled MENU resource's MDEF-ID placeholder with the loaded
/// definition-procedure Handle. Inside Macintosh Volume I (1985), p. I-127;
/// Macintosh Toolbox Essentials (1992), pp. 3-106--3-107.
#[allow(clippy::too_many_arguments)]
fn ppc_resolve_menu_definition(
menu_handle: u32,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
current_resource_refnum: i16,
last_resource_error: &mut i16,
) -> bool {
let Some(menu_ptr) = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0) else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return false;
};
let Some(menu_proc) = memory.read_u32_be(menu_ptr + 6) else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return false;
};
let mdef_type = u32::from_be_bytes(*b"MDEF");
if menu_proc != 0
&& vfs_resources
.iter()
.any(|resource| resource.res_type == mdef_type && resource.handle == menu_proc)
{
return true;
}
let mdef_id = (menu_proc >> 16) as u16 as i16;
let mdef_handle = ppc_menu_definition_handle(
mdef_id,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
last_resource_error,
);
if mdef_handle == 0 || memory.write_u32_be(menu_ptr + 6, mdef_handle).is_none() {
if mdef_handle != 0 {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
}
return false;
}
true
}
fn ppc_menu_color_table_bytes(memory: &mut PpcSectionMem, handles: &[PpcHandleRecord]) -> Vec<u8> {
let handle = memory
.read_u32_be(crate::memory::globals::addr::MENU_C_INFO)
.unwrap_or(0);
ppc_menu_handle_bytes(memory, handles, handle).unwrap_or_default()
}
fn ppc_ensure_menu_color_table_handle_with_allocator(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
legacy_free_handle_blocks: Option<&mut Vec<PpcHandleRecord>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> u32 {
let current = memory
.read_u32_be(crate::memory::globals::addr::MENU_C_INFO)
.unwrap_or(0);
if current != 0 {
return current;
}
let handle = if let Some(allocator) = allocator {
allocator.allocate_handle_with_bytes(memory, heap_cursor, last_mem_error, handles, &[])
} else {
ppc_alloc_recyclable_handle_with_bytes(
memory,
heap_cursor,
heap_limit,
handles,
legacy_free_handle_blocks.expect("legacy menu allocation requires a free list"),
&[],
)
};
if handle != 0 {
let _ = memory.write_u32_be(crate::memory::globals::addr::MENU_C_INFO, handle);
}
handle
}
#[cfg(test)]
fn ppc_ensure_menu_color_table_handle(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
free_handle_blocks: &mut Vec<PpcHandleRecord>,
) -> u32 {
let mut last_mem_error = PPC_NO_ERR;
ppc_ensure_menu_color_table_handle_with_allocator(
None,
Some(free_handle_blocks),
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_load_menu_color_resource_with_allocator(
resource_id: i16,
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
legacy_free_handle_blocks: Option<&mut Vec<PpcHandleRecord>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) {
let Some(index) = ppc_vfs_resource_index(
vfs_resources,
current_resource_refnum,
u32::from_be_bytes(*b"mctb"),
resource_id,
false,
) else {
return;
};
let incoming = compiled_menu_color_entries(&vfs_resources[index].data);
if incoming.is_empty() {
return;
}
let handle = ppc_ensure_menu_color_table_handle_with_allocator(
allocator.as_deref_mut(),
legacy_free_handle_blocks,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
if handle == 0 {
return;
}
let current = ppc_menu_color_table_bytes(memory, handles);
let merged = merge_menu_color_entries(¤t, &incoming);
let _ = ppc_replace_menu_bytes_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
&merged,
);
}
fn ppc_clear_menu_color_table_with_allocator(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) {
ppc_filter_menu_color_table_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
|_id, _item| false,
);
}
fn ppc_filter_menu_color_table_with_allocator(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
keep: impl FnMut(i16, i16) -> bool,
) {
let handle = memory
.read_u32_be(crate::memory::globals::addr::MENU_C_INFO)
.unwrap_or(0);
if handle == 0 {
return;
}
let current = ppc_menu_color_table_bytes(memory, handles);
let filtered = filter_menu_color_entries(¤t, keep);
let _ = ppc_replace_menu_bytes_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
&filtered,
);
}
#[allow(clippy::too_many_arguments)]
fn ppc_get_menu_bar_with_allocator(
current_menu_list: u32,
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
legacy_free_handle_blocks: Option<&mut Vec<PpcHandleRecord>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> u32 {
let menu_list = if current_menu_list == 0 {
PpcMenuListDefinition::default()
} else {
let Some(menu_list) = ppc_menu_list_definition(memory, current_menu_list) else {
*last_mem_error = PPC_PARAM_ERR;
return 0;
};
menu_list
};
let handle = ppc_alloc_menu_list_definition_handle_with_allocator(
&menu_list,
allocator,
legacy_free_handle_blocks,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
*last_mem_error = if handle == 0 {
PPC_MEM_FULL_ERR
} else {
PPC_NO_ERR
};
handle
}
fn ppc_alloc_menu_list_handle_with_allocator(
menu_handles: &[u32],
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
legacy_free_handle_blocks: Option<&mut Vec<PpcHandleRecord>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> u32 {
let mut menu_list =
PpcMenuListDefinition::from_regular_handles(0, menu_handles.iter().copied());
ppc_relayout_menu_list(memory, &mut menu_list);
ppc_alloc_menu_list_definition_handle_with_allocator(
&menu_list,
allocator,
legacy_free_handle_blocks,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
)
}
#[cfg(test)]
fn ppc_alloc_menu_list_handle(
menu_handles: &[u32],
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
free_handle_blocks: &mut Vec<PpcHandleRecord>,
) -> u32 {
let mut last_mem_error = PPC_NO_ERR;
ppc_alloc_menu_list_handle_with_allocator(
menu_handles,
None,
Some(free_handle_blocks),
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
)
}
fn ppc_alloc_menu_list_definition_handle_with_allocator(
menu_list: &PpcMenuListDefinition,
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
legacy_free_handle_blocks: Option<&mut Vec<PpcHandleRecord>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> u32 {
let bytes = ppc_menu_list_bytes(menu_list);
if let Some(allocator) = allocator {
allocator.allocate_handle_with_bytes(memory, heap_cursor, last_mem_error, handles, &bytes)
} else {
ppc_alloc_recyclable_handle_with_bytes(
memory,
heap_cursor,
heap_limit,
handles,
legacy_free_handle_blocks.expect("legacy menu allocation requires a free list"),
&bytes,
)
}
}
#[cfg(test)]
fn ppc_alloc_menu_list_definition_handle(
menu_list: &PpcMenuListDefinition,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
free_handle_blocks: &mut Vec<PpcHandleRecord>,
) -> u32 {
let mut last_mem_error = PPC_NO_ERR;
ppc_alloc_menu_list_definition_handle_with_allocator(
menu_list,
None,
Some(free_handle_blocks),
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_get_new_mbar(
mbar_id: i16,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
current_resource_refnum: i16,
last_resource_error: &mut i16,
) -> u32 {
let mbar_type = u32::from_be_bytes(*b"MBAR");
let Some(mbar_index) = ppc_vfs_resource_index(
vfs_resources,
current_resource_refnum,
mbar_type,
mbar_id,
false,
) else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return 0;
};
let Some(mbar) = MenuBarResource::decode(&vfs_resources[mbar_index].data) else {
*last_resource_error = PPC_RES_NOT_FOUND_ERR;
return 0;
};
// GetNewMBar saves the current menu list but clears MenuCInfo before it
// calls GetMenu for each compiled menu ID. The rebuilt color table remains
// current after the old menu list is restored. Macintosh Toolbox
// Essentials (1992), pp. 3-111--3-112.
{
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
ppc_clear_menu_color_table_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
}
let menu_handles = mbar.load_regular_handles(|menu_id| {
let handle = ppc_load_menu_resource(
menu_id,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
last_resource_error,
);
(handle != 0).then_some(handle)
});
// Macintosh Toolbox Essentials (1992), pp. 3-110--3-112 and 3-155:
// GetNewMBar expands the MBAR's ordered MENU resource IDs into a new,
// caller-owned menu-list handle; it does not install or draw that list.
let mut menu_list = PpcMenuListDefinition::from_regular_handles(mbar_id, menu_handles);
ppc_relayout_menu_list(memory, &mut menu_list);
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let handle = ppc_alloc_menu_list_definition_handle_with_allocator(
&menu_list,
Some(&mut allocator),
None,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
if handle == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return 0;
}
*last_mem_error = PPC_NO_ERR;
*last_resource_error = PPC_NO_ERR;
handle
}
fn ppc_continue_menu_bar_build(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
startup: &mut PpcToolboxStartupState,
resources: &[PpcVfsResourceRecord],
current_resource_refnum: i16,
) -> PpcImportAction {
loop {
let menu_handle = match startup.execution.calls()
.advance_menu_bar_build(GuestIsa::PowerPc)
{
Some(MenuBarBuildResume::Size(handle)) => handle,
Some(MenuBarBuildResume::Complete {
result,
origin: MenuBarCallOrigin::PowerPc { return_address },
}) => {
cpu.lr = return_address;
return PpcImportAction::Return(result);
}
Some(MenuBarBuildResume::Waiting) => return PpcImportAction::Yield(u64::MAX),
_ => return PpcImportAction::Return(0),
};
if let Some(action) = ppc_dispatch_native_menu_definition(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
resources,
startup,
MenuDefinitionInvocation::size(menu_handle),
cpu.pc,
) {
return action;
}
ppc_calc_menu_size_with_resources(memory, menu_handle, resources, current_resource_refnum);
}
}
#[cfg(test)]
fn ppc_menu_list_handles(memory: &mut PpcSectionMem, menu_list_handle: u32) -> Option<Vec<u32>> {
Some(
ppc_menu_list_definition(memory, menu_list_handle)?
.handles()
.collect(),
)
}
fn ppc_menu_list_definition(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
) -> Option<PpcMenuListDefinition> {
let list = memory
.read_u32_be(menu_list_handle)
.filter(|ptr| *ptr != 0)?;
let regular_bytes = usize::from(memory.read_u16_be(list)?);
if regular_bytes % 6 != 0 || regular_bytes / 6 > MAX_MENU_LIST_ENTRIES {
return None;
}
let hierarchical_header = list.checked_add(6 + u32::try_from(regular_bytes).ok()?)?;
let hierarchical_bytes = usize::from(memory.read_u16_be(hierarchical_header)?);
if hierarchical_bytes % 6 != 0 || hierarchical_bytes / 6 > MAX_MENU_LIST_ENTRIES {
return None;
}
let byte_count = 12usize
.checked_add(regular_bytes)?
.checked_add(hierarchical_bytes)?;
let bytes = ppc_memory_read_bytes(memory, list, u32::try_from(byte_count).ok()?)?;
PpcMenuListDefinition::decode(&bytes)
}
fn ppc_menu_list_bytes(menu_list: &PpcMenuListDefinition) -> Vec<u8> {
menu_list.encode()
}
fn ppc_relayout_menu_list(memory: &mut PpcSectionMem, menu_list: &mut PpcMenuListDefinition) {
menu_list.relayout_regular_titles(
STANDARD_MENU_BAR_FIRST_TITLE_LEFT,
STANDARD_MENU_BAR_TITLE_SPACING,
|handle| {
memory
.read_u32_be(handle)
.filter(|menu| *menu != 0)
.and_then(|menu| ppc_read_pascal_string(memory, menu.checked_add(14)?))
.map(|title| standard_menu_title_advance(&title))
.unwrap_or(0)
},
);
}
fn ppc_replace_menu_list_definition_with_allocator(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
menu_list_handle: u32,
menu_list: &PpcMenuListDefinition,
) -> i16 {
let bytes = ppc_menu_list_bytes(menu_list);
ppc_replace_menu_bytes_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
menu_list_handle,
&bytes,
)
}
#[cfg(test)]
fn ppc_replace_menu_list_definition(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
menu_list_handle: u32,
menu_list: &PpcMenuListDefinition,
) -> i16 {
let mut last_mem_error = PPC_NO_ERR;
ppc_replace_menu_list_definition_with_allocator(
None,
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
menu_list_handle,
menu_list,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_insert_menu_with_allocator(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
legacy_free_handle_blocks: Option<&mut Vec<PpcHandleRecord>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
menu_handle: u32,
before_id: i16,
) -> i16 {
if memory
.read_u32_be(menu_handle)
.filter(|ptr| *ptr != 0)
.is_none()
{
return PPC_PARAM_ERR;
}
let mut current_menu_list = ppc_current_menu_list(memory);
if current_menu_list == 0 {
current_menu_list = ppc_alloc_menu_list_handle_with_allocator(
&[],
allocator.as_deref_mut(),
legacy_free_handle_blocks,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
if current_menu_list == 0 {
return PPC_MEM_FULL_ERR;
}
ppc_set_current_menu_list(memory, current_menu_list);
}
let Some(mut menu_list) = ppc_menu_list_definition(memory, current_menu_list) else {
return PPC_PARAM_ERR;
};
if !menu_list.insert(menu_handle, before_id, |candidate| {
memory
.read_u32_be(candidate)
.and_then(|menu| memory.read_u16_be(menu))
.map(|id| id as i16)
}) {
return PPC_NO_ERR;
}
ppc_relayout_menu_list(memory, &mut menu_list);
ppc_replace_menu_list_definition_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
current_menu_list,
&menu_list,
)
}
#[cfg(test)]
#[allow(clippy::too_many_arguments)]
fn ppc_insert_menu(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
free_handle_blocks: &mut Vec<PpcHandleRecord>,
menu_handle: u32,
before_id: i16,
) -> i16 {
let mut last_mem_error = PPC_NO_ERR;
ppc_insert_menu_with_allocator(
None,
Some(free_handle_blocks),
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
menu_handle,
before_id,
)
}
fn ppc_delete_menu_with_allocator(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
menu_list_handle: u32,
menu_id: i16,
) -> i16 {
if menu_list_handle == 0 {
return PPC_NO_ERR;
}
let Some(mut menu_list) = ppc_menu_list_definition(memory, menu_list_handle) else {
return PPC_PARAM_ERR;
};
if menu_list
.remove_by_id(menu_id, |candidate| {
memory
.read_u32_be(candidate)
.and_then(|menu| memory.read_u16_be(menu))
.map(|id| id as i16)
})
.is_none()
{
return PPC_NO_ERR;
}
ppc_relayout_menu_list(memory, &mut menu_list);
let result = ppc_replace_menu_list_definition_with_allocator(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
menu_list_handle,
&menu_list,
);
if result == PPC_NO_ERR {
ppc_filter_menu_color_table_with_allocator(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
|id, _item| id != menu_id,
);
}
result
}
#[cfg(test)]
fn ppc_delete_menu(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
menu_list_handle: u32,
menu_id: i16,
) -> i16 {
let mut last_mem_error = PPC_NO_ERR;
ppc_delete_menu_with_allocator(
None,
memory,
heap_cursor,
heap_limit,
&mut last_mem_error,
handles,
menu_list_handle,
menu_id,
)
}
fn ppc_get_menu_handle(memory: &mut PpcSectionMem, menu_list_handle: u32, menu_id: i16) -> u32 {
let Some(menu_list) = ppc_menu_list_definition(memory, menu_list_handle) else {
return 0;
};
menu_list
.find_handle_by_id(menu_id, |handle| {
memory
.read_u32_be(handle)
.filter(|menu| *menu != 0)
.and_then(|menu| memory.read_u16_be(menu))
.map(|id| id as i16)
})
.unwrap_or(0)
}
fn ppc_regular_menu_contains_id(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
menu_id: i16,
) -> bool {
let Some(menu_list) = ppc_menu_list_definition(memory, menu_list_handle) else {
return false;
};
let contains = menu_list.regular_handles().any(|menu_handle| {
memory
.read_u32_be(menu_handle)
.filter(|menu| *menu != 0)
.and_then(|menu| memory.read_u16_be(menu))
.map(|id| id as i16)
== Some(menu_id)
});
contains
}
fn ppc_root_menu_id_for_selection(
memory: &mut PpcSectionMem,
menu_list_handle: u32,
selected_menu_id: i16,
) -> i16 {
let Some(menu_list) = ppc_menu_list_definition(memory, menu_list_handle) else {
return 0;
};
menu_list
.owning_regular_menu(selected_menu_id, |menu_handle| {
ppc_menu_key_menu(memory, menu_handle)
})
.map(|(_handle, menu_id)| menu_id)
.unwrap_or(0)
}
fn ppc_flash_entire_menu_bar_with_colors(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
) -> bool {
let Some(front_buffer) = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
else {
return false;
};
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return false;
}
// StandardMBDF reverses the complete bar through MCEntry(0,0)'s RGB4
// menu-bar background and RGB1 title foreground, preserving unrelated
// indexed colors. Inside Macintosh Volume V (1986), pp. V-235 and V-246.
let (Some(background), Some(foreground), Some(black)) = (
ppc_physical_screen_color_pixel(
front_buffer,
ppc_menu_rgb(menu_colors.menu_bar_background()),
screen_clut,
),
ppc_physical_screen_color_pixel(
front_buffer,
ppc_menu_rgb(menu_colors.title_foreground(0)),
screen_clut,
),
ppc_physical_screen_color_pixel(front_buffer, PPC_RGB_BLACK, screen_clut),
) else {
return false;
};
let height = front_buffer.height.min(u32::from(
memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap_or(20),
));
for y in 0..height as i32 {
for x in 0..front_buffer.width as i32 {
let Some(pixel) = ppc_quickdraw_read_pixel(memory, front_buffer, (x, y)) else {
continue;
};
let reversed = standard_menu_highlighted_value(pixel, background, foreground);
let _ = ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), reversed);
}
}
// The outer-screen mask is not menu-bar content and therefore remains
// black while FlashMenuBar(0) reverses the strip.
for_each_standard_menu_bar_corner_pixel(
ppc_u32_to_i16_saturating(front_buffer.width),
|x, y| {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front_buffer,
(i32::from(x), i32::from(y)),
black,
);
},
);
true
}
fn ppc_set_menu_title_highlight_with_colors(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
menu_list_handle: u32,
requested_menu_id: i16,
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
menu_bar_hidden: bool,
) {
let target_menu_id = if requested_menu_id != 0
&& ppc_regular_menu_contains_id(memory, menu_list_handle, requested_menu_id)
{
requested_menu_id
} else {
0
};
let previous_menu_id = memory.read_u16_be(PPC_THE_MENU_ADDR).unwrap_or(0) as i16;
if previous_menu_id == target_menu_id {
return;
}
let _ = memory.write_u16_be(PPC_THE_MENU_ADDR, target_menu_id as u16);
if !menu_bar_hidden {
let _ = ppc_draw_menu_bar_with_colors(
memory,
gworlds,
menu_list_handle,
screen_clut,
menu_colors,
);
}
}
fn ppc_set_menu_command_highlight_with_colors(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
menu_list_handle: u32,
result: u32,
known_root_menu_id: Option<i16>,
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
menu_bar_hidden: bool,
) {
let selected_menu_id = (result >> 16) as u16 as i16;
let root_menu_id = known_root_menu_id.unwrap_or_else(|| {
ppc_root_menu_id_for_selection(memory, menu_list_handle, selected_menu_id)
});
ppc_set_menu_title_highlight_with_colors(
memory,
gworlds,
menu_list_handle,
root_menu_id,
screen_clut,
menu_colors,
menu_bar_hidden,
);
// The highlighted artwork belongs to the originating regular title, but
// TheMenu identifies the menu that owns the chosen item, including a
// hierarchical submenu. Macintosh Toolbox Essentials (1992), pp.
// 3-115--3-119.
let _ = memory.write_u16_be(PPC_THE_MENU_ADDR, selected_menu_id as u16);
}
#[cfg(test)]
fn ppc_set_menu_title_highlight(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
menu_list_handle: u32,
requested_menu_id: i16,
screen_clut: &[[u16; 3]; 256],
menu_bar_hidden: bool,
) {
ppc_set_menu_title_highlight_with_colors(
memory,
gworlds,
menu_list_handle,
requested_menu_id,
screen_clut,
MenuColorTable::new(&[]),
menu_bar_hidden,
);
}
fn ppc_reverse_menu_title_cell(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
region: MenuBarTitleRegion,
menu_bar_height: i16,
background: u16,
foreground: u16,
themed: Option<(u16, u16)>,
) {
if menu_bar_height <= 1 {
return;
}
let screen_width = ppc_u32_to_i16_saturating(front_buffer.width);
let screen_height = ppc_u32_to_i16_saturating(front_buffer.height);
// The standard MBDF's highlighted title rectangle extends beyond the
// logical hit cell and excludes the menu bar's outer border. Inside
// Macintosh Volume I (1985), p. I-356.
let (top, left, bottom, right) = region.highlighted_rect(menu_bar_height);
let left = left.max(0).min(screen_width);
let right = right.max(0).min(screen_width);
let bottom = bottom.min(screen_height);
for y in top..bottom {
for x in left..right {
let Some(pixel) =
ppc_quickdraw_read_pixel(memory, front_buffer, (i32::from(x), i32::from(y)))
else {
continue;
};
let reversed = if let Some((selected_background, selected_foreground)) = themed {
if pixel == background {
selected_background
} else if pixel == foreground {
selected_foreground
} else {
pixel
}
} else {
standard_menu_highlighted_value(pixel, background, foreground)
};
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front_buffer,
(i32::from(x), i32::from(y)),
reversed,
);
}
}
}
fn ppc_menu_bar_title_metrics() -> (i16, i16) {
let (menu_font, numerator, denominator) =
get_font_face_scale_ratio(PPC_QD_TEXT_FONT_DEFAULT, PPC_QD_TEXT_SIZE_SYSTEM);
let menu_ascent =
ppc_scale_font_value(i32::from(menu_font.metrics.ascent), numerator, denominator);
let menu_descent =
ppc_scale_font_value(i32::from(menu_font.metrics.descent), numerator, denominator);
(menu_ascent, menu_descent)
}
fn ppc_menu_bar_title_baseline(menu_bar_height: i16) -> i16 {
let (menu_ascent, menu_descent) = ppc_menu_bar_title_metrics();
// Keep the PowerPC menu title baseline identical to the 68k Menu
// Manager when an application changes MBarHeight: center the live system
// font metrics inside the bar instead of assuming the default 20 pixels.
standard_menu_bar_title_baseline(menu_bar_height, menu_ascent, menu_descent)
}
fn ppc_menu_bar_system_mark_top(menu_bar_height: i16) -> i16 {
let (menu_ascent, menu_descent) = ppc_menu_bar_title_metrics();
standard_menu_bar_system_mark_top(menu_bar_height, menu_ascent, menu_descent)
}
fn ppc_apply_menu_title_dim_pattern(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
rect: (i16, i16, i16, i16),
background: u16,
) {
let screen_width = ppc_u32_to_i16_saturating(front_buffer.width);
let screen_height = ppc_u32_to_i16_saturating(front_buffer.height);
let (top, left, bottom, right) = rect;
for y in top.max(0)..bottom.min(screen_height) {
for x in left.max(0)..right.min(screen_width) {
if standard_menu_gray_pattern_is_ink(x, y) {
continue;
}
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front_buffer,
(i32::from(x), i32::from(y)),
background,
);
}
}
}
fn ppc_draw_menu_bar_with_colors(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
menu_list_handle: u32,
screen_clut: &[[u16; 3]; 256],
menu_colors: MenuColorTable<'_>,
) -> bool {
let theme = ppc_ui_theme(gworlds);
let palette = theme.provider().palette();
let Some(front_buffer) = ppc_live_front_buffer_for_gworld(memory, gworlds, PPC_MAIN_GWORLD)
else {
return false;
};
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16) {
return false;
}
// The standard MBDF resolves the menu-bar background and each title's
// foreground/background from the live MenuCInfo table. Inside Macintosh
// Volume V (1986), pp. V-231--V-235 and V-249--V-250; Macintosh Toolbox
// Essentials (1992), pp. 3-152--3-156.
let (Some(bar_background), Some(black)) = (
ppc_physical_screen_color_pixel(
front_buffer,
if theme == UiThemeId::ClassicSystem7 {
ppc_menu_rgb(menu_colors.menu_bar_background())
} else {
ppc_theme_rgb(palette.window_background)
},
screen_clut,
),
ppc_physical_screen_color_pixel(front_buffer, PPC_RGB_BLACK, screen_clut),
) else {
return false;
};
let height = front_buffer.height.min(u32::from(
memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap_or(20),
)) as i32;
if height == 0 {
return true;
}
for y in 0..height {
let pixel = if y == height - 1 {
black
} else {
bar_background
};
for x in 0..front_buffer.width as i32 {
let _ = ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), pixel);
}
}
for_each_standard_menu_bar_corner_pixel(
ppc_u32_to_i16_saturating(front_buffer.width),
|x, y| {
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front_buffer,
(i32::from(x), i32::from(y)),
black,
);
},
);
let Some(menu_list) = ppc_menu_list_definition(memory, menu_list_handle) else {
return true;
};
// DrawMenuBar redraws the title represented by TheMenu as highlighted
// after drawing the remaining titles. For a submenu-valued TheMenu this
// is the originating regular title. Inside Macintosh Volume V (1986),
// p. V-250; Macintosh Toolbox Essentials (1992), pp. 3-115--3-119.
let selected_menu_id = memory.read_u16_be(PPC_THE_MENU_ADDR).unwrap_or(0) as i16;
let highlighted_menu_id =
ppc_root_menu_id_for_selection(memory, menu_list_handle, selected_menu_id);
struct PendingTitleHighlight {
region: MenuBarTitleRegion,
background: u16,
foreground: u16,
system_menu_mark: bool,
title_h: i16,
dim_pattern: Option<((i16, i16, i16, i16), u16)>,
}
let mut pending_highlight = None;
let menu_bar_height = i16::try_from(height).unwrap_or(i16::MAX);
let title_v = ppc_menu_bar_title_baseline(menu_bar_height);
let (title_ascent, title_descent) = ppc_menu_bar_title_metrics();
// Inside Macintosh Volume V (1986), pp. V-228--V-230: regular MenuList
// entries carry their live menuLeft values and lastRight closes the final
// title cell. The shared MenuList operation is therefore authoritative
// for drawing as well as hit testing; do not reconstruct a second layout
// from title widths in this PowerPC adapter.
for region in menu_list.regular_title_regions() {
if region.handle == 0 {
continue;
}
let Some(menu) = memory.read_u32_be(region.handle).filter(|ptr| *ptr != 0) else {
continue;
};
let menu_id = memory.read_u16_be(menu).unwrap_or(0) as i16;
let title_foreground = if theme == UiThemeId::ClassicSystem7 {
ppc_menu_rgb(menu_colors.title_foreground(menu_id))
} else {
ppc_theme_rgb(palette.frame_dark)
};
let title_background = if theme == UiThemeId::ClassicSystem7 {
ppc_menu_rgb(menu_colors.title_background(menu_id))
} else {
ppc_theme_rgb(palette.window_background)
};
let dimmed_title = ppc_menu_rgb(MenuColorTable::dimmed(
menu_colors.title_foreground(menu_id),
menu_colors.title_background(menu_id),
));
let (Some(title_foreground_pixel), Some(title_background_pixel), Some(dimmed_title_pixel)) = (
ppc_physical_screen_color_pixel(front_buffer, title_foreground, screen_clut),
ppc_physical_screen_color_pixel(front_buffer, title_background, screen_clut),
ppc_physical_screen_color_pixel(front_buffer, dimmed_title, screen_clut),
) else {
continue;
};
// MTE 1992 p. 3-131: DisableItem(menu, 0) disables the whole menu
// title, and HIG 1992 p. 54 says an unavailable title remains visible
// but is drawn in gray. Match the 68k standard definition procedure:
// use the GetGray midpoint when the device can represent it, otherwise
// fall back to the shared 50% gray pattern (IM:V 1986 p. V-142).
let menu_enabled = memory.read_u32_be(menu + 10).unwrap_or(0) & 1 != 0;
let title_ptr = menu.wrapping_add(14);
let Some(title) = ppc_read_pascal_string(memory, title_ptr) else {
continue;
};
let title_h = region.title_origin();
let system_menu_mark = is_standard_system_menu_title(&title);
let (cell_top, cell_left, cell_bottom, cell_right) =
region.highlighted_rect(menu_bar_height);
for y in cell_top.max(0)..cell_bottom.min(ppc_u32_to_i16_saturating(front_buffer.height)) {
for x in cell_left.max(0)..cell_right.min(ppc_u32_to_i16_saturating(front_buffer.width))
{
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front_buffer,
(i32::from(x), i32::from(y)),
title_background_pixel,
);
}
}
if system_menu_mark {
ppc_draw_system_menu_mark(memory, front_buffer, screen_clut, title_h);
} else {
let title_ink = if menu_enabled {
title_foreground
} else {
dimmed_title
};
let title_ink_pixel = if menu_enabled {
title_foreground_pixel
} else {
dimmed_title_pixel
};
let explicit_index = ppc_indexed_depth_entry_count(front_buffer.depth)
.and_then(|_| u8::try_from(title_ink_pixel).ok());
ppc_draw_text_bytes(
memory,
gworlds,
PPC_MAIN_GWORLD,
(title_h, title_v),
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
PPC_QD_TEXT_MODE_SRC_OR,
title_ink,
explicit_index,
&title,
);
}
let highlighted = pending_highlight.is_none()
&& highlighted_menu_id != 0
&& menu_id == highlighted_menu_id;
let dim_with_pattern = !menu_enabled
&& (system_menu_mark
|| dimmed_title_pixel == title_foreground_pixel
|| dimmed_title_pixel == title_background_pixel);
let dim_pattern = dim_with_pattern.then(|| {
let dim_top = if system_menu_mark {
1
} else {
title_v.saturating_sub(title_ascent).max(0)
};
let dim_bottom = if system_menu_mark {
menu_bar_height.saturating_sub(1)
} else {
title_v
.saturating_add(title_descent)
.min(menu_bar_height.saturating_sub(1))
};
(
(
dim_top,
title_h,
dim_bottom,
title_h.saturating_add(standard_menu_title_advance(&title)),
),
if highlighted {
title_foreground_pixel
} else {
title_background_pixel
},
)
});
if highlighted {
pending_highlight = Some(PendingTitleHighlight {
region,
background: title_background_pixel,
foreground: title_foreground_pixel,
system_menu_mark,
title_h,
dim_pattern,
});
} else if let Some((rect, background)) = dim_pattern {
ppc_apply_menu_title_dim_pattern(memory, front_buffer, rect, background);
}
}
if let Some(highlight) = pending_highlight {
// Reverse the selected title only after every normal title has been
// drawn. Adjacent MBDF cells overlap the three-pixel highlight
// overhang, so drawing a later title after this step would erase the
// selected title's right edge. Inside Macintosh Volume V (1986),
// pp. V-235 and V-244.
ppc_reverse_menu_title_cell(
memory,
front_buffer,
highlight.region,
menu_bar_height,
highlight.background,
highlight.foreground,
if theme == UiThemeId::ClassicSystem7 {
None
} else {
Some((
ppc_physical_screen_color_pixel(
front_buffer,
ppc_theme_rgb(palette.selection),
screen_clut,
)
.unwrap_or(highlight.foreground),
ppc_physical_screen_color_pixel(
front_buffer,
ppc_theme_rgb(palette.frame_light),
screen_clut,
)
.unwrap_or(highlight.background),
))
},
);
if highlight.system_menu_mark && front_buffer.depth != 1 {
ppc_draw_system_menu_mark(memory, front_buffer, screen_clut, highlight.title_h);
}
if let Some((rect, background)) = highlight.dim_pattern {
ppc_apply_menu_title_dim_pattern(memory, front_buffer, rect, background);
}
}
true
}
fn ppc_service_invalid_menu_bar(
event_queue: &mut EventQueue,
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
gworlds: &[PpcGWorldRecord],
menu_list_handle: u32,
screen_clut: &[[u16; 3]; 256],
startup: &mut PpcToolboxStartupState,
) -> bool {
if !event_queue.take_menu_bar_invalidation() {
return false;
}
startup.menu_bar_draw_count = startup.menu_bar_draw_count.saturating_add(1);
if !startup.host_menu_bar_hidden {
let menu_color_bytes = ppc_menu_color_table_bytes(memory, handles);
let _ = ppc_draw_menu_bar_with_colors(
memory,
gworlds,
menu_list_handle,
screen_clut,
MenuColorTable::new(&menu_color_bytes),
);
}
true
}
#[cfg(test)]
fn ppc_draw_menu_bar(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
menu_list_handle: u32,
screen_clut: &[[u16; 3]; 256],
) -> bool {
ppc_draw_menu_bar_with_colors(
memory,
gworlds,
menu_list_handle,
screen_clut,
MenuColorTable::new(&[]),
)
}
fn ppc_draw_system_menu_mark(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
screen_clut: &[[u16; 3]; 256],
left: i16,
) {
let palette = crate::ui_art::RETRO_COMPUTER_MENU_MARK_PALETTE.map(|rgb| {
ppc_physical_screen_color_pixel(
front_buffer,
PpcRgbColor {
red: rgb[0],
green: rgb[1],
blue: rgb[2],
},
screen_clut,
)
.unwrap_or(0)
});
let menu_bar_height = memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap_or(20) as i16;
let top = ppc_menu_bar_system_mark_top(menu_bar_height);
let menu_bar_bottom = menu_bar_height.saturating_sub(1).max(0);
for (dy, row) in crate::ui_art::RETRO_COMPUTER_MENU_MARK_PIXELS
.iter()
.enumerate()
{
for (dx, palette_index) in row.iter().copied().enumerate() {
if palette_index == 0 {
continue;
}
let y = top.saturating_add(dy as i16);
if y < 0 || y >= menu_bar_bottom {
continue;
}
let _ = ppc_quickdraw_write_raw_pixel(
memory,
front_buffer,
(i32::from(left) + dx as i32, i32::from(y)),
palette[usize::from(palette_index - 1)],
);
}
}
}
fn ppc_menu_items_from_memory(memory: &mut PpcSectionMem, menu_handle: u32) -> Option<MenuItems> {
let menu = memory.read_u32_be(menu_handle).filter(|ptr| *ptr != 0)?;
MenuItems::decode_with(|offset| {
let offset = u32::try_from(offset).ok()?;
memory.read_u8(menu.checked_add(offset)?)
})
}
fn ppc_menu_first_item(memory: &mut PpcSectionMem, menu_handle: u32) -> Option<u32> {
if menu_handle == 0 {
return None;
}
let menu = memory.read_u32_be(menu_handle)?;
if menu == 0 {
return None;
}
// Macintosh Toolbox Essentials (1992), pp. 3-132 and 3-141, together
// with the MENU layout in Inside Macintosh Volume I, p. I-345: the menu
// title is followed by Pascal-string items and four attribute bytes.
let title_len = u32::from(memory.read_u8(menu.checked_add(14)?)?);
menu.checked_add(15u32.checked_add(title_len)?)
}
fn ppc_menu_item(memory: &mut PpcSectionMem, menu_handle: u32, item: i16) -> Option<(u32, u8)> {
if item < 1 {
return None;
}
let mut item_addr = ppc_menu_first_item(memory, menu_handle)?;
for index in 1..=1024i16 {
let item_len = memory.read_u8(item_addr)?;
if item_len == 0 {
return None;
}
if index == item {
return Some((item_addr, item_len));
}
item_addr = item_addr.checked_add(5 + u32::from(item_len))?;
}
None
}
fn ppc_f64_to_fixed(value: f64) -> u32 {
(value * 65536.0)
.round()
.clamp(i32::MIN as f64, i32::MAX as f64) as i32 as u32
}
fn ppc_sys_environs(memory: &mut PpcSectionMem, rec_ptr: u32) -> i16 {
if rec_ptr < 0x100 || !ppc_memory_can_write_bytes(memory, rec_ptr, 16) {
return PPC_PARAM_ERR;
}
let _ = memory.write_u16_be(rec_ptr, 2);
let _ = memory.write_u16_be(rec_ptr + 2, REFERENCE_MACHINE_PROFILE.gestalt_machine_type);
let _ = memory.write_u16_be(rec_ptr + 4, REFERENCE_MACHINE_PROFILE.system_version_bcd);
let _ = memory.write_u16_be(
rec_ptr + 6,
REFERENCE_MACHINE_PROFILE.gestalt_processor_type as u16,
);
let _ = memory.write_u8(rec_ptr + 8, u8::from(REFERENCE_MACHINE_PROFILE.has_fpu()));
let _ = memory.write_u8(rec_ptr + 9, 1);
let _ = memory.write_u16_be(rec_ptr + 10, 0);
let _ = memory.write_u16_be(rec_ptr + 12, 0);
let _ = memory.write_u16_be(rec_ptr + 14, 0);
PPC_NO_ERR
}
#[cfg(test)]
fn ppc_raw_trap_table_entry(trap_word: u16, toolbox: bool) -> u32 {
let kind = if toolbox {
TrapTableKind::Toolbox
} else {
TrapTableKind::OperatingSystem
};
TrapManager::table_address(trap_word, kind)
}
fn ppc_logical_trap_address(
memory: &mut PpcSectionMem,
trap_word: u16,
toolbox: bool,
) -> Option<u32> {
let kind = if toolbox {
TrapTableKind::Toolbox
} else {
TrapTableKind::OperatingSystem
};
let protected_memory = memory.shared_view();
TrapManager::get_address_with_provenance(
trap_word,
kind,
|operation| match operation {
TrapManagerMemoryOp::ReadLong(address) => {
Some(TrapManagerMemoryResult::Long(memory.read_u32_be(address)?))
}
TrapManagerMemoryOp::WriteLong { .. }
| TrapManagerMemoryOp::WriteProtectedLong { .. } => None,
},
move |address| protected_memory.is_shared_readonly_range(address, 4),
)
}
fn ppc_set_logical_trap_address(
memory: &mut PpcSectionMem,
trap_word: u16,
toolbox: bool,
handler: u32,
) -> bool {
let kind = if toolbox {
TrapTableKind::Toolbox
} else {
TrapTableKind::OperatingSystem
};
let protected_memory = memory.shared_view();
let result = TrapManager::set_address_with_provenance(
trap_word,
kind,
handler,
|operation| match operation {
TrapManagerMemoryOp::ReadLong(address) => {
Some(TrapManagerMemoryResult::Long(memory.read_u32_be(address)?))
}
TrapManagerMemoryOp::WriteLong { address, value } => memory
.write_u32_be(address, value)
.map(|()| TrapManagerMemoryResult::Written),
TrapManagerMemoryOp::WriteProtectedLong { address, value } => memory
.write_shared_system_u32_be(address, value)
.map(|()| TrapManagerMemoryResult::Written),
},
move |address| protected_memory.is_shared_readonly_range(address, 4),
);
if matches!(result, Err(TrapManagerSetError::InvalidComeFromHead)) {
// NSetTrapAddress raises system error 12 for this malformed splice.
// Inside Macintosh: Operating System Utilities (1994), p. 8-30.
let _ = memory.write_u16_be(crate::memory::globals::addr::DS_ERR_CODE, 12);
}
result.is_ok()
}
pub(super) fn ppc_write_rect(
memory: &mut PpcSectionMem,
rect_ptr: u32,
top: i16,
left: i16,
bottom: i16,
right: i16,
) -> Option<()> {
memory.write_u16_be(rect_ptr, top as u16)?;
memory.write_u16_be(rect_ptr + 2, left as u16)?;
memory.write_u16_be(rect_ptr + 4, bottom as u16)?;
memory.write_u16_be(rect_ptr + 6, right as u16)?;
Some(())
}
pub(super) fn ppc_read_rect(memory: &mut PpcSectionMem, rect_ptr: u32) -> Option<(i16, i16, i16, i16)> {
let top = memory.read_u16_be(rect_ptr)? as i16;
let left = memory.read_u16_be(rect_ptr + 2)? as i16;
let bottom = memory.read_u16_be(rect_ptr + 4)? as i16;
let right = memory.read_u16_be(rect_ptr + 6)? as i16;
Some((top, left, bottom, right))
}
fn ppc_transform_port_point(
memory: &mut PpcSectionMem,
port: u32,
point_ptr: u32,
local_to_global: bool,
) -> Option<()> {
if port == 0 || point_ptr == 0 {
return None;
}
let pixmap_handle = memory.read_u32_be(port.checked_add(2)?)?;
let pixmap = memory.read_u32_be(pixmap_handle)?;
let (pixel_top, pixel_left, _, _) = ppc_read_rect(memory, pixmap.checked_add(6)?)?;
let v = memory.read_u16_be(point_ptr)? as i16;
let h = memory.read_u16_be(point_ptr.checked_add(2)?)? as i16;
let (v, h) = if local_to_global {
(v.wrapping_sub(pixel_top), h.wrapping_sub(pixel_left))
} else {
(v.wrapping_add(pixel_top), h.wrapping_add(pixel_left))
};
// Inside Macintosh: Imaging With QuickDraw (1994), Basic QuickDraw
// pp. 2-9–2-10 and 2-51–2-52: the boundary rectangle's upper-left
// coordinates are subtracted from a local point to convert it to global.
memory.write_u16_be(point_ptr, v as u16)?;
memory.write_u16_be(point_ptr + 2, h as u16)?;
Some(())
}
fn ppc_set_port_origin(memory: &mut PpcSectionMem, port: u32, h: i16, v: i16) -> Option<()> {
if port == 0 {
return None;
}
let pixmap_handle = memory.read_u32_be(port.checked_add(2)?)?;
let pixmap = memory.read_u32_be(pixmap_handle)?;
let (pixel_top, pixel_left, pixel_bottom, pixel_right) =
ppc_read_rect(memory, pixmap.checked_add(6)?)?;
let pixel_height = pixel_bottom.wrapping_sub(pixel_top);
let pixel_width = pixel_right.wrapping_sub(pixel_left);
ppc_write_rect(
memory,
pixmap + 6,
v,
h,
v.wrapping_add(pixel_height),
h.wrapping_add(pixel_width),
)?;
let (port_top, port_left, port_bottom, port_right) =
ppc_read_rect(memory, port.checked_add(16)?)?;
let port_height = port_bottom.wrapping_sub(port_top);
let port_width = port_right.wrapping_sub(port_left);
// Inside Macintosh: Imaging With QuickDraw (1994), Basic QuickDraw
// p. 2-45: SetOrigin redefines the local coordinates of the portRect
// without moving the underlying pixels or clipping region.
ppc_write_rect(
memory,
port + 16,
v,
h,
v.wrapping_add(port_height),
h.wrapping_add(port_width),
)
}
fn ppc_open_region_include_point(startup: &mut PpcToolboxStartupState, h: i16, v: i16) {
startup.open_region_bounds = Some(match startup.open_region_bounds {
Some((top, left, bottom, right)) => (top.min(v), left.min(h), bottom.max(v), right.max(h)),
None => (v, h, v, h),
});
}
fn ppc_open_picture_commands(
startup: &mut PpcToolboxStartupState,
current_gworld: u32,
) -> Option<&mut Vec<u8>> {
startup
.open_picture
.as_mut()
.filter(|(_, port, _, _)| *port == current_gworld)
.map(|(_, _, _, commands)| commands)
}
fn ppc_open_region_include_rows(
startup: &mut PpcToolboxStartupState,
rows_top: i16,
rows: Vec<Vec<i16>>,
) {
let Some(first) = rows.iter().position(|row| !row.is_empty()) else {
return;
};
let Some(last) = rows.iter().rposition(|row| !row.is_empty()) else {
return;
};
let shape_top = i32::from(rows_top) + first as i32;
let shape_bottom = i32::from(rows_top) + last as i32 + 1;
let (Ok(shape_top), Ok(shape_bottom)) = (i16::try_from(shape_top), i16::try_from(shape_bottom))
else {
return;
};
let shape_left = rows
.iter()
.filter_map(|row| row.first().copied())
.min()
.unwrap_or(0);
let shape_right = rows
.iter()
.filter_map(|row| row.last().copied())
.max()
.unwrap_or(0);
startup.open_region_bounds = Some(match startup.open_region_bounds {
Some((top, left, bottom, right)) => (
top.min(shape_top),
left.min(shape_left),
bottom.max(shape_bottom),
right.max(shape_right),
),
None => (shape_top, shape_left, shape_bottom, shape_right),
});
let (combined_top, combined_bottom) = startup
.open_region_rows
.as_ref()
.map(|(top, existing)| {
(
(*top).min(rows_top),
(i32::from(*top) + existing.len() as i32)
.max(i32::from(rows_top) + rows.len() as i32),
)
})
.unwrap_or((rows_top, i32::from(rows_top) + rows.len() as i32));
let Ok(combined_bottom) = i16::try_from(combined_bottom) else {
return;
};
let Ok(combined_height) = usize::try_from(i32::from(combined_bottom) - i32::from(combined_top))
else {
return;
};
let previous = startup.open_region_rows.take();
let mut combined = Vec::with_capacity(combined_height);
for row_offset in 0..combined_height {
let y = i32::from(combined_top) + row_offset as i32;
let existing_row = previous
.as_ref()
.and_then(|(top, existing)| {
usize::try_from(y - i32::from(*top))
.ok()
.and_then(|index| existing.get(index))
})
.map(Vec::as_slice)
.unwrap_or(&[]);
let new_row = usize::try_from(y - i32::from(rows_top))
.ok()
.and_then(|index| rows.get(index))
.map(Vec::as_slice)
.unwrap_or(&[]);
combined.push(ppc_region_combine_rows(
existing_row,
new_row,
PpcRegionBooleanOp::Xor,
));
}
startup.open_region_rows = Some((combined_top, combined));
}
fn ppc_open_region_include_rect(
startup: &mut PpcToolboxStartupState,
memory: &mut PpcSectionMem,
rect_ptr: u32,
) {
let Some((rect_top, rect_left, rect_bottom, rect_right)) = ppc_read_rect(memory, rect_ptr)
else {
return;
};
let Ok(height) = usize::try_from(i32::from(rect_bottom) - i32::from(rect_top)) else {
return;
};
ppc_open_region_include_rows(startup, rect_top, vec![vec![rect_left, rect_right]; height]);
}
fn ppc_open_region_include_region(
startup: &mut PpcToolboxStartupState,
memory: &mut PpcSectionMem,
region_handle: u32,
) {
// Inside Macintosh: Imaging With QuickDraw, pp. 3-87–3-89: while a
// region is open, drawing commands contribute to its collected outline.
let Some(storage) = ppc_region_storage(memory, region_handle) else {
return;
};
let Some((rect_top, _, rect_bottom, _)) = ppc_region_storage_bbox(&storage) else {
return;
};
let Some(rows) = ppc_region_rows_for_band(&storage, rect_top, rect_bottom) else {
return;
};
ppc_open_region_include_rows(startup, rect_top, rows);
}
fn ppc_open_region_include_polygon(
startup: &mut PpcToolboxStartupState,
memory: &mut PpcSectionMem,
polygon_handle: u32,
) {
// Inside Macintosh: Imaging With QuickDraw, p. 3-82: framing a polygon
// while a region is open adds the polygon outline to that region.
let Some(ptr) = memory.read_u32_be(polygon_handle) else {
return;
};
let Some((rect_top, rect_left, rect_bottom, rect_right)) = ppc_read_rect(memory, ptr + 2)
else {
return;
};
startup.open_region_bounds = Some(match startup.open_region_bounds {
Some((top, left, bottom, right)) => (
top.min(rect_top),
left.min(rect_left),
bottom.max(rect_bottom),
right.max(rect_right),
),
None => (rect_top, rect_left, rect_bottom, rect_right),
});
}
#[allow(clippy::too_many_arguments)]
fn ppc_open_rgn(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
current_gworld: u32,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
mut legacy_handle_states: Option<&mut Vec<PpcHandleStateRecord>>,
startup: &mut PpcToolboxStartupState,
) {
if startup.open_region_save_handle != 0 {
let _ = ppc_allocator_view_dispose_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
legacy_handle_states.as_deref_mut(),
startup.open_region_save_handle,
);
}
let save_handle = ppc_allocator_view_new_rgn(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
if save_handle == 0 {
startup.open_region_port = 0;
startup.open_region_save_handle = 0;
startup.open_region_bounds = None;
startup.open_region_rows = None;
return;
}
startup.open_region_port = current_gworld;
startup.open_region_save_handle = save_handle;
startup.open_region_bounds = None;
startup.open_region_rows = None;
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 3-88--3-89:
// OpenRgn installs temporary rgnSave state in the current port and calls
// HidePen so collected outlines are not also drawn to the screen.
if current_gworld != 0 {
let _ = memory.write_u32_be(
current_gworld.wrapping_add(PPC_CGRAF_PORT_RGN_SAVE_OFFSET),
save_handle,
);
if let Some(pn_vis) = memory
.read_u16_be(current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_VIS_OFFSET))
.map(|value| value as i16)
{
let _ = memory.write_u16_be(
current_gworld.wrapping_add(PPC_CGRAF_PORT_PN_VIS_OFFSET),
pn_vis.saturating_sub(1) as u16,
);
}
}
*last_mem_error = PPC_NO_ERR;
}
fn ppc_close_rgn(
mut allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
destination: u32,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
mut legacy_handle_states: Option<&mut Vec<PpcHandleStateRecord>>,
startup: &mut PpcToolboxStartupState,
) {
*last_mem_error = if let Some((top, rows)) = startup.open_region_rows.take() {
ppc_region_storage_from_rows(top, &rows).map_or(PPC_PARAM_ERR, |storage| {
ppc_write_region_storage(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
destination,
&storage,
)
})
} else {
match startup.open_region_bounds {
Some((top, left, bottom, right)) if bottom > top && right > left => {
if ppc_write_rgn_bbox(memory, destination, top, left, bottom, right).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
}
}
_ => {
if ppc_set_empty_rgn(memory, destination).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
}
}
}
};
let port = startup.open_region_port;
if port != 0 {
let _ = memory.write_u32_be(port.wrapping_add(PPC_CGRAF_PORT_RGN_SAVE_OFFSET), 0);
if let Some(pn_vis) = memory
.read_u16_be(port.wrapping_add(PPC_CGRAF_PORT_PN_VIS_OFFSET))
.map(|value| value as i16)
{
let _ = memory.write_u16_be(
port.wrapping_add(PPC_CGRAF_PORT_PN_VIS_OFFSET),
pn_vis.saturating_add(1) as u16,
);
}
}
if startup.open_region_save_handle != 0 {
let _ = ppc_allocator_view_dispose_handle(
allocator.as_deref_mut(),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
legacy_handle_states.as_deref_mut(),
startup.open_region_save_handle,
);
}
startup.open_region_port = 0;
startup.open_region_save_handle = 0;
startup.open_region_bounds = None;
startup.open_region_rows = None;
}
fn ppc_bitmap_to_region(
cpu: &PpcCpu,
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> i16 {
let region_handle = cpu.gpr[3];
let bitmap = cpu.gpr[4];
if ppc_rgn_ptr(memory, region_handle).is_none() || bitmap == 0 {
return PPC_PARAM_ERR;
}
let (Some(base_addr), Some(raw_row_bytes), Some(bounds)) = (
memory.read_u32_be(bitmap),
memory.read_u16_be(bitmap + 4),
ppc_read_rect(memory, bitmap + 6),
) else {
return PPC_PARAM_ERR;
};
let row_bytes = u32::from(raw_row_bytes & 0x3fff);
let pixel_size = if raw_row_bytes & 0x8000 != 0 {
memory.read_u16_be(bitmap + 32).unwrap_or(0)
} else {
1
};
if pixel_size != 1 {
return PPC_PIXMAP_TOO_DEEP_ERR;
}
let (top, left, bottom, right) = bounds;
if bottom <= top || right <= left || row_bytes == 0 {
return if ppc_set_empty_rgn(memory, region_handle).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
}
let mut rows = Vec::with_capacity((i32::from(bottom) - i32::from(top)) as usize);
for v in top..bottom {
let mut endpoints = Vec::new();
let mut in_run = false;
for h in left..right {
let inked = ppc_read_packed_bitmap_index(memory, base_addr, row_bytes, 1, bounds, v, h)
== Some(1);
if inked != in_run {
endpoints.push(h);
in_run = inked;
}
}
if in_run {
endpoints.push(right);
}
rows.push(endpoints);
}
let Some(storage) = ppc_region_storage_from_rows(top, &rows) else {
return PPC_RGN_TOO_BIG_ERR;
};
if storage.len() > usize::from(u16::MAX) {
return PPC_RGN_TOO_BIG_ERR;
}
let result = ppc_write_region_storage(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
region_handle,
&storage,
);
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] BitMapToRegion bitmap=${:08X} base=${:08X} row_bytes={} bounds=({}, {}, {}, {}) region=${:08X} size={} result={}",
bitmap,
base_addr,
row_bytes,
top,
left,
bottom,
right,
region_handle,
storage.len(),
result
);
}
result
}
#[cfg(test)]
fn ppc_new_rgn(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> u32 {
let handle = ppc_alloc_handle(memory, heap_cursor, heap_limit, handles, 10, true);
if handle == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return 0;
}
if ppc_set_empty_rgn(memory, handle).is_none() {
*last_mem_error = PPC_PARAM_ERR;
return 0;
}
*last_mem_error = PPC_NO_ERR;
handle
}
#[allow(clippy::too_many_arguments)]
fn ppc_process_new_rgn(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> u32 {
let handle = ppc_process_alloc_handle(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
10,
true,
);
if handle == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return 0;
}
if ppc_set_empty_rgn(memory, handle).is_none() {
*last_mem_error = PPC_PARAM_ERR;
return 0;
}
*last_mem_error = PPC_NO_ERR;
handle
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_allocator_view_new_rgn(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) -> u32 {
let handle = ppc_allocator_view_allocate_handle(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
10,
true,
);
if handle == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return 0;
}
if ppc_set_empty_rgn(memory, handle).is_none() {
*last_mem_error = PPC_PARAM_ERR;
return 0;
}
*last_mem_error = PPC_NO_ERR;
handle
}
fn ppc_clip_rect(
cpu: &PpcCpu,
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
current_gworld: u32,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
) {
// Inside Macintosh: Imaging With QuickDraw (1994), p. 2-42: ClipRect
// replaces the current port's clipping-region contents while retaining
// the region handle itself.
let Some((top, left, bottom, right)) = ppc_read_rect(memory, cpu.gpr[3]) else {
*last_mem_error = PPC_PARAM_ERR;
return;
};
let Some(clip_addr) = current_gworld.checked_add(PPC_CGRAF_PORT_CLIP_RGN_OFFSET) else {
*last_mem_error = PPC_PARAM_ERR;
return;
};
let mut clip_rgn = memory.read_u32_be(clip_addr).unwrap_or(0);
if ppc_rgn_ptr(memory, clip_rgn).is_none() {
clip_rgn = ppc_allocator_view_new_rgn(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
if clip_rgn == 0 || memory.write_u32_be(clip_addr, clip_rgn).is_none() {
*last_mem_error = PPC_PARAM_ERR;
return;
}
}
if ppc_write_rgn_bbox(memory, clip_rgn, top, left, bottom, right).is_none() {
*last_mem_error = PPC_PARAM_ERR;
return;
}
*last_mem_error = PPC_NO_ERR;
}
pub(super) fn ppc_rgn_ptr(memory: &mut PpcSectionMem, rgn_handle: u32) -> Option<u32> {
if rgn_handle == 0 {
return None;
}
let ptr = memory.read_u32_be(rgn_handle)?;
if ptr == 0 {
None
} else {
Some(ptr)
}
}
pub(super) fn ppc_write_rgn_bbox(
memory: &mut PpcSectionMem,
rgn_handle: u32,
top: i16,
left: i16,
bottom: i16,
right: i16,
) -> Option<()> {
let ptr = ppc_rgn_ptr(memory, rgn_handle)?;
memory.write_u16_be(ptr, 10)?;
ppc_write_rect(memory, ptr + 2, top, left, bottom, right)
}
pub(super) fn ppc_read_rgn_bbox(memory: &mut PpcSectionMem, rgn_handle: u32) -> Option<(i16, i16, i16, i16)> {
let ptr = ppc_rgn_ptr(memory, rgn_handle)?;
ppc_read_rect(memory, ptr + 2)
}
pub(super) fn ppc_set_empty_rgn(memory: &mut PpcSectionMem, rgn_handle: u32) -> Option<()> {
ppc_write_rgn_bbox(memory, rgn_handle, 0, 0, 0, 0)
}
pub(super) fn ppc_copy_rgn(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
src_rgn: u32,
dst_rgn: u32,
) -> i16 {
if src_rgn == dst_rgn {
return if ppc_rgn_ptr(memory, src_rgn).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
}
let Some(src_ptr) = ppc_rgn_ptr(memory, src_rgn) else {
return PPC_PARAM_ERR;
};
let Some(size) = memory.read_u16_be(src_ptr).map(u32::from) else {
return PPC_PARAM_ERR;
};
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 3-90–3-91:
// CopyRgn duplicates the complete mathematical region into an existing
// destination so later changes to either region remain independent.
if size < 10 || !ppc_memory_can_read_bytes(memory, src_ptr, size) {
return PPC_PARAM_ERR;
}
let bytes = (0..size)
.map(|offset| memory.read_u8(src_ptr + offset))
.collect::<Option<Vec<_>>>();
let Some(bytes) = bytes else {
return PPC_PARAM_ERR;
};
if !handles.iter().any(|record| record.handle == dst_rgn) {
let Some(dst_ptr) = ppc_rgn_ptr(memory, dst_rgn) else {
return PPC_PARAM_ERR;
};
let Some(dst_size) = memory.read_u16_be(dst_ptr).map(u32::from) else {
return PPC_PARAM_ERR;
};
if dst_size < size || !ppc_memory_can_write_bytes(memory, dst_ptr, size) {
return PPC_PARAM_ERR;
}
return if memory.write_bytes(dst_ptr, &bytes).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
}
let result = ppc_allocator_view_resize_handle(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
dst_rgn,
size,
);
if result != PPC_NO_ERR {
return result;
}
let Some(dst_ptr) = ppc_rgn_ptr(memory, dst_rgn) else {
return PPC_PARAM_ERR;
};
for (offset, byte) in bytes.into_iter().enumerate() {
if memory.write_u8(dst_ptr + offset as u32, byte).is_none() {
return PPC_PARAM_ERR;
}
}
PPC_NO_ERR
}
#[derive(Clone, Copy)]
pub(super) enum PpcRegionBooleanOp {
Intersection,
Union,
Difference,
Xor,
}
fn ppc_region_storage(memory: &mut PpcSectionMem, rgn_handle: u32) -> Option<Vec<u8>> {
let ptr = ppc_rgn_ptr(memory, rgn_handle)?;
let size = u32::from(memory.read_u16_be(ptr)?);
if size < 10 || !ppc_memory_can_read_bytes(memory, ptr, size) {
return None;
}
(0..size)
.map(|offset| memory.read_u8(ptr + offset))
.collect()
}
fn ppc_region_storage_bbox(storage: &[u8]) -> Option<(i16, i16, i16, i16)> {
if storage.len() < 10 {
return None;
}
let word = |offset: usize| i16::from_be_bytes([storage[offset], storage[offset + 1]]);
let bbox = (word(2), word(4), word(6), word(8));
(bbox.2 > bbox.0 && bbox.3 > bbox.1).then_some(bbox)
}
fn ppc_region_merge_endpoints(lhs: &[i16], rhs: &[i16]) -> Vec<i16> {
let mut merged = Vec::with_capacity(lhs.len() + rhs.len());
let mut lhs_index = 0usize;
let mut rhs_index = 0usize;
while lhs_index < lhs.len() || rhs_index < rhs.len() {
match (lhs.get(lhs_index), rhs.get(rhs_index)) {
(Some(&lhs_value), Some(&rhs_value)) if lhs_value < rhs_value => {
merged.push(lhs_value);
lhs_index += 1;
}
(Some(&lhs_value), Some(&rhs_value)) if rhs_value < lhs_value => {
merged.push(rhs_value);
rhs_index += 1;
}
(Some(_), Some(_)) => {
lhs_index += 1;
rhs_index += 1;
}
(Some(&lhs_value), None) => {
merged.push(lhs_value);
lhs_index += 1;
}
(None, Some(&rhs_value)) => {
merged.push(rhs_value);
rhs_index += 1;
}
(None, None) => break,
}
}
merged
}
fn ppc_region_rows_for_band(storage: &[u8], top: i16, bottom: i16) -> Option<Vec<Vec<i16>>> {
let height = (i32::from(bottom) - i32::from(top)).max(0) as usize;
let mut rows = vec![Vec::new(); height];
let Some((rgn_top, rgn_left, rgn_bottom, rgn_right)) = ppc_region_storage_bbox(storage) else {
return Some(rows);
};
let overlap_top = top.max(rgn_top);
let overlap_bottom = bottom.min(rgn_bottom);
if overlap_bottom <= overlap_top {
return Some(rows);
}
if storage.len() == 10 {
for y in overlap_top..overlap_bottom {
rows[(i32::from(y) - i32::from(top)) as usize] = vec![rgn_left, rgn_right];
}
return Some(rows);
}
const REGION_STOP: i16 = i16::MAX;
let mut cursor = 10usize;
let read_word = |storage: &[u8], cursor: &mut usize| {
let bytes = storage.get(*cursor..cursor.checked_add(2)?)?;
*cursor += 2;
Some(i16::from_be_bytes([bytes[0], bytes[1]]))
};
let mut next_change_y = read_word(storage, &mut cursor)?;
let mut active = Vec::new();
for y32 in i32::from(rgn_top)..i32::from(overlap_bottom) {
let y = y32 as i16;
while next_change_y != REGION_STOP && next_change_y <= y {
let mut delta = Vec::new();
loop {
let value = read_word(storage, &mut cursor)?;
if value == REGION_STOP {
break;
}
delta.push(value);
}
active = ppc_region_merge_endpoints(&active, &delta);
next_change_y = read_word(storage, &mut cursor)?;
}
if y >= overlap_top {
rows[(i32::from(y) - i32::from(top)) as usize] = active.clone();
}
}
Some(rows)
}
fn ppc_region_endpoints_to_intervals(endpoints: &[i16]) -> Vec<(i16, i16)> {
endpoints
.chunks_exact(2)
.filter_map(|pair| (pair[0] < pair[1]).then_some((pair[0], pair[1])))
.collect()
}
fn ppc_region_intervals_to_endpoints(mut intervals: Vec<(i16, i16)>) -> Vec<i16> {
intervals.sort_unstable();
let mut merged: Vec<(i16, i16)> = Vec::with_capacity(intervals.len());
for (start, end) in intervals {
if start >= end {
continue;
}
if let Some((_, last_end)) = merged.last_mut() {
if start <= *last_end {
*last_end = (*last_end).max(end);
continue;
}
}
merged.push((start, end));
}
merged
.into_iter()
.flat_map(|(start, end)| [start, end])
.collect()
}
fn ppc_region_intersect_rows(lhs: &[i16], rhs: &[i16]) -> Vec<i16> {
let lhs = ppc_region_endpoints_to_intervals(lhs);
let rhs = ppc_region_endpoints_to_intervals(rhs);
let mut out = Vec::new();
for &(lhs_start, lhs_end) in &lhs {
for &(rhs_start, rhs_end) in &rhs {
let start = lhs_start.max(rhs_start);
let end = lhs_end.min(rhs_end);
if start < end {
out.push((start, end));
}
}
}
ppc_region_intervals_to_endpoints(out)
}
fn ppc_region_union_rows(lhs: &[i16], rhs: &[i16]) -> Vec<i16> {
let mut intervals = ppc_region_endpoints_to_intervals(lhs);
intervals.extend(ppc_region_endpoints_to_intervals(rhs));
ppc_region_intervals_to_endpoints(intervals)
}
fn ppc_region_difference_rows(lhs: &[i16], rhs: &[i16]) -> Vec<i16> {
let lhs = ppc_region_endpoints_to_intervals(lhs);
let rhs = ppc_region_endpoints_to_intervals(rhs);
let mut out = Vec::new();
for (lhs_start, lhs_end) in lhs {
let mut start = lhs_start;
for &(rhs_start, rhs_end) in &rhs {
if rhs_end <= start {
continue;
}
if rhs_start >= lhs_end {
break;
}
if rhs_start > start {
out.push((start, rhs_start.min(lhs_end)));
}
start = start.max(rhs_end);
if start >= lhs_end {
break;
}
}
if start < lhs_end {
out.push((start, lhs_end));
}
}
ppc_region_intervals_to_endpoints(out)
}
fn ppc_region_combine_rows(lhs: &[i16], rhs: &[i16], operation: PpcRegionBooleanOp) -> Vec<i16> {
match operation {
PpcRegionBooleanOp::Intersection => ppc_region_intersect_rows(lhs, rhs),
PpcRegionBooleanOp::Union => ppc_region_union_rows(lhs, rhs),
PpcRegionBooleanOp::Difference => ppc_region_difference_rows(lhs, rhs),
PpcRegionBooleanOp::Xor => ppc_region_union_rows(
&ppc_region_difference_rows(lhs, rhs),
&ppc_region_difference_rows(rhs, lhs),
),
}
}
fn ppc_region_storage_from_rows(top: i16, rows: &[Vec<i16>]) -> Option<Vec<u8>> {
const REGION_STOP: i16 = i16::MAX;
let mut bbox: Option<(i16, i16, i16, i16)> = None;
for (row_index, row) in rows.iter().enumerate() {
if row.is_empty() {
continue;
}
let y = i32::from(top).checked_add(i32::try_from(row_index).ok()?)?;
let y = i16::try_from(y).ok()?;
let bottom = y.checked_add(1)?;
let left = row[0];
let right = *row.last()?;
bbox = Some(match bbox {
Some((current_top, current_left, current_bottom, current_right)) => (
current_top,
current_left.min(left),
current_bottom.max(bottom),
current_right.max(right),
),
None => (y, left, bottom, right),
});
}
let Some((bbox_top, left, bottom, right)) = bbox else {
return Some(vec![0, 10, 0, 0, 0, 0, 0, 0, 0, 0]);
};
let first = &rows[(i32::from(bbox_top) - i32::from(top)) as usize];
let rectangular = first == &[left, right]
&& (i32::from(bbox_top)..i32::from(bottom))
.all(|y| rows[(y - i32::from(top)) as usize] == *first);
let mut words = Vec::new();
if !rectangular {
let mut previous = Vec::new();
for y32 in i32::from(bbox_top)..=i32::from(bottom) {
let current = if y32 < i32::from(bottom) {
rows[(y32 - i32::from(top)) as usize].clone()
} else {
Vec::new()
};
let delta = ppc_region_merge_endpoints(&previous, ¤t);
if !delta.is_empty() {
words.push(y32 as i16);
words.extend(delta);
words.push(REGION_STOP);
}
previous = current;
}
words.push(REGION_STOP);
}
let size = 10usize.checked_add(words.len().checked_mul(2)?)?;
let size = u16::try_from(size).ok()?;
let mut storage = Vec::with_capacity(usize::from(size));
storage.extend_from_slice(&size.to_be_bytes());
for value in [bbox_top, left, bottom, right] {
storage.extend_from_slice(&value.to_be_bytes());
}
for word in words {
storage.extend_from_slice(&word.to_be_bytes());
}
Some(storage)
}
fn ppc_write_region_storage(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
rgn_handle: u32,
storage: &[u8],
) -> i16 {
let result = ppc_allocator_view_resize_handle(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
rgn_handle,
u32::try_from(storage.len()).unwrap_or(u32::MAX),
);
if result != PPC_NO_ERR {
return result;
}
let Some(ptr) = ppc_rgn_ptr(memory, rgn_handle) else {
return PPC_PARAM_ERR;
};
for (offset, byte) in storage.iter().copied().enumerate() {
if memory.write_u8(ptr + offset as u32, byte).is_none() {
return PPC_PARAM_ERR;
}
}
PPC_NO_ERR
}
pub(super) fn ppc_region_boolean_op(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
src_a: u32,
src_b: u32,
dst: u32,
operation: PpcRegionBooleanOp,
) -> i16 {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 3-93–3-96:
// region Boolean operations preserve the complete mathematical shape,
// allow a destination to alias either source, and write into an existing
// destination handle.
let Some(storage_a) = ppc_region_storage(memory, src_a) else {
return PPC_PARAM_ERR;
};
let Some(storage_b) = ppc_region_storage(memory, src_b) else {
return PPC_PARAM_ERR;
};
let bbox_a = ppc_region_storage_bbox(&storage_a);
let bbox_b = ppc_region_storage_bbox(&storage_b);
let band = match operation {
PpcRegionBooleanOp::Intersection => match (bbox_a, bbox_b) {
(Some(a), Some(b)) if a.2.min(b.2) > a.0.max(b.0) => Some((a.0.max(b.0), a.2.min(b.2))),
_ => None,
},
PpcRegionBooleanOp::Difference => bbox_a.map(|a| (a.0, a.2)),
PpcRegionBooleanOp::Union | PpcRegionBooleanOp::Xor => match (bbox_a, bbox_b) {
(Some(a), Some(b)) => Some((a.0.min(b.0), a.2.max(b.2))),
(Some(a), None) => Some((a.0, a.2)),
(None, Some(b)) => Some((b.0, b.2)),
(None, None) => None,
},
};
let output = if let Some((top, bottom)) = band {
let Some(rows_a) = ppc_region_rows_for_band(&storage_a, top, bottom) else {
return PPC_PARAM_ERR;
};
let Some(rows_b) = ppc_region_rows_for_band(&storage_b, top, bottom) else {
return PPC_PARAM_ERR;
};
let rows = rows_a
.iter()
.zip(&rows_b)
.map(|(lhs, rhs)| ppc_region_combine_rows(lhs, rhs, operation))
.collect::<Vec<_>>();
let Some(output) = ppc_region_storage_from_rows(top, &rows) else {
return PPC_MEM_FULL_ERR;
};
output
} else {
vec![0, 10, 0, 0, 0, 0, 0, 0, 0, 0]
};
ppc_write_region_storage(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
dst,
&output,
)
}
fn ppc_set_rect_rgn(
memory: &mut PpcSectionMem,
rgn_handle: u32,
left: i16,
top: i16,
right: i16,
bottom: i16,
) -> Option<()> {
ppc_write_rgn_bbox(memory, rgn_handle, top, left, bottom, right)
}
pub(super) fn ppc_rect_rgn(memory: &mut PpcSectionMem, rgn_handle: u32, rect_ptr: u32) -> Option<()> {
let (top, left, bottom, right) = ppc_read_rect(memory, rect_ptr)?;
ppc_write_rgn_bbox(memory, rgn_handle, top, left, bottom, right)
}
pub(super) fn ppc_offset_rgn(memory: &mut PpcSectionMem, rgn_handle: u32, dh: i16, dv: i16) -> i16 {
let Some(ptr) = ppc_rgn_ptr(memory, rgn_handle) else {
return PPC_PARAM_ERR;
};
let Some(size) = memory.read_u16_be(ptr).map(u32::from) else {
return PPC_PARAM_ERR;
};
if size < 10 || !ppc_memory_can_write_bytes(memory, ptr, size) {
return PPC_PARAM_ERR;
}
let Some((top, left, bottom, right)) = ppc_read_rect(memory, ptr + 2) else {
return PPC_PARAM_ERR;
};
if bottom <= top || right <= left {
return PPC_NO_ERR;
}
if ppc_write_rect(
memory,
ptr + 2,
top.wrapping_add(dv),
left.wrapping_add(dh),
bottom.wrapping_add(dv),
right.wrapping_add(dh),
)
.is_none()
{
return PPC_PARAM_ERR;
}
if size == 10 {
return PPC_NO_ERR;
}
// Imaging With QuickDraw (1994), p. 3-93: the nonrectangular region
// payload alternates vertical change coordinates with horizontal boundary
// coordinates; $7FFF terminates each row and then the complete region.
let mut offset = 10u32;
while offset + 2 <= size {
let Some(y) = memory.read_u16_be(ptr + offset) else {
return PPC_PARAM_ERR;
};
if y == 0x7fff {
return PPC_NO_ERR;
}
if memory
.write_u16_be(ptr + offset, (y as i16).wrapping_add(dv) as u16)
.is_none()
{
return PPC_PARAM_ERR;
}
offset += 2;
loop {
if offset + 2 > size {
return PPC_PARAM_ERR;
}
let Some(x) = memory.read_u16_be(ptr + offset) else {
return PPC_PARAM_ERR;
};
if x == 0x7fff {
offset += 2;
break;
}
if memory
.write_u16_be(ptr + offset, (x as i16).wrapping_add(dh) as u16)
.is_none()
{
return PPC_PARAM_ERR;
}
offset += 2;
}
}
PPC_PARAM_ERR
}
fn ppc_empty_rgn(memory: &mut PpcSectionMem, rgn_handle: u32) -> bool {
let Some((top, left, bottom, right)) = ppc_read_rgn_bbox(memory, rgn_handle) else {
return true;
};
bottom <= top || right <= left
}
fn ppc_point_in_region(memory: &mut PpcSectionMem, rgn_handle: u32, v: i16, h: i16) -> bool {
let Some(storage) = ppc_region_storage(memory, rgn_handle) else {
return false;
};
ppc_point_in_region_storage(&storage, v, h)
}
fn ppc_point_in_region_storage(storage: &[u8], v: i16, h: i16) -> bool {
let Some((top, left, bottom, right)) = ppc_region_storage_bbox(&storage) else {
return false;
};
if v < top || v >= bottom || h < left || h >= right {
return false;
}
if storage.len() == 10 {
return true;
}
ppc_region_rows_for_band(&storage, v, v.saturating_add(1)).is_some_and(|rows| {
rows.first().is_some_and(|row| {
row.chunks_exact(2)
.any(|interval| h >= interval[0] && h < interval[1])
})
})
}
fn ppc_rect_in_region(memory: &mut PpcSectionMem, rect_ptr: u32, rgn_handle: u32) -> bool {
let Some((rect_top, rect_left, rect_bottom, rect_right)) = ppc_read_rect(memory, rect_ptr)
else {
return false;
};
let Some(storage) = ppc_region_storage(memory, rgn_handle) else {
return false;
};
let Some((rgn_top, rgn_left, rgn_bottom, rgn_right)) = ppc_region_storage_bbox(&storage) else {
return false;
};
let top = rect_top.max(rgn_top);
let bottom = rect_bottom.min(rgn_bottom);
if top >= bottom || rect_left.max(rgn_left) >= rect_right.min(rgn_right) {
return false;
}
ppc_region_rows_for_band(&storage, top, bottom).is_some_and(|rows| {
rows.iter().any(|row| {
row.chunks_exact(2)
.any(|interval| rect_left < interval[1] && rect_right > interval[0])
})
})
}
fn ppc_open_polygon(memory: &mut PpcSectionMem, current_gworld: u32) -> Option<u32> {
(current_gworld != 0)
.then(|| memory.read_u32_be(current_gworld.wrapping_add(100)))
.flatten()
.filter(|handle| *handle != 0)
}
fn ppc_open_poly(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
current_gworld: u32,
) -> u32 {
if current_gworld == 0 || ppc_open_polygon(memory, current_gworld).is_some() {
*last_mem_error = PPC_PARAM_ERR;
return 0;
}
let handle = ppc_process_alloc_handle(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
10,
true,
);
let Some(ptr) = memory.read_u32_be(handle).filter(|ptr| *ptr != 0) else {
*last_mem_error = PPC_MEM_FULL_ERR;
return 0;
};
if memory.write_u16_be(ptr, 10).is_none()
|| ppc_write_rect(memory, ptr + 2, 0, 0, 0, 0).is_none()
|| memory
.write_u32_be(current_gworld.wrapping_add(100), handle)
.is_none()
{
*last_mem_error = PPC_PARAM_ERR;
return 0;
}
// Imaging With QuickDraw (1994), pp. 3-77--3-81: OpenPoly allocates a
// PolyHandle, installs it in polySave, and records subsequent Move/Line
// vertices until ClosePoly clears polySave.
*last_mem_error = PPC_NO_ERR;
handle
}
fn ppc_record_polygon_point(
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
handle: u32,
h: i16,
v: i16,
) -> i16 {
let Some(ptr) = memory.read_u32_be(handle).filter(|ptr| *ptr != 0) else {
return PPC_PARAM_ERR;
};
let Some(size) = memory.read_u16_be(ptr).map(u32::from) else {
return PPC_PARAM_ERR;
};
if size < 10 || (size - 10) % 4 != 0 {
return PPC_PARAM_ERR;
}
if size >= 14
&& memory.read_u16_be(ptr + size - 4) == Some(v as u16)
&& memory.read_u16_be(ptr + size - 2) == Some(h as u16)
{
return PPC_NO_ERR;
}
let Some(new_size) = size.checked_add(4) else {
return PPC_MEM_FULL_ERR;
};
let result = process_memory_manager.set_native_handle_size(memory, handle, new_size);
ppc_apply_process_native_resource_handle(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
handle,
);
if result != PPC_NO_ERR {
return result;
}
let Some(ptr) = memory.read_u32_be(handle).filter(|ptr| *ptr != 0) else {
return PPC_PARAM_ERR;
};
if memory.write_u16_be(ptr + size, v as u16).is_none()
|| memory.write_u16_be(ptr + size + 2, h as u16).is_none()
|| memory.write_u16_be(ptr, new_size as u16).is_none()
{
return PPC_PARAM_ERR;
}
let bounds = if size == 10 {
(v, h, v.saturating_add(1), h.saturating_add(1))
} else {
let Some((top, left, bottom, right)) = ppc_read_rect(memory, ptr + 2) else {
return PPC_PARAM_ERR;
};
(
top.min(v),
left.min(h),
bottom.max(v.saturating_add(1)),
right.max(h.saturating_add(1)),
)
};
if ppc_write_rect(memory, ptr + 2, bounds.0, bounds.1, bounds.2, bounds.3).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_polygon_points(memory: &mut PpcSectionMem, handle: u32) -> Option<Vec<(i16, i16)>> {
let ptr = memory.read_u32_be(handle).filter(|ptr| *ptr != 0)?;
let size = u32::from(memory.read_u16_be(ptr)?);
if size < 10 || (size - 10) % 4 != 0 {
return None;
}
(10..size)
.step_by(4)
.map(|offset| {
Some((
memory.read_u16_be(ptr + offset + 2)? as i16,
memory.read_u16_be(ptr + offset)? as i16,
))
})
.collect()
}
fn ppc_paint_polygon(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
handle: u32,
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
let Some(points) = ppc_polygon_points(memory, handle).filter(|points| points.len() >= 3) else {
return false;
};
let Some(ptr) = memory.read_u32_be(handle) else {
return false;
};
let Some(bounds) = ppc_read_rect(memory, ptr + 2) else {
return false;
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, current_gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
let Some(color_pixel) =
ppc_quickdraw_surface_fore_pixel(memory, surface, color, explicit_index)
else {
return false;
};
let (top, left, bottom, right) = surface.local_rect(bounds);
let points = points
.into_iter()
.map(|(h, v)| surface.local_point((i32::from(h), i32::from(v))))
.collect::<Vec<_>>();
let mut wrote = false;
for y in top..bottom {
for x in left..right {
let mut crossings = 0u32;
for index in 0..points.len() {
let (x1, y1) = points[index];
let (x2, y2) = points[(index + 1) % points.len()];
let (x1, y1, x2, y2) = (f64::from(x1), f64::from(y1), f64::from(x2), f64::from(y2));
let (y_min, y_max, x_at_min, x_at_max) = if y1 < y2 {
(y1, y2, x1, x2)
} else {
(y2, y1, x2, x1)
};
if y1 != y2 && f64::from(y) >= y_min && f64::from(y) < y_max {
let intersection = x_at_min
+ (f64::from(y) - y_min) * (x_at_max - x_at_min) / (y_max - y_min);
if intersection <= f64::from(x) {
crossings += 1;
}
}
}
if crossings & 1 != 0 {
wrote |= ppc_quickdraw_write_raw_pixel(memory, front_buffer, (x, y), color_pixel);
}
}
}
wrote
}
fn ppc_frame_polygon(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
handle: u32,
color: PpcRgbColor,
explicit_index: Option<u8>,
) -> bool {
// Inside Macintosh: Imaging With QuickDraw, pp. 3-81–3-82: FramePoly
// plays back the polygon's line-drawing commands with the current pen.
let Some(points) = ppc_polygon_points(memory, handle).filter(|points| points.len() >= 2) else {
return false;
};
let mut wrote = false;
for i in 0..points.len() {
let from = points[i];
let to = points[(i + 1) % points.len()];
wrote |= ppc_line_to(
memory,
gworlds,
current_gworld,
from,
to,
color,
explicit_index,
);
}
wrote
}
fn ppc_offset_rect(memory: &mut PpcSectionMem, rect_ptr: u32, dh: i16, dv: i16) -> Option<()> {
let (top, left, bottom, right) = ppc_read_rect(memory, rect_ptr)?;
ppc_write_rect(
memory,
rect_ptr,
top.wrapping_add(dv),
left.wrapping_add(dh),
bottom.wrapping_add(dv),
right.wrapping_add(dh),
)
}
fn ppc_map_rect(memory: &mut PpcSectionMem, rect_ptr: u32, src_ptr: u32, dst_ptr: u32) {
// Inside Macintosh Volume I (1985), p. I-197: MapRect maps all four
// coordinates proportionally from srcRect's coordinate space into
// dstRect's coordinate space.
let (
Some((top, left, bottom, right)),
Some((src_top, src_left, src_bottom, src_right)),
Some((dst_top, dst_left, dst_bottom, dst_right)),
) = (
ppc_read_rect(memory, rect_ptr),
ppc_read_rect(memory, src_ptr),
ppc_read_rect(memory, dst_ptr),
)
else {
return;
};
let src_width = i64::from(src_right) - i64::from(src_left);
let src_height = i64::from(src_bottom) - i64::from(src_top);
let dst_width = i64::from(dst_right) - i64::from(dst_left);
let dst_height = i64::from(dst_bottom) - i64::from(dst_top);
let map_h = |value: i16| {
if src_width == 0 {
value
} else {
(i64::from(dst_left) + (i64::from(value) - i64::from(src_left)) * dst_width / src_width)
as i16
}
};
let map_v = |value: i16| {
if src_height == 0 {
value
} else {
(i64::from(dst_top) + (i64::from(value) - i64::from(src_top)) * dst_height / src_height)
as i16
}
};
let _ = ppc_write_rect(
memory,
rect_ptr,
map_v(top),
map_h(left),
map_v(bottom),
map_h(right),
);
}
pub(super) fn ppc_fs_make_fsspec(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
default_dir_id: u32,
) -> i16 {
let requested_vref = cpu.gpr[3] as u16 as i16;
let requested_dir_id = cpu.gpr[4];
let name_ptr = cpu.gpr[5];
let spec_ptr = cpu.gpr[6];
if spec_ptr == 0 {
return PPC_PARAM_ERR;
}
let effective_vref = ppc_resolve_volume_ref_num(requested_vref);
let effective_dir_id =
ppc_resolve_directory_id(requested_vref, requested_dir_id, default_dir_id);
let name_bytes = if name_ptr == 0 {
Vec::new()
} else {
let Some(bytes) = ppc_read_pstring_bytes(memory, name_ptr) else {
return PPC_PARAM_ERR;
};
bytes
};
let mut output_dir_id = effective_dir_id;
let mut output_name_bytes = name_bytes.clone();
let result = if !name_bytes.is_empty()
&& effective_dir_id > 1
&& ppc_directory_path_for_id(vfs_directories, effective_dir_id).is_none()
{
PPC_DIR_NF_ERR
} else if let Some(target_path) = ppc_resolved_fsspec_target_path(
vfs_directories,
vfs_files,
vfs_resource_files,
effective_dir_id,
&name_bytes,
) {
if !name_bytes.is_empty() {
output_dir_id = ppc_parent_dir_id_for_path(vfs_directories, &target_path);
output_name_bytes = ppc_vfs_basename_bytes(&target_path);
}
PPC_NO_ERR
} else {
PPC_FNF_ERR
};
if ppc_write_fsspec(
memory,
spec_ptr,
effective_vref,
output_dir_id,
&output_name_bytes,
)
.is_none()
{
return PPC_PARAM_ERR;
}
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] FSMakeFSSpec requested_vref={} requested_dir={} effective_vref={} effective_dir={} name=\"{}\" result={}",
requested_vref,
requested_dir_id,
effective_vref,
effective_dir_id,
decode_mac_roman(&name_bytes),
result
);
}
result
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct PpcCatalogEntry {
path: String,
name: Vec<u8>,
is_directory: bool,
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_pb_get_cat_info(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_volumes: &[PpcVfsVolumeRecord],
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
default_dir_id: u32,
) -> i16 {
let pb = cpu.gpr[3];
if pb == 0 {
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, pb + 16, 2)
|| !ppc_memory_can_write_bytes(memory, pb + 22, 2)
{
return PPC_PARAM_ERR;
}
let Some(name_ptr) = memory.read_u32_be(pb + 18) else {
return PPC_PARAM_ERR;
};
let Some(vref) = memory.read_u16_be(pb + 22).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(fdir_index) = memory.read_u16_be(pb + 28).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(requested_dir_id) = memory.read_u32_be(pb + 48) else {
return PPC_PARAM_ERR;
};
let effective_dir_id = ppc_resolve_directory_id(vref, requested_dir_id, default_dir_id);
// A negative index selects the directory by ID. ioNamePtr is output-only,
// including when its buffer does not yet contain a valid Pascal string.
// Inside Macintosh: Files (1992), pp. 2-191 and 3-36.
let name_bytes = if fdir_index < 0 || name_ptr == 0 {
Vec::new()
} else {
match ppc_read_pstring_bytes(memory, name_ptr) {
Some(bytes) => bytes,
None => return ppc_complete_pb(memory, pb, PPC_PARAM_ERR),
}
};
let requested_name = decode_mac_roman(&name_bytes);
let absolute_pathname = !requested_name.starts_with(':') && requested_name.contains(':');
let pathname_volume = (!requested_name.starts_with(':'))
.then(|| requested_name.split_once(':').map(|(volume, _)| volume))
.flatten()
.and_then(|name| {
vfs_volumes
.iter()
.find(|volume| volume.name.eq_ignore_ascii_case(name))
});
let resolved_vref =
pathname_volume.map_or_else(|| ppc_resolve_volume_ref_num(vref), |volume| volume.ref_num);
if !absolute_pathname
&& effective_dir_id > 1
&& ppc_directory_path_for_id(vfs_directories, effective_dir_id).is_none()
{
return ppc_complete_pb(memory, pb, PPC_DIR_NF_ERR);
}
let Some(entry) = ppc_catalog_entry_for_lookup(
vfs_directories,
vfs_files,
vfs_resource_files,
effective_dir_id,
&name_bytes,
fdir_index,
) else {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] PBGetCatInfo dir={} index={} name=\"{}\" -> {}",
effective_dir_id,
fdir_index,
decode_mac_roman(&name_bytes),
PPC_FNF_ERR
);
}
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
let filled = if entry.is_directory {
vfs_directories
.iter()
.find(|directory| directory.path.eq_ignore_ascii_case(&entry.path))
.and_then(|directory| {
ppc_fill_directory_catalog_info(
memory,
pb,
directory,
vfs_directories,
vfs_files,
vfs_resource_files,
)
})
} else {
ppc_fill_file_catalog_info(
memory,
pb,
vfs_directories,
vfs_files,
vfs_resource_files,
vfs_resources,
&entry.path,
)
};
if filled.is_none() {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
if name_ptr != 0 && !ppc_write_pstring_bytes(memory, name_ptr, &entry.name) {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
if memory.write_u16_be(pb + 22, resolved_vref as u16).is_none() {
return PPC_PARAM_ERR;
}
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] PBGetCatInfo dir={} index={} name=\"{}\" -> 0 out=\"{}\"",
effective_dir_id,
fdir_index,
decode_mac_roman(&name_bytes),
decode_mac_roman(&entry.name)
);
}
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
pub(super) fn ppc_pb_set_cat_info(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &mut [PpcVfsDirectory],
vfs_files: &mut [PpcVfsFileRecord],
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
default_dir_id: u32,
) -> i16 {
let pb = cpu.gpr[3];
if pb == 0 {
return PPC_PARAM_ERR;
}
let Some(name_ptr) = memory.read_u32_be(pb + 18) else {
return PPC_PARAM_ERR;
};
let Some(vref) = memory.read_u16_be(pb + 22).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(fdir_index) = memory.read_u16_be(pb + 28).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(requested_dir_id) = memory.read_u32_be(pb + 48) else {
return PPC_PARAM_ERR;
};
let effective_dir_id = ppc_resolve_directory_id(vref, requested_dir_id, default_dir_id);
let name_bytes = if name_ptr == 0 {
Vec::new()
} else {
match ppc_read_pstring_bytes(memory, name_ptr) {
Some(bytes) => bytes,
None => return ppc_complete_pb(memory, pb, PPC_PARAM_ERR),
}
};
if effective_dir_id > 1
&& ppc_directory_path_for_id(vfs_directories, effective_dir_id).is_none()
{
return ppc_complete_pb(memory, pb, PPC_DIR_NF_ERR);
}
let Some((file_type, creator, finder_flags)) = ppc_read_finfo(memory, pb + 32) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(entry) = ppc_catalog_entry_for_lookup(
vfs_directories,
vfs_files,
vfs_resource_files,
effective_dir_id,
&name_bytes,
fdir_index,
) else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
if entry.is_directory {
let Some(directory) = vfs_directories
.iter_mut()
.find(|directory| directory.path.eq_ignore_ascii_case(&entry.path))
else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
directory.file_type = file_type;
directory.creator = creator;
directory.finder_flags = finder_flags;
directory.dirty = true;
} else {
let mut found = false;
for file in vfs_files
.iter_mut()
.filter(|record| record.path.eq_ignore_ascii_case(&entry.path))
{
file.file_type = file_type;
file.creator = creator;
file.finder_flags = finder_flags;
file.dirty = true;
found = true;
}
for file in vfs_resource_files
.iter_mut()
.filter(|record| record.path.eq_ignore_ascii_case(&entry.path))
{
file.file_type = file_type;
file.creator = creator;
file.finder_flags = finder_flags;
file.dirty = true;
found = true;
}
if !found {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
}
}
let resolved_vref = ppc_resolve_volume_ref_num(vref);
if memory.write_u16_be(pb + 22, resolved_vref as u16).is_none() {
return PPC_PARAM_ERR;
}
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
pub(super) fn ppc_pb_get_finfo(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
default_dir_id: u32,
hfs: bool,
) -> i16 {
let pb = cpu.gpr[3];
if pb == 0 {
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, pb + 16, 2)
|| !ppc_memory_can_write_bytes(memory, pb + 22, 2)
{
return PPC_PARAM_ERR;
}
let Some(name_ptr) = memory.read_u32_be(pb + 18) else {
return PPC_PARAM_ERR;
};
let Some(vref) = memory.read_u16_be(pb + 22).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(fdir_index) = memory.read_u16_be(pb + 28).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let requested_dir_id = if hfs {
let Some(dir_id) = memory.read_u32_be(pb + 48) else {
return PPC_PARAM_ERR;
};
dir_id
} else {
0
};
let resolved_vref = ppc_resolve_volume_ref_num(vref);
let effective_dir_id = ppc_resolve_directory_id(vref, requested_dir_id, default_dir_id);
let name_bytes = if name_ptr == 0 {
Vec::new()
} else {
match ppc_read_pstring_bytes(memory, name_ptr) {
Some(bytes) => bytes,
None => return ppc_complete_pb(memory, pb, PPC_PARAM_ERR),
}
};
if effective_dir_id > 1
&& ppc_directory_path_for_id(vfs_directories, effective_dir_id).is_none()
{
return ppc_complete_pb(memory, pb, PPC_DIR_NF_ERR);
}
let Some(path) = ppc_pb_finfo_path_for_lookup(
vfs_directories,
vfs_files,
vfs_resource_files,
effective_dir_id,
&name_bytes,
fdir_index,
) else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
if ppc_fill_file_finfo_pb(
memory,
pb,
vfs_directories,
vfs_files,
vfs_resource_files,
vfs_resources,
&path,
hfs,
)
.is_none()
{
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
if name_ptr != 0 && !ppc_write_pstring_bytes(memory, name_ptr, &ppc_vfs_basename_bytes(&path)) {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
if memory.write_u16_be(pb + 22, resolved_vref as u16).is_none() {
return PPC_PARAM_ERR;
}
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
pub(super) fn ppc_pb_set_finfo(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut [PpcVfsFileRecord],
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
default_dir_id: u32,
hfs: bool,
) -> i16 {
let pb = cpu.gpr[3];
if pb == 0 {
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, pb + 16, 2)
|| !ppc_memory_can_write_bytes(memory, pb + 22, 2)
{
return PPC_PARAM_ERR;
}
let Some(name_ptr) = memory.read_u32_be(pb + 18) else {
return PPC_PARAM_ERR;
};
let Some(vref) = memory.read_u16_be(pb + 22).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(fdir_index) = memory.read_u16_be(pb + 28).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let requested_dir_id = if hfs {
let Some(dir_id) = memory.read_u32_be(pb + 48) else {
return PPC_PARAM_ERR;
};
dir_id
} else {
0
};
let resolved_vref = ppc_resolve_volume_ref_num(vref);
let effective_dir_id = ppc_resolve_directory_id(vref, requested_dir_id, default_dir_id);
let name_bytes = if name_ptr == 0 {
Vec::new()
} else {
match ppc_read_pstring_bytes(memory, name_ptr) {
Some(bytes) => bytes,
None => return ppc_complete_pb(memory, pb, PPC_PARAM_ERR),
}
};
if effective_dir_id > 1
&& ppc_directory_path_for_id(vfs_directories, effective_dir_id).is_none()
{
return ppc_complete_pb(memory, pb, PPC_DIR_NF_ERR);
}
let Some((file_type, creator, finder_flags)) = ppc_read_finfo(memory, pb + 32) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(path) = ppc_pb_finfo_path_for_lookup(
vfs_directories,
vfs_files,
vfs_resource_files,
effective_dir_id,
&name_bytes,
fdir_index,
) else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
if !ppc_set_finfo_for_path(
vfs_files,
vfs_resource_files,
&path,
file_type,
creator,
finder_flags,
) {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
}
if memory.write_u16_be(pb + 22, resolved_vref as u16).is_none() {
return PPC_PARAM_ERR;
}
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
fn ppc_pb_finfo_path_for_lookup(
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
dir_id: u32,
name_bytes: &[u8],
fdir_index: i16,
) -> Option<String> {
if fdir_index > 0 {
let entry = ppc_catalog_child_by_index(
vfs_directories,
vfs_files,
vfs_resource_files,
dir_id,
fdir_index as usize,
)?;
return (!entry.is_directory).then_some(entry.path);
}
if name_bytes.is_empty() {
return None;
}
let normalized_name = ppc_normalize_vfs_path(&decode_mac_roman(name_bytes));
if normalized_name.is_empty() {
return None;
}
if let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, dir_id) {
let candidate = ppc_join_vfs_path(parent_path, &normalized_name);
if let Some(path) = ppc_vfs_file_or_resource_path(vfs_files, vfs_resource_files, &candidate)
{
return Some(path);
}
}
if normalized_name.contains('/') {
if let Some(path) =
ppc_vfs_file_or_resource_path(vfs_files, vfs_resource_files, &normalized_name)
{
return Some(path);
}
}
ppc_vfs_file_or_resource_path_by_basename(vfs_files, vfs_resource_files, &normalized_name)
}
fn ppc_vfs_file_or_resource_path(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
path: &str,
) -> Option<String> {
vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(path))
.map(|file| file.path.clone())
.or_else(|| {
vfs_resource_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(path))
.map(|file| file.path.clone())
})
}
fn ppc_vfs_file_or_resource_path_by_basename(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
name: &str,
) -> Option<String> {
let basename = name.rsplit('/').next().unwrap_or(name);
let mut data_paths = vfs_files.iter().map(|file| &file.path).collect::<Vec<_>>();
data_paths.sort_by_key(|path| path.to_ascii_lowercase());
if let Some(path) = data_paths
.into_iter()
.find(|path| ppc_vfs_basename(path).eq_ignore_ascii_case(basename))
{
return Some(path.clone());
}
let mut resource_paths = vfs_resource_files
.iter()
.map(|file| &file.path)
.collect::<Vec<_>>();
resource_paths.sort_by_key(|path| path.to_ascii_lowercase());
resource_paths
.into_iter()
.find(|path| ppc_vfs_basename(path).eq_ignore_ascii_case(basename))
.cloned()
}
fn ppc_vfs_basename(path: &str) -> &str {
path.rsplit('/')
.next()
.filter(|name| !name.is_empty())
.unwrap_or(path)
}
fn ppc_fill_file_finfo_pb(
memory: &mut PpcSectionMem,
pb: u32,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
path: &str,
include_parent_dir_id: bool,
) -> Option<()> {
let data_len = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(path))
.map_or(0, |file| u32::try_from(file.data.len()).unwrap_or(u32::MAX));
let resource_len = ppc_resource_fork_len_for_path(vfs_resource_files, vfs_resources, path);
let (file_type, creator, finder_flags) =
ppc_finder_info_for_path(vfs_files, vfs_resource_files, path);
memory.write_u8(pb + 30, 0)?;
memory.write_u8(pb + 31, 0)?;
ppc_write_finfo(memory, pb + 32, file_type, creator, finder_flags)?;
memory.write_u32_be(pb + 48, ppc_synthetic_file_id(path))?;
memory.write_u32_be(pb + 54, data_len)?;
memory.write_u32_be(pb + 58, data_len)?;
memory.write_u32_be(pb + 64, resource_len)?;
memory.write_u32_be(pb + 68, resource_len)?;
memory.write_u32_be(pb + 72, 0)?;
memory.write_u32_be(pb + 76, 0)?;
if include_parent_dir_id {
memory.write_u32_be(pb + 100, ppc_parent_dir_id_for_path(vfs_directories, path))?;
}
Some(())
}
fn ppc_set_finfo_for_path(
vfs_files: &mut [PpcVfsFileRecord],
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
path: &str,
file_type: u32,
creator: u32,
finder_flags: u16,
) -> bool {
let mut found = false;
for file in vfs_files
.iter_mut()
.filter(|record| record.path.eq_ignore_ascii_case(path))
{
file.file_type = file_type;
file.creator = creator;
file.finder_flags = finder_flags;
file.dirty = true;
found = true;
}
for file in vfs_resource_files
.iter_mut()
.filter(|record| record.path.eq_ignore_ascii_case(path))
{
file.file_type = file_type;
file.creator = creator;
file.finder_flags = finder_flags;
file.dirty = true;
found = true;
}
found
}
pub(super) fn ppc_pbh_get_v_info(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_volumes: &[PpcVfsVolumeRecord],
) -> i16 {
let pb = cpu.gpr[3];
if pb == 0 || !ppc_memory_can_write_bytes(memory, pb, 122) {
return PPC_PARAM_ERR;
}
let Some(name_ptr) = memory.read_u32_be(pb + 18) else {
return PPC_PARAM_ERR;
};
let Some(vref_num) = memory.read_u16_be(pb + 22).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(volume_index) = memory.read_u16_be(pb + 28).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let requested_name = if name_ptr == 0 {
String::new()
} else {
ppc_read_pstring_bytes(memory, name_ptr)
.map(|name| decode_mac_roman(&name))
.unwrap_or_default()
};
let relative_pathname = requested_name.starts_with(':');
let absolute_pathname = !relative_pathname && requested_name.contains(':');
// Inside Macintosh: Files (1992), pp. 2-144--2-146: a positive
// ioVolIndex enumerates the VCB queue, zero selects by name or reference,
// and a negative index uses the standard name/reference search order.
let boot_volume = || PpcVfsVolumeRecord {
ref_num: PPC_BOOT_VOLUME_REF_NUM,
name: crate::trap::TrapDispatcher::boot_volume_name().to_string(),
root_dir_id: PPC_ROOT_DIR_ID,
attributes: 0,
file_count: 0,
allocation_block_count: u16::MAX,
allocation_block_size: 4096,
clump_size: 4096,
free_blocks: 0x8000,
bitmap_start: 3,
allocation_pointer: 4,
allocation_start: 3,
next_catalog_id: 1024,
created_date: 0,
modified_date: 0,
};
let volume_by_name = |name: &str| {
let volume_name = name.split(':').next().unwrap_or(name);
if volume_name.eq_ignore_ascii_case(crate::trap::TrapDispatcher::boot_volume_name()) {
Some(boot_volume())
} else {
vfs_volumes
.iter()
.find(|volume| volume.name.eq_ignore_ascii_case(volume_name))
.cloned()
}
};
let volume_by_ref = |requested_ref: i16| {
if requested_ref == PPC_BOOT_VOLUME_REF_NUM {
Some(boot_volume())
} else {
vfs_volumes
.iter()
.find(|volume| volume.ref_num == requested_ref)
.cloned()
}
};
let selected = if volume_index == 0 {
if vref_num != 0 {
volume_by_ref(vref_num)
} else if relative_pathname {
Some(boot_volume())
} else if !requested_name.is_empty() {
volume_by_name(&requested_name)
} else {
Some(boot_volume())
}
} else if volume_index > 0 {
if volume_index == 1 {
Some(boot_volume())
} else {
vfs_volumes.get((volume_index - 2) as usize).cloned()
}
} else if absolute_pathname {
volume_by_name(&requested_name)
} else if vref_num != 0 {
volume_by_ref(vref_num)
} else if relative_pathname {
Some(boot_volume())
} else if !requested_name.is_empty() {
volume_by_name(&requested_name)
} else {
Some(boot_volume())
};
let Some(volume) = selected else {
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] PBHGetVInfo index={volume_index} vref={vref_num} name={requested_name:?} -> nsvErr"
);
}
return ppc_complete_pb(memory, pb, PPC_NSV_ERR);
};
let volume_name = encode_mac_roman_lossy(&volume.name);
if name_ptr != 0 && !ppc_optional_pstring_output_can_write(memory, name_ptr, &volume_name) {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
if name_ptr != 0 {
let _ = ppc_write_pstring_bytes(memory, name_ptr, &volume_name);
}
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] PBHGetVInfo index={volume_index} vref={vref_num} name={requested_name:?} -> {:?} ({})",
volume.name, volume.ref_num
);
}
// Inside Macintosh: Files (1992), p. 2-238: HVolumeParam layout.
let writes = [
memory.write_u16_be(pb + 22, volume.ref_num as u16),
memory.write_u32_be(pb + 30, volume.created_date),
memory.write_u32_be(pb + 34, volume.modified_date),
memory.write_u16_be(pb + 38, volume.attributes),
memory.write_u16_be(pb + 40, volume.file_count),
memory.write_u16_be(pb + 42, volume.bitmap_start),
memory.write_u16_be(pb + 44, volume.allocation_pointer),
memory.write_u16_be(pb + 46, volume.allocation_block_count),
memory.write_u32_be(pb + 48, volume.allocation_block_size),
memory.write_u32_be(pb + 52, volume.clump_size),
memory.write_u16_be(pb + 56, volume.allocation_start),
memory.write_u32_be(pb + 58, volume.next_catalog_id),
memory.write_u16_be(pb + 62, volume.free_blocks),
memory.write_u16_be(pb + 64, 0x4244),
memory.write_u16_be(pb + 66, 1),
memory.write_u16_be(pb + 68, (-33i16) as u16),
memory.write_u16_be(pb + 70, 0),
memory.write_u32_be(pb + 72, 0),
memory.write_u16_be(pb + 76, 0),
memory.write_u32_be(pb + 78, 0),
memory.write_u32_be(pb + 82, 0),
memory.write_u32_be(pb + 86, 0),
memory.write_u32_be(pb + 90, PPC_SYSTEM_FOLDER_DIR_ID),
];
if writes.iter().any(Option::is_none) {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
pub(super) fn ppc_complete_pb(memory: &mut PpcSectionMem, pb: u32, err: i16) -> i16 {
if memory.write_u16_be(pb + 16, err as u16).is_none() {
PPC_PARAM_ERR
} else {
err
}
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_pb_get_fcb_info(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
files: &[PpcFileRecord],
resource_files: &[PpcResourceFileRecord],
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
launched_app_path: Option<&str>,
) -> i16 {
// Inside Macintosh: Files (1992), pp. 2-237--2-238: FCBPBRec selects an
// open fork by ioRefNum when ioFCBIndx is zero, or enumerates open FCBs
// when ioFCBIndx is positive.
let pb = cpu.gpr[3];
if pb == 0 || !ppc_memory_can_write_bytes(memory, pb, 62) {
return PPC_PARAM_ERR;
}
let Some(name_ptr) = memory.read_u32_be(pb + 18) else {
return PPC_PARAM_ERR;
};
let Some(vref) = memory.read_u16_be(pb + 22).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(requested_ref_num) = memory.read_u16_be(pb + 24).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(fcb_index) = memory.read_u16_be(pb + 28).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
if fcb_index < 0 || (name_ptr != 0 && !ppc_memory_can_write_bytes(memory, name_ptr, 32)) {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
// Inside Macintosh: Files (1992), pp. 2-218--2-219: ioVRefNum limits
// indexed FCB enumeration, but ioRefNum alone selects the open file when
// ioFCBIndx is zero. Real applications consequently leave ioVRefNum
// uninitialized for the latter form.
if fcb_index > 0 && !matches!(vref, 0 | PPC_BOOT_VOLUME_REF_NUM) {
return ppc_complete_pb(memory, pb, PPC_NSV_ERR);
}
let selected = if fcb_index == 0 {
if requested_ref_num == 0 {
launched_app_path.map(|path| (0, path.to_string(), true, 0))
} else if let Some(file) = files.iter().find(|file| file.ref_num == requested_ref_num) {
Some((file.ref_num, file.path.clone(), false, file.position))
} else {
resource_files
.iter()
.find(|file| file.ref_num == requested_ref_num)
.map(|file| (file.ref_num, file.path.clone(), true, 0))
}
} else {
let mut open_forks = Vec::with_capacity(
files.len() + resource_files.len() + usize::from(launched_app_path.is_some()),
);
if let Some(path) = launched_app_path {
open_forks.push((0, path.to_string(), true, 0));
}
open_forks.extend(
files
.iter()
.map(|file| (file.ref_num, file.path.clone(), false, file.position)),
);
open_forks.extend(
resource_files
.iter()
.map(|file| (file.ref_num, file.path.clone(), true, 0)),
);
open_forks.into_iter().nth(fcb_index as usize - 1)
};
let Some((ref_num, path, is_resource_fork, position)) = selected else {
return ppc_complete_pb(memory, pb, PPC_FN_OPN_ERR);
};
let logical_eof = if is_resource_fork {
ppc_resource_fork_len_for_path(vfs_resource_files, vfs_resources, &path)
} else {
vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(&path))
.map(|file| u32::try_from(file.data.len()).unwrap_or(u32::MAX))
.unwrap_or(0)
};
let mut name = ppc_vfs_basename_bytes(&path);
name.truncate(31);
let flags = if is_resource_fork { 0x0200 } else { 0x0100 };
let writes = [
memory.write_u16_be(pb + 22, PPC_BOOT_VOLUME_REF_NUM as u16),
memory.write_u16_be(pb + 24, ref_num as u16),
memory.write_u16_be(pb + 30, 0),
memory.write_u32_be(pb + 32, ppc_synthetic_file_id(&path)),
memory.write_u16_be(pb + 36, flags),
memory.write_u16_be(pb + 38, 0),
memory.write_u32_be(pb + 40, logical_eof),
memory.write_u32_be(pb + 44, logical_eof),
memory.write_u32_be(pb + 48, position.min(logical_eof)),
memory.write_u16_be(pb + 52, PPC_BOOT_VOLUME_REF_NUM as u16),
memory.write_u32_be(pb + 54, 0),
memory.write_u32_be(pb + 58, ppc_parent_dir_id_for_path(vfs_directories, &path)),
];
if writes.iter().any(Option::is_none)
|| (name_ptr != 0 && !ppc_write_pstring_bytes(memory, name_ptr, &name))
{
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] PBGetFCBInfo ref={} index={} -> ref={} path=\"{}\" resource={} eof={} position={}",
requested_ref_num, fcb_index, ref_num, path, is_resource_fork, logical_eof, position
);
}
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
fn ppc_catalog_entry_for_lookup(
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
dir_id: u32,
name_bytes: &[u8],
fdir_index: i16,
) -> Option<PpcCatalogEntry> {
if fdir_index > 0 {
return ppc_catalog_child_by_index(
vfs_directories,
vfs_files,
vfs_resource_files,
dir_id,
fdir_index as usize,
);
}
if fdir_index < 0 {
let directory = vfs_directories
.iter()
.find(|directory| directory.dir_id == dir_id)?;
return Some(PpcCatalogEntry {
path: directory.path.clone(),
name: ppc_vfs_basename_bytes(&directory.path),
is_directory: true,
});
}
if name_bytes.is_empty() {
let directory = vfs_directories
.iter()
.find(|directory| directory.dir_id == dir_id)?;
return Some(PpcCatalogEntry {
path: directory.path.clone(),
name: ppc_vfs_basename_bytes(&directory.path),
is_directory: true,
});
}
let decoded_name = decode_mac_roman(name_bytes);
let normalized_name = ppc_normalize_vfs_path(&decoded_name);
if normalized_name.is_empty() {
return None;
}
// Inside Macintosh: Files (1992), pp. 2-6--2-7: a pathname beginning
// with a volume name is absolute, while a leading colon is relative.
let absolute = !decoded_name.starts_with(':') && decoded_name.contains(':');
let path = if absolute {
normalized_name
} else {
let parent_path = ppc_directory_path_for_id(vfs_directories, dir_id)?;
ppc_join_vfs_path(parent_path, &normalized_name)
};
if ppc_directory_id_for_path(vfs_directories, &path).is_some() {
return Some(PpcCatalogEntry {
name: ppc_vfs_basename_bytes(&path),
path,
is_directory: true,
});
}
if ppc_vfs_file_index(vfs_files, &path).is_some()
|| ppc_vfs_resource_file_index(vfs_resource_files, &path).is_some()
{
return Some(PpcCatalogEntry {
name: ppc_vfs_basename_bytes(&path),
path,
is_directory: false,
});
}
None
}
fn ppc_catalog_child_by_index(
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
dir_id: u32,
fdir_index: usize,
) -> Option<PpcCatalogEntry> {
let parent_path = ppc_directory_path_for_id(vfs_directories, dir_id)?;
let mut entries = Vec::new();
for directory in vfs_directories
.iter()
.filter(|directory| directory.parent_dir_id == dir_id)
{
entries.push(PpcCatalogEntry {
path: directory.path.clone(),
name: ppc_vfs_basename_bytes(&directory.path),
is_directory: true,
});
}
for file in vfs_files {
if let Some(name) = ppc_child_name_for_parent(parent_path, &file.path) {
entries.push(PpcCatalogEntry {
path: file.path.clone(),
name: name.as_bytes().to_vec(),
is_directory: false,
});
}
}
for fork in vfs_resource_files {
if vfs_files
.iter()
.any(|file| file.path.eq_ignore_ascii_case(&fork.path))
{
continue;
}
if let Some(name) = ppc_child_name_for_parent(parent_path, &fork.path) {
entries.push(PpcCatalogEntry {
path: fork.path.clone(),
name: name.as_bytes().to_vec(),
is_directory: false,
});
}
}
entries.sort_by(|left, right| {
let left_key = (
left.name.to_ascii_lowercase(),
u8::from(!left.is_directory),
left.path.to_ascii_lowercase(),
);
let right_key = (
right.name.to_ascii_lowercase(),
u8::from(!right.is_directory),
right.path.to_ascii_lowercase(),
);
left_key.cmp(&right_key)
});
entries.into_iter().nth(fdir_index.saturating_sub(1))
}
fn ppc_child_name_for_parent<'a>(parent_path: &str, path: &'a str) -> Option<&'a str> {
if parent_path.is_empty() {
return if !path.is_empty() && !path.contains('/') {
Some(path)
} else {
None
};
}
let remainder = path.strip_prefix(parent_path)?.strip_prefix('/')?;
if remainder.is_empty() || remainder.contains('/') {
None
} else {
Some(remainder)
}
}
fn ppc_vfs_basename_bytes(path: &str) -> Vec<u8> {
let basename = path
.rsplit('/')
.next()
.filter(|name| !name.is_empty())
.unwrap_or(path);
encode_mac_roman_lossy(basename)
}
fn ppc_fill_file_catalog_info(
memory: &mut PpcSectionMem,
pb: u32,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
path: &str,
) -> Option<()> {
let data_len = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(path))
.map_or(0, |file| u32::try_from(file.data.len()).unwrap_or(u32::MAX));
let resource_len = ppc_resource_fork_len_for_path(vfs_resource_files, vfs_resources, path);
let (file_type, creator, finder_flags) =
ppc_finder_info_for_path(vfs_files, vfs_resource_files, path);
memory.write_u8(pb + 30, 0)?;
memory.write_u8(pb + 31, 0)?;
ppc_write_finfo(memory, pb + 32, file_type, creator, finder_flags)?;
memory.write_u32_be(pb + 48, ppc_synthetic_file_id(path))?;
memory.write_u32_be(pb + 54, data_len)?;
memory.write_u32_be(pb + 58, data_len)?;
memory.write_u32_be(pb + 64, resource_len)?;
memory.write_u32_be(pb + 68, resource_len)?;
memory.write_u32_be(pb + 72, 0)?;
memory.write_u32_be(pb + 76, 0)?;
memory.write_u32_be(pb + 100, ppc_parent_dir_id_for_path(vfs_directories, path))?;
Some(())
}
fn ppc_resource_fork_len_for_path(
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
path: &str,
) -> u32 {
let resource_file = vfs_resource_files
.iter()
.find(|fork| fork.path.eq_ignore_ascii_case(path));
if let Some(raw_data) = resource_file.and_then(|fork| fork.raw_data.as_ref()) {
return u32::try_from(raw_data.len()).unwrap_or(u32::MAX);
}
let entries = vfs_resources
.iter()
.filter(|resource| resource.path.eq_ignore_ascii_case(path))
.map(|resource| {
let (data, attrs) = match (&resource.raw_data, resource.raw_attrs) {
(Some(raw_data), Some(raw_attrs)) => (raw_data.clone(), raw_attrs),
_ => (resource.data.clone(), resource.attrs),
};
ResourceForkEntry {
res_type: resource.res_type.to_be_bytes(),
id: resource.res_id,
name: resource.name.clone(),
data,
attrs: (attrs & 0x00ff) as u8,
}
})
.collect::<Vec<_>>();
if !entries.is_empty() {
return serialize_resource_fork_with_attrs(
&entries,
resource_file.map_or(0, |fork| fork.map_attrs),
)
.map(|bytes| u32::try_from(bytes.len()).unwrap_or(u32::MAX))
.unwrap_or(0);
}
resource_file.map_or(0, |fork| fork.resource_len)
}
fn ppc_fill_directory_catalog_info(
memory: &mut PpcSectionMem,
pb: u32,
directory: &PpcVfsDirectory,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
) -> Option<()> {
memory.write_u8(pb + 30, 0x10)?;
memory.write_u8(pb + 31, 0)?;
ppc_write_finfo(
memory,
pb + 32,
directory.file_type,
directory.creator,
directory.finder_flags,
)?;
memory.write_u32_be(pb + 48, directory.dir_id)?;
let mut entry_count = 0usize;
while ppc_catalog_child_by_index(
vfs_directories,
vfs_files,
vfs_resource_files,
directory.dir_id,
entry_count.saturating_add(1),
)
.is_some()
{
entry_count = entry_count.saturating_add(1);
}
memory.write_u16_be(pb + 52, entry_count.min(u16::MAX as usize) as u16)?;
memory.write_u32_be(pb + 72, 0)?;
memory.write_u32_be(pb + 76, 0)?;
memory.write_u32_be(pb + 100, directory.parent_dir_id)?;
Some(())
}
fn ppc_finder_info_for_path(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
path: &str,
) -> (u32, u32, u16) {
if let Some(file) = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(path))
{
return (file.file_type, file.creator, file.finder_flags);
}
if let Some(fork) = vfs_resource_files
.iter()
.find(|fork| fork.path.eq_ignore_ascii_case(path))
{
return (fork.file_type, fork.creator, fork.finder_flags);
}
(0, 0, 0)
}
fn ppc_synthetic_file_id(path: &str) -> u32 {
let mut hash = 0x811c_9dc5u32;
for byte in path.bytes().map(|byte| byte.to_ascii_lowercase()) {
hash ^= u32::from(byte);
hash = hash.wrapping_mul(0x0100_0193);
}
0x1000_0000 | (hash & 0x0fff_ffff)
}
fn ppc_parent_dir_id_for_path(vfs_directories: &[PpcVfsDirectory], path: &str) -> u32 {
let parent_path = path.rsplit_once('/').map_or("", |(parent, _)| parent);
ppc_directory_id_for_path(vfs_directories, parent_path).unwrap_or(PPC_ROOT_DIR_ID)
}
pub(super) fn ppc_get_finfo(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
default_dir_id: u32,
) -> i16 {
let file_name_ptr = cpu.gpr[3];
let vref_num = cpu.gpr[4] as u16 as i16;
let finfo_ptr = cpu.gpr[5];
if !matches!(vref_num, 0 | PPC_BOOT_VOLUME_REF_NUM)
|| finfo_ptr == 0
|| !ppc_memory_can_write_bytes(memory, finfo_ptr, 16)
{
return PPC_PARAM_ERR;
}
let Some(name_bytes) = ppc_read_pstring_bytes(memory, file_name_ptr) else {
return PPC_PARAM_ERR;
};
let path = ppc_resolved_fsspec_target_path(
vfs_directories,
vfs_files,
vfs_resource_files,
default_dir_id,
&name_bytes,
)
.or_else(|| {
ppc_resolved_fsspec_target_path(
vfs_directories,
vfs_files,
vfs_resource_files,
PPC_ROOT_DIR_ID,
&name_bytes,
)
});
let Some(path) = path else {
let _ = ppc_write_finfo(memory, finfo_ptr, 0, 0, 0);
return PPC_FNF_ERR;
};
let (file_type, creator, finder_flags) =
ppc_finder_info_for_path(vfs_files, vfs_resource_files, &path);
// Inside Macintosh, Volume II (1985), File Manager p. II-95: GetFInfo
// takes a Str255 name and volume reference and returns the 16-byte FInfo.
if ppc_write_finfo(memory, finfo_ptr, file_type, creator, finder_flags).is_none() {
PPC_PARAM_ERR
} else {
PPC_NO_ERR
}
}
fn ppc_h_finfo_path(
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vref_num: i16,
requested_dir_id: u32,
file_name_ptr: u32,
default_dir_id: u32,
) -> Result<String, i16> {
if !matches!(vref_num, 0 | PPC_BOOT_VOLUME_REF_NUM) {
return Err(PPC_NSV_ERR);
}
let name_bytes = ppc_read_pstring_bytes(memory, file_name_ptr).ok_or(PPC_PARAM_ERR)?;
let name = ppc_normalize_vfs_path(&decode_mac_roman(&name_bytes));
if name.is_empty() || name.contains('/') {
return Err(PPC_BD_NAM_ERR);
}
let dir_id = ppc_resolve_directory_id(vref_num, requested_dir_id, default_dir_id);
let parent = ppc_directory_path_for_id(vfs_directories, dir_id).ok_or(PPC_DIR_NF_ERR)?;
let requested_path = ppc_join_vfs_path(parent, &name);
ppc_vfs_file_or_resource_path(vfs_files, vfs_resource_files, &requested_path).ok_or(PPC_FNF_ERR)
}
pub(super) fn ppc_h_get_finfo(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
default_dir_id: u32,
) -> i16 {
let finfo_ptr = cpu.gpr[6];
if finfo_ptr == 0 || !ppc_memory_can_write_bytes(memory, finfo_ptr, 16) {
return PPC_PARAM_ERR;
}
let path = match ppc_h_finfo_path(
memory,
vfs_directories,
vfs_files,
vfs_resource_files,
cpu.gpr[3] as u16 as i16,
cpu.gpr[4],
cpu.gpr[5],
default_dir_id,
) {
Ok(path) => path,
Err(err) => return err,
};
let (file_type, creator, finder_flags) =
ppc_finder_info_for_path(vfs_files, vfs_resource_files, &path);
// Inside Macintosh: Files (1992), pp. 2-175--2-176: HGetFInfo uses the
// explicit directory ID and returns the original 16-byte FInfo record.
if ppc_write_finfo(memory, finfo_ptr, file_type, creator, finder_flags).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
}
}
pub(super) fn ppc_h_set_finfo(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut [PpcVfsFileRecord],
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
default_dir_id: u32,
) -> i16 {
let finfo_ptr = cpu.gpr[6];
let Some((file_type, creator, finder_flags)) = ppc_read_finfo(memory, finfo_ptr) else {
return PPC_PARAM_ERR;
};
let path = match ppc_h_finfo_path(
memory,
vfs_directories,
vfs_files,
vfs_resource_files,
cpu.gpr[3] as u16 as i16,
cpu.gpr[4],
cpu.gpr[5],
default_dir_id,
) {
Ok(path) => path,
Err(err) => return err,
};
if ppc_set_finfo_for_path(
vfs_files,
vfs_resource_files,
&path,
file_type,
creator,
finder_flags,
) {
PPC_NO_ERR
} else {
PPC_FNF_ERR
}
}
pub(super) fn ppc_fsp_get_finfo(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
) -> i16 {
let spec_ptr = cpu.gpr[3];
let finfo_ptr = cpu.gpr[4];
if finfo_ptr == 0 {
return PPC_PARAM_ERR;
}
let path = match ppc_path_for_fsspec(memory, vfs_directories, spec_ptr) {
Ok(path) => path,
Err(err) => return err,
};
if let Some(directory) = vfs_directories
.iter()
.find(|directory| directory.path.eq_ignore_ascii_case(&path))
{
return if ppc_write_finfo(
memory,
finfo_ptr,
directory.file_type,
directory.creator,
directory.finder_flags,
)
.is_some()
{
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
}
if let Some(file) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&path))
{
return if ppc_write_finfo(
memory,
finfo_ptr,
file.file_type,
file.creator,
file.finder_flags,
)
.is_some()
{
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
}
if let Some(file) = vfs_resource_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&path))
{
return if ppc_write_finfo(
memory,
finfo_ptr,
file.file_type,
file.creator,
file.finder_flags,
)
.is_some()
{
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
}
let _ = ppc_write_finfo(memory, finfo_ptr, 0, 0, 0);
PPC_FNF_ERR
}
pub(super) fn ppc_fsp_set_finfo(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &mut [PpcVfsDirectory],
vfs_files: &mut [PpcVfsFileRecord],
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
) -> i16 {
let spec_ptr = cpu.gpr[3];
let finfo_ptr = cpu.gpr[4];
if finfo_ptr == 0 {
return PPC_PARAM_ERR;
}
let path = match ppc_path_for_fsspec(memory, vfs_directories, spec_ptr) {
Ok(path) => path,
Err(err) => return err,
};
let Some((file_type, creator, finder_flags)) = ppc_read_finfo(memory, finfo_ptr) else {
return PPC_PARAM_ERR;
};
let mut found = false;
for file in vfs_files
.iter_mut()
.filter(|record| record.path.eq_ignore_ascii_case(&path))
{
file.file_type = file_type;
file.creator = creator;
file.finder_flags = finder_flags;
file.dirty = true;
found = true;
}
for file in vfs_resource_files
.iter_mut()
.filter(|record| record.path.eq_ignore_ascii_case(&path))
{
file.file_type = file_type;
file.creator = creator;
file.finder_flags = finder_flags;
file.dirty = true;
found = true;
}
if found {
PPC_NO_ERR
} else if let Some(directory) = vfs_directories
.iter_mut()
.find(|directory| directory.path.eq_ignore_ascii_case(&path))
{
directory.file_type = file_type;
directory.creator = creator;
directory.finder_flags = finder_flags;
directory.dirty = true;
PPC_NO_ERR
} else {
PPC_FNF_ERR
}
}
fn ppc_write_finfo(
memory: &mut PpcSectionMem,
finfo_ptr: u32,
file_type: u32,
creator: u32,
finder_flags: u16,
) -> Option<()> {
memory.write_u32_be(finfo_ptr, file_type)?;
memory.write_u32_be(finfo_ptr + 4, creator)?;
memory.write_u16_be(finfo_ptr + 8, finder_flags)?;
memory.write_u32_be(finfo_ptr + 10, 0)?;
memory.write_u16_be(finfo_ptr + 14, 0)?;
Some(())
}
fn ppc_read_finfo(memory: &mut PpcSectionMem, finfo_ptr: u32) -> Option<(u32, u32, u16)> {
Some((
memory.read_u32_be(finfo_ptr)?,
memory.read_u32_be(finfo_ptr + 4)?,
memory.read_u16_be(finfo_ptr + 8)?,
))
}
fn ppc_write_fsspec(
memory: &mut PpcSectionMem,
spec_ptr: u32,
vref: i16,
dir_id: u32,
name_bytes: &[u8],
) -> Option<()> {
memory.write_u16_be(spec_ptr, vref as u16)?;
memory.write_u32_be(spec_ptr + 2, dir_id)?;
let len = name_bytes.len().min(63);
memory.write_u8(spec_ptr + 6, len as u8)?;
for (offset, byte) in name_bytes.iter().take(len).enumerate() {
memory.write_u8(spec_ptr + 7 + offset as u32, *byte)?;
}
Some(())
}
fn ppc_fsspec_target_exists(
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
dir_id: u32,
name_bytes: &[u8],
) -> bool {
ppc_resolved_fsspec_target_path(
vfs_directories,
vfs_files,
vfs_resource_files,
dir_id,
name_bytes,
)
.is_some()
}
fn ppc_resolved_fsspec_target_path(
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
dir_id: u32,
name_bytes: &[u8],
) -> Option<String> {
if name_bytes.is_empty() {
return ppc_directory_path_for_id(vfs_directories, dir_id).map(str::to_string);
}
let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, dir_id) else {
return None;
};
let name = decode_mac_roman(name_bytes);
let normalized_name = ppc_normalize_vfs_path(&name);
if normalized_name.is_empty() {
return None;
}
let path = ppc_join_vfs_path(parent_path, &normalized_name);
if let Some(path) = ppc_vfs_target_path(vfs_directories, vfs_files, vfs_resource_files, &path) {
return Some(path);
}
if normalized_name.contains('/') {
if let Some(path) = ppc_vfs_target_path(
vfs_directories,
vfs_files,
vfs_resource_files,
&normalized_name,
) {
return Some(path);
}
}
if dir_id != PPC_ROOT_DIR_ID {
return None;
}
ppc_vfs_target_path_by_suffix_or_unique_basename(
vfs_directories,
vfs_files,
vfs_resource_files,
&normalized_name,
)
}
fn ppc_path_for_fsspec(
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
spec_ptr: u32,
) -> Result<String, i16> {
if spec_ptr == 0 {
return Err(PPC_PARAM_ERR);
}
let Some(dir_id) = memory.read_u32_be(spec_ptr + 2) else {
return Err(PPC_PARAM_ERR);
};
let Some(name_bytes) = ppc_read_pstring_bytes(memory, spec_ptr + 6) else {
return Err(PPC_PARAM_ERR);
};
let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, dir_id) else {
return Err(PPC_DIR_NF_ERR);
};
let name = decode_mac_roman(&name_bytes);
let normalized_name = ppc_normalize_vfs_path(&name);
if normalized_name.is_empty() {
return Err(PPC_PARAM_ERR);
}
Ok(ppc_join_vfs_path(parent_path, &normalized_name))
}
fn ppc_existing_path_for_fsspec(
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
spec_ptr: u32,
) -> Result<String, i16> {
if spec_ptr == 0 {
return Err(PPC_PARAM_ERR);
}
let Some(dir_id) = memory.read_u32_be(spec_ptr + 2) else {
return Err(PPC_PARAM_ERR);
};
let Some(name_bytes) = ppc_read_pstring_bytes(memory, spec_ptr + 6) else {
return Err(PPC_PARAM_ERR);
};
if name_bytes.is_empty() {
return ppc_directory_path_for_id(vfs_directories, dir_id)
.map(str::to_string)
.ok_or(PPC_DIR_NF_ERR);
}
let name = decode_mac_roman(&name_bytes);
let normalized_name = ppc_normalize_vfs_path(&name);
if normalized_name.is_empty() {
return Err(PPC_PARAM_ERR);
}
let mut fallback_path = None;
if let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, dir_id) {
let path = ppc_join_vfs_path(parent_path, &normalized_name);
if ppc_directory_id_for_path(vfs_directories, &path).is_some() {
return Ok(path);
}
if let Some(path) = ppc_vfs_file_or_resource_path(vfs_files, vfs_resource_files, &path) {
return Ok(path);
}
fallback_path = Some(path);
}
if let Some(path) = ppc_vfs_file_or_resource_path_by_suffix_or_unique_basename(
vfs_files,
vfs_resource_files,
&normalized_name,
) {
return Ok(path);
}
fallback_path.ok_or(PPC_DIR_NF_ERR)
}
fn ppc_existing_data_path_for_fsspec(
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
spec_ptr: u32,
) -> Result<String, i16> {
if spec_ptr == 0 {
return Err(PPC_PARAM_ERR);
}
let Some(dir_id) = memory.read_u32_be(spec_ptr + 2) else {
return Err(PPC_PARAM_ERR);
};
let Some(name_bytes) = ppc_read_pstring_bytes(memory, spec_ptr + 6) else {
return Err(PPC_PARAM_ERR);
};
if name_bytes.is_empty() {
return Err(PPC_PARAM_ERR);
}
let name = decode_mac_roman(&name_bytes);
let normalized_name = ppc_normalize_vfs_path(&name);
if normalized_name.is_empty() {
return Err(PPC_PARAM_ERR);
}
if let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, dir_id) {
let path = ppc_join_vfs_path(parent_path, &normalized_name);
if let Some(index) = ppc_vfs_file_index(vfs_files, &path) {
if vfs_files[index].data.is_empty() {
if let Some(non_empty_path) =
ppc_unique_non_empty_vfs_file_path_by_basename(vfs_files, &normalized_name)
{
return Ok(non_empty_path);
}
}
return Ok(vfs_files[index].path.clone());
}
if dir_id == PPC_ROOT_DIR_ID {
if let Some(path) = ppc_vfs_file_path_by_suffix_or_unique_basename(vfs_files, &path) {
return Ok(path);
}
}
}
if dir_id == PPC_ROOT_DIR_ID {
if let Some(path) =
ppc_vfs_file_path_by_suffix_or_unique_basename(vfs_files, &normalized_name)
{
return Ok(path);
}
}
Err(PPC_FNF_ERR)
}
fn ppc_unique_non_empty_vfs_file_path_by_basename(
vfs_files: &[PpcVfsFileRecord],
path: &str,
) -> Option<String> {
let basename = ppc_vfs_basename(path);
let matches = vfs_files
.iter()
.filter(|file| !file.data.is_empty())
.filter(|file| ppc_vfs_basename(&file.path).eq_ignore_ascii_case(basename))
.map(|file| file.path.as_str())
.collect::<Vec<_>>();
ppc_unique_case_insensitive_path(matches)
}
fn ppc_vfs_target_path(
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
path: &str,
) -> Option<String> {
if let Some(directory) = vfs_directories
.iter()
.find(|directory| directory.path.eq_ignore_ascii_case(path))
{
return Some(directory.path.clone());
}
ppc_vfs_file_or_resource_path(vfs_files, vfs_resource_files, path)
}
fn ppc_vfs_target_path_by_suffix_or_unique_basename(
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
path: &str,
) -> Option<String> {
let normalized_path = ppc_normalize_vfs_path(path);
if normalized_path.is_empty() {
return None;
}
let suffix = format!("/{}", normalized_path.to_ascii_lowercase());
let all_paths = vfs_directories
.iter()
.map(|directory| directory.path.as_str())
.chain(vfs_files.iter().map(|file| file.path.as_str()))
.chain(vfs_resource_files.iter().map(|file| file.path.as_str()))
.collect::<Vec<_>>();
let suffix_matches = all_paths
.iter()
.copied()
.filter(|candidate| candidate.to_ascii_lowercase().ends_with(&suffix))
.collect::<Vec<_>>();
if let Some(path) = ppc_unique_case_insensitive_path(suffix_matches) {
return Some(path);
}
let basename = ppc_vfs_basename(&normalized_path);
let basename_matches = all_paths
.iter()
.copied()
.filter(|candidate| ppc_vfs_basename(candidate).eq_ignore_ascii_case(basename))
.collect::<Vec<_>>();
ppc_unique_case_insensitive_path(basename_matches)
}
fn ppc_vfs_file_path_by_suffix_or_unique_basename(
vfs_files: &[PpcVfsFileRecord],
path: &str,
) -> Option<String> {
let normalized_path = ppc_normalize_vfs_path(path);
if normalized_path.is_empty() {
return None;
}
let suffix = format!("/{}", normalized_path.to_ascii_lowercase());
let all_paths = vfs_files
.iter()
.map(|file| file.path.as_str())
.collect::<Vec<_>>();
let suffix_matches = all_paths
.iter()
.copied()
.filter(|candidate| candidate.to_ascii_lowercase().ends_with(&suffix))
.collect::<Vec<_>>();
if let Some(path) = ppc_unique_case_insensitive_path(suffix_matches) {
return Some(path);
}
let basename = ppc_vfs_basename(&normalized_path);
let basename_matches = all_paths
.iter()
.copied()
.filter(|candidate| ppc_vfs_basename(candidate).eq_ignore_ascii_case(basename))
.collect::<Vec<_>>();
ppc_unique_case_insensitive_path(basename_matches)
}
fn ppc_vfs_file_or_resource_path_by_suffix_or_unique_basename(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
path: &str,
) -> Option<String> {
let normalized_path = ppc_normalize_vfs_path(path);
if normalized_path.is_empty() {
return None;
}
let suffix = format!("/{}", normalized_path.to_ascii_lowercase());
let all_paths = vfs_files
.iter()
.map(|file| file.path.as_str())
.chain(vfs_resource_files.iter().map(|file| file.path.as_str()))
.collect::<Vec<_>>();
let suffix_matches = all_paths
.iter()
.copied()
.filter(|candidate| candidate.to_ascii_lowercase().ends_with(&suffix))
.collect::<Vec<_>>();
if let Some(path) = ppc_unique_case_insensitive_path(suffix_matches) {
return Some(path);
}
let basename = ppc_vfs_basename(&normalized_path);
let basename_matches = all_paths
.iter()
.copied()
.filter(|candidate| ppc_vfs_basename(candidate).eq_ignore_ascii_case(basename))
.collect::<Vec<_>>();
ppc_unique_case_insensitive_path(basename_matches)
}
fn ppc_vfs_file_or_resource_path_by_nearest_basename(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
path: &str,
context_path: Option<&str>,
) -> Option<String> {
let context_path = context_path?;
let normalized_path = ppc_normalize_vfs_path(path);
let basename = ppc_vfs_basename(&normalized_path);
if basename.is_empty() {
return None;
}
let mut matches = vfs_files
.iter()
.map(|file| file.path.as_str())
.chain(vfs_resource_files.iter().map(|file| file.path.as_str()))
.filter(|candidate| ppc_vfs_basename(candidate).eq_ignore_ascii_case(basename))
.collect::<Vec<_>>();
matches.sort_by_key(|candidate| candidate.to_ascii_lowercase());
matches.dedup_by(|left, right| left.eq_ignore_ascii_case(right));
let common_prefix_len = |candidate: &str| {
candidate
.split('/')
.zip(context_path.split('/'))
.take_while(|(left, right)| left.eq_ignore_ascii_case(right))
.count()
};
let best_prefix_len = matches
.iter()
.map(|candidate| common_prefix_len(candidate))
.max()?;
if best_prefix_len == 0 {
return None;
}
let mut best = matches
.into_iter()
.filter(|candidate| common_prefix_len(candidate) == best_prefix_len);
let selected = best.next()?;
best.next().is_none().then(|| selected.to_string())
}
fn ppc_vfs_file_or_resource_path_by_suffix(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
path: &str,
) -> Option<String> {
let normalized_path = ppc_normalize_vfs_path(path);
if normalized_path.is_empty() {
return None;
}
let suffix = format!("/{}", normalized_path.to_ascii_lowercase());
let all_paths = vfs_files
.iter()
.map(|file| file.path.as_str())
.chain(vfs_resource_files.iter().map(|file| file.path.as_str()))
.collect::<Vec<_>>();
let suffix_matches = all_paths
.iter()
.copied()
.filter(|candidate| candidate.to_ascii_lowercase().ends_with(&suffix))
.collect::<Vec<_>>();
ppc_unique_case_insensitive_path(suffix_matches)
}
fn ppc_vfs_file_or_resource_path_by_parent_basename(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
path: &str,
) -> Option<String> {
let normalized_path = ppc_normalize_vfs_path(path);
let (parent, basename) = normalized_path.rsplit_once('/')?;
let parent_basename = ppc_vfs_basename(parent);
if parent_basename.is_empty() || basename.is_empty() {
return None;
}
let all_paths = vfs_files
.iter()
.map(|file| file.path.as_str())
.chain(vfs_resource_files.iter().map(|file| file.path.as_str()))
.collect::<Vec<_>>();
let matches = all_paths
.iter()
.copied()
.filter(|candidate| {
let Some((candidate_parent, candidate_basename)) = candidate.rsplit_once('/') else {
return false;
};
candidate_basename.eq_ignore_ascii_case(basename)
&& ppc_vfs_basename(candidate_parent).eq_ignore_ascii_case(parent_basename)
})
.collect::<Vec<_>>();
ppc_unique_case_insensitive_path(matches)
}
fn ppc_unique_case_insensitive_path(mut paths: Vec<&str>) -> Option<String> {
paths.sort_by_key(|path| path.to_ascii_lowercase());
let mut unique = Vec::new();
for path in paths {
if !unique
.iter()
.any(|candidate: &&str| candidate.eq_ignore_ascii_case(path))
{
unique.push(path);
}
}
(unique.len() == 1).then(|| unique[0].to_string())
}
fn ppc_vfs_file_index(vfs_files: &[PpcVfsFileRecord], path: &str) -> Option<usize> {
vfs_files
.iter()
.position(|record| record.path.eq_ignore_ascii_case(path))
}
fn ppc_vfs_file_mut<'a>(
vfs_files: &'a mut [PpcVfsFileRecord],
path: &str,
) -> Option<&'a mut PpcVfsFileRecord> {
vfs_files
.iter_mut()
.find(|record| record.path.eq_ignore_ascii_case(path))
}
fn ppc_vfs_resource_file_index(
vfs_resource_files: &[PpcVfsResourceFileRecord],
path: &str,
) -> Option<usize> {
if let Some(index) = vfs_resource_files
.iter()
.position(|record| record.path.eq_ignore_ascii_case(path))
{
return Some(index);
}
if !path.contains('/') {
let basename = ppc_vfs_basename(path);
return vfs_resource_files
.iter()
.position(|record| ppc_vfs_basename(&record.path).eq_ignore_ascii_case(basename));
}
None
}
fn ppc_mark_resource_file_contents_dirty(
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
path: &str,
) {
if path.is_empty() {
return;
}
if let Some(record) = vfs_resource_files
.iter_mut()
.find(|record| record.path.eq_ignore_ascii_case(path))
{
record.raw_data = None;
record.dirty = true;
}
}
fn ppc_resource_file_path(resource_files: &[PpcResourceFileRecord], ref_num: i16) -> String {
resource_files
.iter()
.find(|record| record.ref_num == ref_num)
.map(|record| record.path.clone())
.unwrap_or_default()
}
fn ppc_rebind_resources_for_path(
vfs_resources: &mut [PpcVfsResourceRecord],
path: &str,
ref_num: i16,
) {
for resource in vfs_resources
.iter_mut()
.filter(|resource| resource.path.eq_ignore_ascii_case(path))
{
resource.ref_num = ref_num;
}
}
fn ppc_register_vfs_resource_fonts(resources: &[PpcVfsResourceRecord]) {
let fond_type = u32::from_be_bytes(*b"FOND");
let font_type = u32::from_be_bytes(*b"FONT");
let nfnt_type = u32::from_be_bytes(*b"NFNT");
let sfnt_type = u32::from_be_bytes(*b"sfnt");
for font in resources.iter().filter(|resource| {
resource.res_type == font_type
|| resource.res_type == nfnt_type
|| resource.res_type == sfnt_type
}) {
let associations = resources
.iter()
.filter(|resource| {
resource.path.eq_ignore_ascii_case(&font.path) && resource.res_type == fond_type
})
.filter_map(|fond| {
crate::quickdraw::fonts::parse_fond_associations(fond.res_id, &fond.data)
})
.flatten()
.filter(|association| association.font_resource_id == font.res_id)
.collect::<Vec<_>>();
if associations.is_empty() {
if font.res_type == font_type {
let _ =
crate::quickdraw::fonts::register_resource_font_strike(font.res_id, &font.data);
}
continue;
}
for association in associations {
if association.style & 0x00ff != 0 {
continue;
}
let registered = if font.res_type == sfnt_type {
crate::quickdraw::fonts::register_resource_outline_font(
association.family_id,
&font.data,
)
} else {
crate::quickdraw::fonts::register_resource_font_strike_for_family(
association.family_id,
association.size,
&font.data,
)
};
if registered && std::env::var_os("SYSTEMLESS_TRACE_FONT_TRAPS").is_some() {
eprintln!(
"[FONT] PPC FOND {} maps {}pt style ${:04X} to bitmap resource {}",
association.family_id,
association.size,
association.style,
association.font_resource_id,
);
}
}
}
}
fn ppc_vfs_font_id_for_name(resources: &[PpcVfsResourceRecord], name: &str) -> Option<i16> {
let fond_type = u32::from_be_bytes(*b"FOND");
resources
.iter()
.filter(|resource| resource.res_type == fond_type)
.find(|resource| {
decode_mac_roman(&resource.name)
.trim()
.eq_ignore_ascii_case(name.trim())
})
.map(|resource| resource.res_id)
}
fn ppc_vfs_font_name_for_id(resources: &[PpcVfsResourceRecord], font_id: i16) -> Option<String> {
let fond_type = u32::from_be_bytes(*b"FOND");
resources
.iter()
.find(|resource| resource.res_type == fond_type && resource.res_id == font_id)
.map(|resource| decode_mac_roman(&resource.name))
}
fn ppc_materialize_resource_records_for_path(
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
path: &str,
) {
let Some(raw_data) = vfs_resource_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(path))
.and_then(|file| file.raw_data.as_ref())
else {
return;
};
let Some(fork) = ResourceFork::parse(raw_data) else {
return;
};
let mut sorted_resources = fork.resources().values().collect::<Vec<_>>();
sorted_resources.sort_by_key(|resource| (resource.res_type, resource.id));
for resource in sorted_resources {
let res_type = u32::from_be_bytes(resource.res_type);
if vfs_resources.iter().any(|existing| {
existing.path.eq_ignore_ascii_case(path)
&& existing.res_type == res_type
&& existing.res_id == resource.id
}) {
continue;
}
vfs_resources.push(PpcVfsResourceRecord {
ref_num: 0,
path: path.to_string(),
res_type,
res_id: resource.id,
name: resource.name_bytes.clone().unwrap_or_default(),
data: resource.data.clone(),
raw_data: resource.raw_data.clone(),
raw_attrs: resource.raw_attrs.map(u16::from),
attrs: u16::from(resource.attrs),
handle: 0,
});
}
}
fn ppc_materialize_quilt_resources_for_existing_path(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
path: &str,
) {
let Some((_, mut resources)) =
ppc_quilt_named_resource_records(vfs_files, vfs_resource_files, path)
else {
return;
};
resources.sort_by_key(|resource| (resource.res_type, resource.res_id));
for mut resource in resources {
if vfs_resources.iter().any(|existing| {
existing.path.eq_ignore_ascii_case(path)
&& existing.res_type == resource.res_type
&& existing.res_id == resource.res_id
}) {
continue;
}
resource.path = path.to_string();
vfs_resources.push(resource);
}
}
fn ppc_materialize_unique_named_resource_file(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
path: &str,
) -> bool {
if ppc_vfs_resource_file_index(vfs_resource_files, path).is_some() {
return true;
}
let basename = ppc_vfs_basename(path);
let mut matches = Vec::new();
for file in vfs_resource_files.iter() {
let Some(raw_data) = file.raw_data.as_ref() else {
continue;
};
let Some(fork) = ResourceFork::parse(raw_data) else {
continue;
};
for resource in fork.resources().values() {
let Some(name_bytes) = resource.name_bytes.as_ref() else {
continue;
};
let name = decode_mac_roman(name_bytes);
if ppc_vfs_basename(&ppc_normalize_vfs_path(&name)).eq_ignore_ascii_case(basename) {
matches.push((file.clone(), resource.clone()));
}
}
}
let quilt_records = ppc_quilt_named_resource_records(vfs_files, vfs_resource_files, path);
let prefer_quilt_records = basename.to_ascii_lowercase().ends_with(".picr")
&& quilt_records.as_ref().is_some_and(|(_, resources)| {
let img_type = u32::from_be_bytes(*b"#Img");
let pict_type = u32::from_be_bytes(*b"PICT");
resources
.iter()
.any(|resource| resource.res_type == img_type || resource.res_type == pict_type)
});
let (source_file, mut resources) = if matches.is_empty() {
match quilt_records {
Some(records) => records,
None => return false,
}
} else if prefer_quilt_records {
match quilt_records {
Some(records) => records,
None => return false,
}
} else {
let source_path = &matches[0].0.path;
if matches
.iter()
.any(|(source_file, _)| !source_file.path.eq_ignore_ascii_case(source_path))
{
match quilt_records {
Some(records) => records,
None => return false,
}
} else {
let source_file = matches[0].0.clone();
let resources = matches
.into_iter()
.map(|(_, resource)| PpcVfsResourceRecord {
ref_num: 0,
path: path.to_string(),
res_type: u32::from_be_bytes(resource.res_type),
res_id: resource.id,
name: resource.name_bytes.unwrap_or_default(),
data: resource.data,
raw_data: resource.raw_data,
raw_attrs: resource.raw_attrs.map(u16::from),
attrs: u16::from(resource.attrs),
handle: 0,
})
.collect::<Vec<_>>();
(source_file, resources)
}
};
ppc_synthesize_quilt_img_resource_if_missing(path, &mut resources);
let resource_len = resources
.iter()
.map(|resource| resource.data.len())
.sum::<usize>();
vfs_resource_files.push(PpcVfsResourceFileRecord {
path: path.to_string(),
creator: source_file.creator,
file_type: source_file.file_type,
finder_flags: source_file.finder_flags,
resource_len: u32::try_from(resource_len).unwrap_or(u32::MAX),
raw_data: None,
map_attrs: source_file.map_attrs,
dirty: false,
});
resources.sort_by_key(|resource| (resource.res_type, resource.res_id));
for mut resource in resources {
resource.path = path.to_string();
vfs_resources.push(resource);
}
true
}
fn ppc_synthesize_quilt_img_resource_if_missing(
path: &str,
resources: &mut Vec<PpcVfsResourceRecord>,
) {
let img_type = u32::from_be_bytes(*b"#Img");
if resources
.iter()
.any(|resource| resource.res_type == img_type)
{
return;
}
let pict_type = u32::from_be_bytes(*b"PICT");
let frame_count = resources
.iter()
.filter(|resource| resource.res_type == pict_type)
.count();
if frame_count == 0 {
return;
}
let mut data = vec![0u8; 18];
data[0..2].copy_from_slice(&1u16.to_be_bytes());
data[2..4].copy_from_slice(&1u16.to_be_bytes());
data[4..6].copy_from_slice(&1u16.to_be_bytes());
data[6..8].copy_from_slice(&(u16::try_from(frame_count).unwrap_or(u16::MAX)).to_be_bytes());
data[8..10].copy_from_slice(&1u16.to_be_bytes());
data[10..12].copy_from_slice(&1u16.to_be_bytes());
resources.push(PpcVfsResourceRecord {
ref_num: 0,
path: path.to_string(),
res_type: img_type,
res_id: 1000,
name: ppc_vfs_basename(path).as_bytes().to_vec(),
data,
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
fn ppc_quilt_named_resource_records(
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
target_path: &str,
) -> Option<(PpcVfsResourceFileRecord, Vec<PpcVfsResourceRecord>)> {
let target_basename = ppc_vfs_basename(target_path);
let versionless_target_basename = target_basename
.trim_end_matches(|character: char| character.is_ascii_digit())
.trim_end();
let mut matches = Vec::new();
let mut best_name_rank = 0u8;
for resource_file in vfs_resource_files {
let Some(raw_data) = resource_file.raw_data.as_ref() else {
continue;
};
let Some(fork) = ResourceFork::parse(raw_data) else {
continue;
};
let Some(data_file) = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(&resource_file.path))
else {
continue;
};
for resource in fork.resources().values() {
if resource.res_type != *b"qDir" {
continue;
}
for record in resource.data.chunks_exact(60) {
let name_len = u16::from_be_bytes([record[26], record[27]]) as usize;
if name_len == 0 || name_len > 32 {
continue;
}
let name_bytes = &record[28..28 + name_len];
let name = decode_mac_roman(name_bytes);
let normalized_name = ppc_normalize_vfs_path(&name);
let record_basename = ppc_vfs_basename(&normalized_name);
let name_rank = if record_basename.eq_ignore_ascii_case(target_basename) {
2
} else if versionless_target_basename.len() < target_basename.len()
&& record_basename.eq_ignore_ascii_case(versionless_target_basename)
{
1
} else {
0
};
if name_rank == 0 || name_rank < best_name_rank {
continue;
}
if name_rank > best_name_rank {
matches.clear();
best_name_rank = name_rank;
}
let data_len =
u32::from_be_bytes([record[8], record[9], record[10], record[11]]) as usize;
let data_offset =
u32::from_be_bytes([record[12], record[13], record[14], record[15]]) as usize;
let Some(end) = data_offset.checked_add(data_len) else {
continue;
};
let Some(data) = data_file.data.get(data_offset..end) else {
continue;
};
matches.push((
resource_file.clone(),
PpcVfsResourceRecord {
ref_num: 0,
path: String::new(),
res_type: u32::from_be_bytes([record[0], record[1], record[2], record[3]]),
res_id: u32::from_be_bytes([record[4], record[5], record[6], record[7]])
as u16 as i16,
name: name_bytes.to_vec(),
data: data.to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
));
}
}
}
if matches.is_empty() {
return None;
}
let mut source_paths = matches
.iter()
.map(|(source_file, _)| source_file.path.clone())
.collect::<Vec<_>>();
source_paths.sort_by_key(|path| {
let common_prefix = path
.split('/')
.zip(target_path.split('/'))
.take_while(|(left, right)| left.eq_ignore_ascii_case(right))
.count();
let depth = path
.split('/')
.filter(|component| !component.is_empty())
.count();
std::cmp::Reverse((common_prefix, depth))
});
source_paths.dedup_by(|left, right| left.eq_ignore_ascii_case(right));
let source_path = source_paths.first()?;
matches.retain(|(source_file, _)| source_file.path.eq_ignore_ascii_case(source_path));
let source_file = matches.first()?.0.clone();
let mut resources = matches
.into_iter()
.map(|(_, resource)| resource)
.collect::<Vec<_>>();
ppc_add_quilt_anam_picture_resources(vfs_files, &source_file, &mut resources);
ppc_expand_compact_quilt_frames(&mut resources);
ppc_wrap_quilt_raw_pict_frames(&mut resources);
Some((source_file, resources))
}
fn ppc_add_quilt_anam_picture_resources(
vfs_files: &[PpcVfsFileRecord],
source_file: &PpcVfsResourceFileRecord,
resources: &mut Vec<PpcVfsResourceRecord>,
) {
ppc_apply_quilt_animation_resource_names(resources);
let pict_type = u32::from_be_bytes(*b"PICT");
let img_type = u32::from_be_bytes(*b"#Img");
if resources
.iter()
.any(|resource| resource.res_type == pict_type || resource.res_type == img_type)
{
return;
}
let anam_type = u32::from_be_bytes(*b"ANAM");
let Some(picture_name) = resources
.iter()
.find(|resource| resource.res_type == anam_type)
.and_then(|resource| {
let len = resource
.data
.iter()
.position(|byte| *byte == 0)
.unwrap_or(resource.data.len());
let name = decode_mac_roman(&resource.data[..len]);
let normalized = ppc_normalize_vfs_path(&name);
normalized
.to_ascii_lowercase()
.ends_with(".picr")
.then_some(normalized)
})
else {
return;
};
let picture_basename = ppc_vfs_basename(&picture_name);
let Some(raw_data) = source_file.raw_data.as_ref() else {
return;
};
let Some(fork) = ResourceFork::parse(raw_data) else {
return;
};
let Some(data_file) = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(&source_file.path))
else {
return;
};
let existing = resources
.iter()
.map(|resource| (resource.res_type, resource.res_id))
.collect::<Vec<_>>();
for resource in fork.resources().values() {
if resource.res_type != *b"qDir" {
continue;
}
for record in resource.data.chunks_exact(60) {
let name_len = u16::from_be_bytes([record[26], record[27]]) as usize;
if name_len == 0 || name_len > 32 {
continue;
}
let name_bytes = &record[28..28 + name_len];
let name = decode_mac_roman(name_bytes);
if !ppc_vfs_basename(&ppc_normalize_vfs_path(&name))
.eq_ignore_ascii_case(picture_basename)
{
continue;
}
let res_type = u32::from_be_bytes([record[0], record[1], record[2], record[3]]);
let res_id =
u32::from_be_bytes([record[4], record[5], record[6], record[7]]) as u16 as i16;
if existing.iter().any(|(existing_type, existing_id)| {
*existing_type == res_type && *existing_id == res_id
}) {
continue;
}
let data_len =
u32::from_be_bytes([record[8], record[9], record[10], record[11]]) as usize;
let data_offset =
u32::from_be_bytes([record[12], record[13], record[14], record[15]]) as usize;
let Some(end) = data_offset.checked_add(data_len) else {
continue;
};
let Some(data) = data_file.data.get(data_offset..end) else {
continue;
};
resources.push(PpcVfsResourceRecord {
ref_num: 0,
path: String::new(),
res_type,
res_id,
name: name_bytes.to_vec(),
data: data.to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
}
}
}
fn ppc_apply_quilt_animation_resource_names(resources: &mut [PpcVfsResourceRecord]) {
let animation_list_type = u32::from_be_bytes(*b"Alst");
let animation_name_type = u32::from_be_bytes(*b"ANAM");
let names = resources
.iter()
.filter(|resource| resource.res_type == animation_name_type)
.filter_map(|resource| {
let len = resource
.data
.iter()
.position(|byte| *byte == 0)
.unwrap_or(resource.data.len());
let name = resource.data.get(..len)?;
decode_mac_roman(name)
.to_ascii_lowercase()
.ends_with(".picr")
.then(|| (resource.res_id, name.to_vec()))
})
.collect::<Vec<_>>();
for resource in resources
.iter_mut()
.filter(|resource| resource.res_type == animation_list_type)
{
if let Some((_, name)) = names.iter().find(|(id, _)| *id == resource.res_id) {
resource.name.clone_from(name);
}
}
}
fn ppc_expand_compact_quilt_frames(resources: &mut Vec<PpcVfsResourceRecord>) {
let img_type = u32::from_be_bytes(*b"#Img");
let frms_type = u32::from_be_bytes(*b"frms");
let pict_type = u32::from_be_bytes(*b"PICT");
let header_frame_count = resources
.iter()
.find(|resource| resource.res_type == img_type && resource.data.len() >= 8)
.map(|img| u16::from_be_bytes([img.data[6], img.data[7]]) as usize)
.unwrap_or(0);
let frms_indices = resources
.iter()
.enumerate()
.filter(|(_, resource)| resource.res_type == frms_type)
.map(|(index, _)| index)
.collect::<Vec<_>>();
let pict_indices = resources
.iter()
.enumerate()
.filter(|(_, resource)| resource.res_type == pict_type)
.map(|(index, _)| index)
.collect::<Vec<_>>();
if frms_indices.len() != 1 || pict_indices.len() != 1 {
return;
}
let frms = resources[frms_indices[0]].clone();
let pict = resources[pict_indices[0]].clone();
if pict.data.is_empty() {
return;
}
let inferred_frame_count = frms.data.len() / 8;
let frame_count = if header_frame_count > 1
&& frms.data.len() == header_frame_count * 8
&& pict.data.len() % header_frame_count == 0
{
header_frame_count
} else if inferred_frame_count > 1 && frms.data.len() == inferred_frame_count * 8 {
inferred_frame_count
} else {
return;
};
if pict.data.len() % frame_count != 0 {
return;
}
let frame_pict_len = pict.data.len() / frame_count;
let mut expanded = resources
.iter()
.filter(|resource| resource.res_type != frms_type && resource.res_type != pict_type)
.cloned()
.collect::<Vec<_>>();
for frame_index in 0..frame_count {
let Some(res_id) = 1000i16.checked_add(frame_index as i16) else {
return;
};
let frame_offset = frame_index * 8;
let pict_offset = frame_index * frame_pict_len;
let mut frame_resource = frms.clone();
frame_resource.res_id = res_id;
frame_resource.data = frms.data[frame_offset..frame_offset + 8].to_vec();
frame_resource.handle = 0;
expanded.push(frame_resource);
let mut pict_resource = pict.clone();
pict_resource.res_id = res_id;
pict_resource.data = pict.data[pict_offset..pict_offset + frame_pict_len].to_vec();
pict_resource.handle = 0;
expanded.push(pict_resource);
}
*resources = expanded;
}
fn ppc_wrap_quilt_raw_pict_frames(resources: &mut [PpcVfsResourceRecord]) {
let frms_type = u32::from_be_bytes(*b"frms");
let pict_type = u32::from_be_bytes(*b"PICT");
let frame_rects = resources
.iter()
.filter(|resource| resource.res_type == frms_type && resource.data.len() == 8)
.map(|resource| (resource.res_id, resource.data.clone()))
.collect::<Vec<_>>();
if frame_rects.is_empty() {
return;
}
for resource in resources.iter_mut() {
if resource.res_type != pict_type {
continue;
}
let Some((_, rect)) = frame_rects
.iter()
.find(|(res_id, _)| *res_id == resource.res_id)
else {
continue;
};
let top = i16::from_be_bytes([rect[0], rect[1]]);
let bottom = i16::from_be_bytes([rect[4], rect[5]]);
let height = i32::from(bottom) - i32::from(top);
if height <= 0 || resource.data.len() % height as usize != 0 {
continue;
}
let Some(pict_size) = resource.data.len().checked_add(24) else {
continue;
};
let pict_size = u16::try_from(pict_size).unwrap_or(u16::MAX);
let mut wrapped = Vec::with_capacity(usize::from(pict_size));
wrapped.extend_from_slice(&pict_size.to_be_bytes());
wrapped.extend_from_slice(rect);
wrapped.extend_from_slice(&[0; 14]);
wrapped.extend_from_slice(&resource.data);
resource.data = wrapped;
resource.handle = 0;
}
}
fn ppc_file_permission_allows_writing(permission: u8) -> bool {
// Inside Macintosh: Files (1992), pp. 2-7--2-8: fsCurPerm grants
// read/write when available, and fsWrPerm is synonymous with fsRdWrPerm.
matches!(permission, 0 | 2 | 3 | 4)
}
fn ppc_fsp_open_df(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut Vec<PpcVfsFileRecord>,
files: &mut Vec<PpcFileRecord>,
writable_refnums: &mut HashSet<u16>,
next_file_ref_num: &mut i16,
) -> i16 {
let spec_ptr = cpu.gpr[3];
let permission = cpu.gpr[4] as u8;
let ref_num_out_ptr = cpu.gpr[5];
if ref_num_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, ref_num_out_ptr, 2) {
return PPC_PARAM_ERR;
}
let path = match ppc_existing_data_path_for_fsspec(memory, vfs_directories, vfs_files, spec_ptr)
{
Ok(path) => path,
Err(err) => return err,
};
let ref_num = *next_file_ref_num;
let Some(next_ref_num) = next_file_ref_num.checked_add(1) else {
return PPC_PARAM_ERR;
};
let Some(existing_index) = ppc_vfs_file_index(vfs_files, &path) else {
return PPC_FNF_ERR;
};
let opened_data_len = vfs_files[existing_index].data.len();
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] FSpOpenDF path=\"{}\" permission={} data_len={} result={}",
path, permission, opened_data_len, PPC_NO_ERR
);
}
let _ = memory.write_u16_be(ref_num_out_ptr, ref_num as u16);
files.push(PpcFileRecord {
ref_num,
path,
position: 0,
});
if ppc_file_permission_allows_writing(permission) {
writable_refnums.insert(ref_num as u16);
}
*next_file_ref_num = next_ref_num;
PPC_NO_ERR
}
fn ppc_h_open(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
files: &mut Vec<PpcFileRecord>,
writable_refnums: &mut HashSet<u16>,
next_file_ref_num: &mut i16,
default_dir_id: u32,
) -> i16 {
// Inside Macintosh: Files (1992), 2-181: HOpen takes vRefNum, dirID,
// fileName, permission, and a returned file reference number.
let vref = cpu.gpr[3] as u16 as i16;
let dir_id = cpu.gpr[4];
ppc_open_data_fork_by_name(
memory,
vfs_directories,
vfs_files,
files,
writable_refnums,
next_file_ref_num,
default_dir_id,
vref,
dir_id,
cpu.gpr[5],
cpu.gpr[6] as u8,
cpu.gpr[7],
)
}
fn ppc_fs_open(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
files: &mut Vec<PpcFileRecord>,
writable_refnums: &mut HashSet<u16>,
next_file_ref_num: &mut i16,
default_dir_id: u32,
) -> i16 {
// Inside Macintosh: Files (1992), 2-179: FSOpen resolves its file name
// relative to the current volume/directory and returns a refnum.
ppc_open_data_fork_by_name(
memory,
vfs_directories,
vfs_files,
files,
writable_refnums,
next_file_ref_num,
default_dir_id,
0,
0,
cpu.gpr[3],
cpu.gpr[4] as u8,
cpu.gpr[5],
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_open_data_fork_by_name(
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
files: &mut Vec<PpcFileRecord>,
writable_refnums: &mut HashSet<u16>,
next_file_ref_num: &mut i16,
default_dir_id: u32,
vref: i16,
dir_id: u32,
name_ptr: u32,
permission: u8,
ref_num_out_ptr: u32,
) -> i16 {
if !matches!(vref, 0 | PPC_BOOT_VOLUME_REF_NUM)
|| ref_num_out_ptr == 0
|| !ppc_memory_can_write_bytes(memory, ref_num_out_ptr, 2)
{
return PPC_PARAM_ERR;
}
let Some(name_bytes) = ppc_read_pstring_bytes(memory, name_ptr) else {
return PPC_PARAM_ERR;
};
let name = ppc_normalize_vfs_path(&decode_mac_roman(&name_bytes));
if name.is_empty() {
return PPC_PARAM_ERR;
}
let effective_dir_id = ppc_resolve_directory_id(vref, dir_id, default_dir_id);
let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, effective_dir_id) else {
return PPC_DIR_NF_ERR;
};
let requested_path = ppc_join_vfs_path(parent_path, &name);
let path = ppc_vfs_file_index(vfs_files, &requested_path)
.map(|index| vfs_files[index].path.clone())
.or_else(|| ppc_vfs_file_path_by_suffix_or_unique_basename(vfs_files, &name));
let Some(path) = path else {
return PPC_FNF_ERR;
};
let ref_num = *next_file_ref_num;
let Some(next_ref_num) = next_file_ref_num.checked_add(1) else {
return PPC_PARAM_ERR;
};
if memory
.write_u16_be(ref_num_out_ptr, ref_num as u16)
.is_none()
{
return PPC_PARAM_ERR;
}
files.push(PpcFileRecord {
ref_num,
path,
position: 0,
});
if ppc_file_permission_allows_writing(permission) {
writable_refnums.insert(ref_num as u16);
}
*next_file_ref_num = next_ref_num;
PPC_NO_ERR
}
fn ppc_pbh_open_df(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut [PpcVfsFileRecord],
files: &mut Vec<PpcFileRecord>,
writable_refnums: &mut HashSet<u16>,
next_file_ref_num: &mut i16,
) -> i16 {
let pb = cpu.gpr[3];
if pb == 0 || !ppc_memory_can_write_bytes(memory, pb, 52) {
return PPC_PARAM_ERR;
}
let Some(name_ptr) = memory.read_u32_be(pb + 18) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(name_bytes) = ppc_read_pstring_bytes(memory, name_ptr) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(dir_id) = memory.read_u32_be(pb + 48) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(permission) = memory.read_u8(pb + 27) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let name = ppc_normalize_vfs_path(&decode_mac_roman(&name_bytes));
if name.is_empty() {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
let exact_path = ppc_directory_path_for_id(vfs_directories, dir_id)
.map(|parent| ppc_join_vfs_path(parent, &name));
let path = exact_path
.as_deref()
.and_then(|path| {
ppc_vfs_file_index(vfs_files, path).map(|index| vfs_files[index].path.clone())
})
.or_else(|| ppc_vfs_file_path_by_suffix_or_unique_basename(vfs_files, &name));
let Some(path) = path else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
let ref_num = *next_file_ref_num;
let Some(next_ref_num) = next_file_ref_num.checked_add(1) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
// Inside Macintosh: Files (1992), 2-183 through 2-184: PBHOpenDF uses
// ioNamePtr/ioVRefNum/ioDirID to open a data fork and returns the access
// path's file reference number in ioRefNum at offset 24.
if memory.write_u16_be(pb + 24, ref_num as u16).is_none() {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
files.push(PpcFileRecord {
ref_num,
path,
position: 0,
});
if ppc_file_permission_allows_writing(permission) {
writable_refnums.insert(ref_num as u16);
}
*next_file_ref_num = next_ref_num;
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
fn ppc_fs_close(
cpu: &mut PpcCpu,
files: &mut Vec<PpcFileRecord>,
writable_refnums: &mut HashSet<u16>,
) -> i16 {
let ref_num = ppc_ref_num_from_gpr(cpu.gpr[3]);
files.retain(|file| file.ref_num != ref_num);
writable_refnums.remove(&(ref_num as u16));
PPC_NO_ERR
}
fn ppc_pb_close(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
files: &mut Vec<PpcFileRecord>,
writable_refnums: &mut HashSet<u16>,
) -> i16 {
let pb = cpu.gpr[3];
let Some(ref_num) = memory.read_u16_be(pb + 24).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
if !files.iter().any(|file| file.ref_num == ref_num) {
return ppc_complete_pb(memory, pb, PPC_RF_NUM_ERR);
}
files.retain(|file| file.ref_num != ref_num);
writable_refnums.remove(&(ref_num as u16));
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
fn ppc_pb_flush_file(cpu: &PpcCpu, memory: &mut PpcSectionMem, files: &[PpcFileRecord]) -> i16 {
let pb = cpu.gpr[3];
let Some(ref_num) = memory.read_u16_be(pb + 24).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
// VFS writes are committed to their in-memory fork immediately, so the
// synchronous flush only validates the open file and completes ioResult.
let result = if files.iter().any(|file| file.ref_num == ref_num) {
PPC_NO_ERR
} else {
PPC_RF_NUM_ERR
};
ppc_complete_pb(memory, pb, result)
}
fn ppc_pb_position(mode: u16, offset: i32, mark: u32, eof: usize) -> Option<usize> {
let base = match mode & 0x000f {
0 => i64::from(mark),
1 => 0,
2 => i64::try_from(eof).ok()?,
3 => i64::from(mark),
_ => return None,
};
let delta = if mode & 0x000f == 0 {
0
} else {
i64::from(offset)
};
usize::try_from(base.checked_add(delta)?).ok()
}
fn ppc_pb_read(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
files: &mut [PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
) -> i16 {
let pb = cpu.gpr[3];
if pb == 0 || !ppc_memory_can_write_bytes(memory, pb, 50) {
return PPC_PARAM_ERR;
}
let Some(ref_num) = memory.read_u16_be(pb + 24).map(|value| value as i16) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(buffer_ptr) = memory.read_u32_be(pb + 32) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(requested_count) = memory.read_u32_be(pb + 36) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(position_mode) = memory.read_u16_be(pb + 44) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(position_offset) = memory.read_u32_be(pb + 46).map(|value| value as i32) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(file_index) = files.iter().position(|file| file.ref_num == ref_num) else {
return ppc_complete_pb(memory, pb, PPC_RF_NUM_ERR);
};
let Some(vfs_file) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&files[file_index].path))
else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
let Some(start) = ppc_pb_position(
position_mode,
position_offset,
files[file_index].position,
vfs_file.data.len(),
) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
if start > vfs_file.data.len() {
return ppc_complete_pb(memory, pb, PPC_POS_ERR);
}
let requested_len = usize::try_from(requested_count).unwrap_or(usize::MAX);
let read_len = requested_len.min(vfs_file.data.len().saturating_sub(start));
if read_len != 0
&& (buffer_ptr == 0 || !ppc_memory_can_write_bytes(memory, buffer_ptr, read_len as u32))
{
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
for (offset, byte) in vfs_file.data[start..start + read_len]
.iter()
.copied()
.enumerate()
{
if memory.write_u8(buffer_ptr + offset as u32, byte).is_none() {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
}
let new_position = start.saturating_add(read_len).min(u32::MAX as usize) as u32;
files[file_index].position = new_position;
let _ = memory.write_u32_be(pb + 40, read_len as u32);
let _ = memory.write_u32_be(pb + 46, new_position);
let result = if read_len < requested_len {
PPC_EOF_ERR
} else {
PPC_NO_ERR
};
ppc_complete_pb(memory, pb, result)
}
fn ppc_pb_write(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
files: &mut [PpcFileRecord],
writable_refnums: &HashSet<u16>,
vfs_files: &mut [PpcVfsFileRecord],
) -> i16 {
let pb = cpu.gpr[3];
if pb == 0 || !ppc_memory_can_write_bytes(memory, pb, 50) {
return PPC_PARAM_ERR;
}
let Some(ref_num) = memory.read_u16_be(pb + 24).map(|value| value as i16) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(buffer_ptr) = memory.read_u32_be(pb + 32) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(requested_count) = memory.read_u32_be(pb + 36) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(position_mode) = memory.read_u16_be(pb + 44) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(position_offset) = memory.read_u32_be(pb + 46).map(|value| value as i32) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
if requested_count != 0
&& (buffer_ptr == 0 || !ppc_memory_can_read_bytes(memory, buffer_ptr, requested_count))
{
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
let Some(file_index) = files.iter().position(|file| file.ref_num == ref_num) else {
return ppc_complete_pb(memory, pb, PPC_RF_NUM_ERR);
};
if !writable_refnums.contains(&(ref_num as u16)) {
return ppc_complete_pb(memory, pb, PPC_WR_PERM_ERR);
}
let Some(vfs_file_index) = vfs_files
.iter()
.position(|record| record.path.eq_ignore_ascii_case(&files[file_index].path))
else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
let Some(start) = ppc_pb_position(
position_mode,
position_offset,
files[file_index].position,
vfs_files[vfs_file_index].data.len(),
) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Ok(write_len) = usize::try_from(requested_count) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(end) = start.checked_add(write_len) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let write_result = vfs_files[vfs_file_index].data.with_mut(|data| {
data.resize(end, 0);
for offset in 0..write_len {
let Some(byte) = memory.read_u8(buffer_ptr + offset as u32) else {
return Err(());
};
data[start + offset] = byte;
}
Ok(())
});
if write_result.is_err() {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
vfs_files[vfs_file_index].dirty = true;
let new_position = end.min(u32::MAX as usize) as u32;
files[file_index].position = new_position;
let _ = memory.write_u32_be(pb + 40, requested_count);
let _ = memory.write_u32_be(pb + 46, new_position);
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
fn ppc_pb_get_eof(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
files: &[PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
) -> i16 {
let pb = cpu.gpr[3];
let Some(ref_num) = memory.read_u16_be(pb + 24).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(file) = files.iter().find(|file| file.ref_num == ref_num) else {
return ppc_complete_pb(memory, pb, PPC_RF_NUM_ERR);
};
let Some(vfs_file) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&file.path))
else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
let eof = u32::try_from(vfs_file.data.len()).unwrap_or(u32::MAX);
if memory.write_u32_be(pb + 28, eof).is_none() {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
}
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
fn ppc_pb_set_eof(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
files: &mut [PpcFileRecord],
writable_refnums: &HashSet<u16>,
vfs_files: &mut [PpcVfsFileRecord],
) -> i16 {
let pb = cpu.gpr[3];
let Some(ref_num) = memory.read_u16_be(pb + 24).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(new_eof) = memory.read_u32_be(pb + 28) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(file_index) = files.iter().position(|file| file.ref_num == ref_num) else {
return ppc_complete_pb(memory, pb, PPC_RF_NUM_ERR);
};
if !writable_refnums.contains(&(ref_num as u16)) {
return ppc_complete_pb(memory, pb, PPC_WR_PERM_ERR);
}
let Some(vfs_file) = vfs_files
.iter_mut()
.find(|record| record.path.eq_ignore_ascii_case(&files[file_index].path))
else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
let Ok(new_len) = usize::try_from(new_eof) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
vfs_file.data.with_mut(|data| data.resize(new_len, 0));
vfs_file.dirty = true;
files[file_index].position = files[file_index].position.min(new_eof);
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
fn ppc_pb_set_fpos(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
files: &mut [PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
) -> i16 {
let pb = cpu.gpr[3];
let Some(ref_num) = memory.read_u16_be(pb + 24).map(|value| value as i16) else {
return PPC_PARAM_ERR;
};
let Some(position_mode) = memory.read_u16_be(pb + 44) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(position_offset) = memory.read_u32_be(pb + 46).map(|value| value as i32) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(file_index) = files.iter().position(|file| file.ref_num == ref_num) else {
return ppc_complete_pb(memory, pb, PPC_RF_NUM_ERR);
};
let Some(eof) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&files[file_index].path))
.map(|record| record.data.len())
else {
return ppc_complete_pb(memory, pb, PPC_FNF_ERR);
};
let Some(position) = ppc_pb_position(
position_mode,
position_offset,
files[file_index].position,
eof,
) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Ok(position) = u32::try_from(position) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
files[file_index].position = position;
let _ = memory.write_u32_be(pb + 46, position);
ppc_complete_pb(memory, pb, PPC_NO_ERR)
}
// Inside Macintosh: Files (1992), 2-92 through 2-103 and the I/O parameter
// layout on 2-237 define PBRead/PBWrite/PBSetFPos/PBGetEOF/PBSetEOF/PBClose,
// including ioActCount, mark updates, and eofErr on a short read.
fn ppc_fsp_create_res_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
last_resource_error: &mut i16,
) {
let spec_ptr = cpu.gpr[3];
let creator = cpu.gpr[4];
let file_type = cpu.gpr[5];
let path = match ppc_path_for_fsspec(memory, vfs_directories, spec_ptr) {
Ok(path) => path,
Err(err) => {
*last_resource_error = err;
return;
}
};
if ppc_vfs_resource_file_index(vfs_resource_files, &path).is_some() {
*last_resource_error = PPC_DUP_FN_ERR;
return;
}
if ppc_vfs_file_index(vfs_files, &path).is_none() {
vfs_files.push(PpcVfsFileRecord {
path: path.clone(),
data: Vec::new().into(),
creator,
file_type,
finder_flags: 0,
dirty: true,
});
}
vfs_resource_files.push(PpcVfsResourceFileRecord {
path,
creator,
file_type,
finder_flags: 0,
resource_len: 0,
raw_data: None,
map_attrs: 0,
dirty: true,
});
*last_resource_error = PPC_NO_ERR;
}
fn ppc_h_create_res_file(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
default_dir_id: u32,
last_resource_error: &mut i16,
) {
let vref = cpu.gpr[3] as u16 as i16;
if !matches!(vref, 0 | PPC_BOOT_VOLUME_REF_NUM) {
*last_resource_error = PPC_NSV_ERR;
return;
}
let Some(name_bytes) = ppc_read_pstring_bytes(memory, cpu.gpr[5]) else {
*last_resource_error = PPC_PARAM_ERR;
return;
};
let name = ppc_normalize_vfs_path(&decode_mac_roman(&name_bytes));
if name.is_empty() {
*last_resource_error = PPC_BD_NAM_ERR;
return;
}
let dir_id = ppc_resolve_directory_id(vref, cpu.gpr[4], default_dir_id);
let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, dir_id) else {
*last_resource_error = PPC_DIR_NF_ERR;
return;
};
let path = ppc_join_vfs_path(parent_path, &name);
if ppc_vfs_resource_file_index(vfs_resource_files, &path).is_some() {
*last_resource_error = PPC_DUP_FN_ERR;
return;
}
let (creator, file_type, finder_flags) =
if let Some(index) = ppc_vfs_file_index(vfs_files, &path) {
let file = &vfs_files[index];
(file.creator, file.file_type, file.finder_flags)
} else {
vfs_files.push(PpcVfsFileRecord {
path: path.clone(),
data: Vec::new().into(),
creator: 0,
file_type: 0,
finder_flags: 0,
dirty: true,
});
(0, 0, 0)
};
// More Macintosh Toolbox (1993), pp. 1-56--1-57: HCreateResFile uses
// vRefNum/dirID/name, creates a missing zero-length data fork, and leaves
// the new empty resource fork closed until HOpenResFile is called.
vfs_resource_files.push(PpcVfsResourceFileRecord {
path,
creator,
file_type,
finder_flags,
resource_len: 0,
raw_data: None,
map_attrs: 0,
dirty: true,
});
*last_resource_error = PPC_NO_ERR;
}
fn ppc_fsp_open_res_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
resource_files: &mut Vec<PpcResourceFileRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
next_file_ref_num: &mut i16,
current_resource_refnum: &mut i16,
last_resource_error: &mut i16,
) -> i16 {
let spec_ptr = cpu.gpr[3];
let _permission = cpu.gpr[4] as u8;
let path = match ppc_path_for_fsspec(memory, vfs_directories, spec_ptr) {
Ok(path) => path,
Err(err) => {
*last_resource_error = err;
return -1;
}
};
let resolved_path = if let Some(index) = ppc_vfs_resource_file_index(vfs_resource_files, &path)
{
vfs_resource_files[index].path.clone()
} else {
path
};
let path = resolved_path;
let data_file_exists = vfs_files
.iter()
.any(|file| file.path.eq_ignore_ascii_case(&path));
if ppc_vfs_resource_file_index(vfs_resource_files, &path).is_none() {
*last_resource_error = if data_file_exists {
PPC_RES_F_NOT_FOUND_ERR
} else {
PPC_FNF_ERR
};
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] FSpOpenResFile path=\"{}\" permission={} -> {}",
path, _permission, *last_resource_error
);
}
return -1;
}
if let Some(existing) = resource_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&path))
{
ppc_set_current_resource_refnum(memory, current_resource_refnum, existing.ref_num);
ppc_rebind_resources_for_path(vfs_resources, &path, existing.ref_num);
*last_resource_error = PPC_NO_ERR;
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] FSpOpenResFile path=\"{}\" permission={} -> ref={} existing",
path, _permission, existing.ref_num
);
}
return existing.ref_num;
}
ppc_materialize_resource_records_for_path(vfs_resource_files, vfs_resources, &path);
ppc_materialize_quilt_resources_for_existing_path(
vfs_files,
vfs_resource_files,
vfs_resources,
&path,
);
let ref_num = *next_file_ref_num;
let Some(next_ref_num) = next_file_ref_num.checked_add(1) else {
*last_resource_error = PPC_PARAM_ERR;
return -1;
};
resource_files.push(PpcResourceFileRecord {
ref_num,
path: path.clone(),
});
ppc_rebind_resources_for_path(vfs_resources, &path, ref_num);
*next_file_ref_num = next_ref_num;
ppc_set_current_resource_refnum(memory, current_resource_refnum, ref_num);
*last_resource_error = PPC_NO_ERR;
if ppc_hle_trace_enabled() {
let matching_resources = vfs_resources
.iter()
.filter(|resource| resource.path.eq_ignore_ascii_case(&path))
.collect::<Vec<_>>();
eprintln!(
"[PPC-TRACE] FSpOpenResFile path=\"{}\" permission={} -> ref={} resources={}",
path,
_permission,
ref_num,
matching_resources.len()
);
for resource in matching_resources {
eprintln!(
"[PPC-TRACE] resource '{}' id={} size={} attrs=${:02X} raw_size={}",
ppc_res_type_text(resource.res_type),
resource.res_id,
resource.data.len(),
resource.attrs,
resource.raw_data.as_ref().map_or(0, Vec::len)
);
}
}
ref_num
}
pub(super) fn ppc_open_res_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_files: &mut ProcessVfsFileRecords,
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
resource_files: &mut Vec<PpcResourceFileRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
next_file_ref_num: &mut i16,
current_resource_refnum: &mut i16,
last_resource_error: &mut i16,
launched_app_path: Option<&str>,
) -> i16 {
let name_ptr = cpu.gpr[3];
let Some(name_bytes) = ppc_read_pstring_bytes(memory, name_ptr) else {
*last_resource_error = PPC_PARAM_ERR;
return -1;
};
let normalized_name = ppc_normalize_vfs_path(&decode_mac_roman(&name_bytes));
if normalized_name.is_empty() {
*last_resource_error = PPC_PARAM_ERR;
return -1;
}
let path = if normalized_name.contains('/') {
ppc_vfs_file_or_resource_path_by_suffix(vfs_files, vfs_resource_files, &normalized_name)
.or_else(|| {
ppc_vfs_file_or_resource_path_by_parent_basename(
vfs_files,
vfs_resource_files,
&normalized_name,
)
})
.unwrap_or(normalized_name)
} else {
ppc_vfs_file_or_resource_path_by_suffix_or_unique_basename(
vfs_files,
vfs_resource_files,
&normalized_name,
)
.or_else(|| {
ppc_vfs_file_or_resource_path_by_nearest_basename(
vfs_files,
vfs_resource_files,
&normalized_name,
launched_app_path,
)
})
.unwrap_or(normalized_name)
};
ppc_open_resource_path(
memory,
vfs_files,
vfs_resource_files,
resource_files,
vfs_resources,
next_file_ref_num,
current_resource_refnum,
last_resource_error,
path,
true,
"OpenResFile",
)
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_h_open_res_file(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
resource_files: &mut Vec<PpcResourceFileRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
next_file_ref_num: &mut i16,
current_resource_refnum: &mut i16,
last_resource_error: &mut i16,
default_dir_id: u32,
) -> i16 {
// Inside Macintosh: More Macintosh Toolbox (1993), pp. 1-62--1-64:
// HOpenResFile identifies the resource fork by volume, directory ID, and
// Pascal file name, returning -1 with the error available via ResError.
let vref = cpu.gpr[3] as u16 as i16;
if !matches!(vref, 0 | PPC_BOOT_VOLUME_REF_NUM) {
*last_resource_error = PPC_NSV_ERR;
return -1;
}
let Some(name_bytes) = ppc_read_pstring_bytes(memory, cpu.gpr[5]) else {
*last_resource_error = PPC_PARAM_ERR;
return -1;
};
let name = ppc_normalize_vfs_path(&decode_mac_roman(&name_bytes));
if name.is_empty() {
*last_resource_error = PPC_PARAM_ERR;
return -1;
}
let dir_id = ppc_resolve_directory_id(vref, cpu.gpr[4], default_dir_id);
let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, dir_id) else {
*last_resource_error = PPC_DIR_NF_ERR;
return -1;
};
let requested_path = ppc_join_vfs_path(parent_path, &name);
let path = ppc_vfs_file_or_resource_path(vfs_files, vfs_resource_files, &requested_path)
.unwrap_or(requested_path);
ppc_open_resource_path(
memory,
vfs_files,
vfs_resource_files,
resource_files,
vfs_resources,
next_file_ref_num,
current_resource_refnum,
last_resource_error,
path,
false,
"HOpenResFile",
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_open_resource_path(
memory: &mut PpcSectionMem,
vfs_files: &mut ProcessVfsFileRecords,
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
resource_files: &mut Vec<PpcResourceFileRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
next_file_ref_num: &mut i16,
current_resource_refnum: &mut i16,
last_resource_error: &mut i16,
path: String,
make_existing_current: bool,
trace_name: &str,
) -> i16 {
let resolved_path = if let Some(index) = ppc_vfs_resource_file_index(vfs_resource_files, &path)
{
vfs_resource_files[index].path.clone()
} else {
path
};
let path = resolved_path;
let data_file_exists = vfs_files
.iter()
.any(|file| file.path.eq_ignore_ascii_case(&path));
if ppc_vfs_resource_file_index(vfs_resource_files, &path).is_none() {
if !data_file_exists
&& ppc_materialize_unique_named_resource_file(
vfs_files,
vfs_resource_files,
vfs_resources,
&path,
)
{
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] {} path=\"{}\" materialized named resource",
trace_name, path
);
}
} else {
*last_resource_error = if data_file_exists {
PPC_RES_F_NOT_FOUND_ERR
} else {
PPC_FNF_ERR
};
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] {} path=\"{}\" -> {}",
trace_name, path, *last_resource_error
);
}
return -1;
}
}
if let Some(existing) = resource_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&path))
{
if make_existing_current {
ppc_set_current_resource_refnum(memory, current_resource_refnum, existing.ref_num);
}
ppc_rebind_resources_for_path(vfs_resources, &path, existing.ref_num);
*last_resource_error = PPC_NO_ERR;
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] {} path=\"{}\" -> ref={} existing",
trace_name, path, existing.ref_num
);
}
return existing.ref_num;
}
ppc_materialize_resource_records_for_path(vfs_resource_files, vfs_resources, &path);
ppc_materialize_quilt_resources_for_existing_path(
vfs_files,
vfs_resource_files,
vfs_resources,
&path,
);
let ref_num = *next_file_ref_num;
let Some(next_ref_num) = next_file_ref_num.checked_add(1) else {
*last_resource_error = PPC_PARAM_ERR;
return -1;
};
resource_files.push(PpcResourceFileRecord {
ref_num,
path: path.clone(),
});
ppc_rebind_resources_for_path(vfs_resources, &path, ref_num);
*next_file_ref_num = next_ref_num;
ppc_set_current_resource_refnum(memory, current_resource_refnum, ref_num);
*last_resource_error = PPC_NO_ERR;
if ppc_hle_trace_enabled() {
let resource_count = vfs_resources
.iter()
.filter(|resource| resource.path.eq_ignore_ascii_case(&path))
.count();
eprintln!(
"[PPC-TRACE] {} path=\"{}\" -> ref={} resources={}",
trace_name, path, ref_num, resource_count
);
}
ref_num
}
pub(super) fn ppc_close_res_file(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
resource_files: &mut Vec<PpcResourceFileRecord>,
vfs_resource_files: &mut [PpcVfsResourceFileRecord],
vfs_resources: &mut [PpcVfsResourceRecord],
current_resource_refnum: &mut i16,
last_resource_error: &mut i16,
) {
let ref_num = cpu.gpr[3] as u16 as i16;
ppc_update_res_file(
cpu,
memory,
handles,
resource_files,
vfs_resource_files,
vfs_resources,
*current_resource_refnum,
last_resource_error,
);
if *last_resource_error != PPC_NO_ERR {
return;
}
// Inside Macintosh, Volume I (1985), p. I-115: CloseResFile updates the
// file, then calls ReleaseResource for every resource in that file.
// Detached resources have no associated record handle and remain owned by
// the application.
let resource_handles: Vec<u32> = vfs_resources
.iter()
.filter(|resource| resource.ref_num == ref_num && resource.handle != 0)
.map(|resource| resource.handle)
.collect();
for handle in resource_handles {
let _ = ppc_dispose_process_native_handle(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
);
}
resource_files.retain(|file| file.ref_num != ref_num);
for resource in vfs_resources
.iter_mut()
.filter(|resource| resource.ref_num == ref_num)
{
resource.handle = 0;
resource.ref_num = PPC_CLOSED_RESOURCE_REF_NUM;
}
if ref_num == *current_resource_refnum {
let replacement = resource_files
.last()
.map(|file| file.ref_num)
.unwrap_or_default();
ppc_set_current_resource_refnum(memory, current_resource_refnum, replacement);
}
*last_resource_error = PPC_NO_ERR;
}
fn ppc_get_eof(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
files: &[PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
) -> i16 {
let ref_num = ppc_ref_num_from_gpr(cpu.gpr[3]);
let eof_out_ptr = cpu.gpr[4];
let Some(file) = files.iter().find(|file| file.ref_num == ref_num) else {
return PPC_RF_NUM_ERR;
};
let eof = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&file.path))
.map(|record| u32::try_from(record.data.len()).unwrap_or(u32::MAX))
.unwrap_or(0);
if eof_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, eof_out_ptr, 4) {
PPC_PARAM_ERR
} else {
let _ = memory.write_u32_be(eof_out_ptr, eof);
PPC_NO_ERR
}
}
fn ppc_alloc_contig(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
files: &[PpcFileRecord],
writable_refnums: &HashSet<u16>,
) -> i16 {
// Files (1992), pp. 2-119--2-120: AllocContig reserves physical file
// blocks without changing logical EOF. The virtual filesystem has no
// physical allocation map, so a valid open fork can satisfy the request.
let ref_num = ppc_ref_num_from_gpr(cpu.gpr[3]);
let count_ptr = cpu.gpr[4];
if !files.iter().any(|file| file.ref_num == ref_num) {
return PPC_RF_NUM_ERR;
}
if !writable_refnums.contains(&(ref_num as u16)) {
return PPC_WR_PERM_ERR;
}
if count_ptr == 0 || !ppc_memory_can_write_bytes(memory, count_ptr, 4) {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_set_eof(
cpu: &mut PpcCpu,
files: &mut [PpcFileRecord],
writable_refnums: &HashSet<u16>,
vfs_files: &mut [PpcVfsFileRecord],
) -> i16 {
let ref_num = ppc_ref_num_from_gpr(cpu.gpr[3]);
let new_eof = cpu.gpr[4];
let Some(path) = files
.iter()
.find(|file| file.ref_num == ref_num)
.map(|file| file.path.clone())
else {
return PPC_RF_NUM_ERR;
};
if !writable_refnums.contains(&(ref_num as u16)) {
return PPC_WR_PERM_ERR;
}
let Some(vfs_file) = vfs_files
.iter_mut()
.find(|record| record.path.eq_ignore_ascii_case(&path))
else {
return PPC_FNF_ERR;
};
let Ok(new_len) = usize::try_from(new_eof) else {
return PPC_PARAM_ERR;
};
vfs_file.data.with_mut(|data| data.resize(new_len, 0));
vfs_file.dirty = true;
for file in files
.iter_mut()
.filter(|file| file.path.eq_ignore_ascii_case(&path))
{
if file.position > new_eof {
file.position = new_eof;
}
}
PPC_NO_ERR
}
fn ppc_get_fpos(cpu: &mut PpcCpu, memory: &mut PpcSectionMem, files: &[PpcFileRecord]) -> i16 {
let ref_num = ppc_ref_num_from_gpr(cpu.gpr[3]);
let pos_out_ptr = cpu.gpr[4];
let Some(file) = files.iter().find(|file| file.ref_num == ref_num) else {
return PPC_RF_NUM_ERR;
};
if pos_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, pos_out_ptr, 4) {
PPC_PARAM_ERR
} else {
let _ = memory.write_u32_be(pos_out_ptr, file.position);
PPC_NO_ERR
}
}
fn ppc_set_fpos(
cpu: &mut PpcCpu,
files: &mut [PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
) -> i16 {
let ref_num = ppc_ref_num_from_gpr(cpu.gpr[3]);
let pos_mode = cpu.gpr[4] as u16;
let pos_offset = cpu.gpr[5] as i32 as i64;
let Some(file) = files.iter_mut().find(|file| file.ref_num == ref_num) else {
return PPC_RF_NUM_ERR;
};
let eof = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&file.path))
.map_or(0i64, |record| {
i64::try_from(record.data.len()).unwrap_or(i64::MAX)
});
let current = i64::from(file.position);
let new_pos = match pos_mode {
0 => current,
1 => pos_offset,
2 => eof.saturating_add(pos_offset),
3 => current.saturating_add(pos_offset),
_ => return PPC_PARAM_ERR,
};
let Ok(new_pos) = u32::try_from(new_pos) else {
return PPC_PARAM_ERR;
};
file.position = new_pos;
PPC_NO_ERR
}
fn ppc_fs_read(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
files: &mut [PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
) -> i16 {
let ref_num = ppc_ref_num_from_gpr(cpu.gpr[3]);
let count_ptr = cpu.gpr[4];
let buffer_ptr = cpu.gpr[5];
if count_ptr == 0 || !ppc_memory_can_write_bytes(memory, count_ptr, 4) {
return PPC_PARAM_ERR;
}
let Some(requested_count) = memory.read_u32_be(count_ptr) else {
return PPC_PARAM_ERR;
};
let Some(file) = files.iter_mut().find(|file| file.ref_num == ref_num) else {
return PPC_PARAM_ERR;
};
if requested_count > 0 && buffer_ptr == 0 {
return PPC_PARAM_ERR;
}
let Some(vfs_file) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&file.path))
else {
return PPC_FNF_ERR;
};
let start = usize::try_from(file.position)
.unwrap_or(usize::MAX)
.min(vfs_file.data.len());
let requested_len = usize::try_from(requested_count).unwrap_or(usize::MAX);
let available = vfs_file.data.len().saturating_sub(start);
let read_len = requested_len.min(available);
if read_len > 0
&& !ppc_memory_can_write_bytes(
memory,
buffer_ptr,
u32::try_from(read_len).unwrap_or(u32::MAX),
)
{
return PPC_PARAM_ERR;
}
for (offset, byte) in vfs_file.data[start..start + read_len]
.iter()
.copied()
.enumerate()
{
let Ok(offset) = u32::try_from(offset) else {
return PPC_PARAM_ERR;
};
if memory.write_u8(buffer_ptr + offset, byte).is_none() {
return PPC_PARAM_ERR;
};
}
let read_count = u32::try_from(read_len).unwrap_or(u32::MAX);
file.position = file.position.saturating_add(read_count);
let _ = memory.write_u32_be(count_ptr, read_count);
if read_count < requested_count {
PPC_EOF_ERR
} else {
PPC_NO_ERR
}
}
fn ppc_fs_write(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
files: &mut [PpcFileRecord],
writable_refnums: &HashSet<u16>,
vfs_files: &mut Vec<PpcVfsFileRecord>,
) -> i16 {
let ref_num = ppc_ref_num_from_gpr(cpu.gpr[3]);
let count_ptr = cpu.gpr[4];
let buffer_ptr = cpu.gpr[5];
if count_ptr == 0 || !ppc_memory_can_write_bytes(memory, count_ptr, 4) {
return PPC_PARAM_ERR;
}
let Some(requested_count) = memory.read_u32_be(count_ptr) else {
return PPC_PARAM_ERR;
};
let Some(file) = files.iter_mut().find(|file| file.ref_num == ref_num) else {
return PPC_RF_NUM_ERR;
};
if requested_count > 0 && buffer_ptr == 0 {
return PPC_PARAM_ERR;
}
if requested_count > 0 && !ppc_memory_can_read_bytes(memory, buffer_ptr, requested_count) {
return PPC_PARAM_ERR;
}
if !writable_refnums.contains(&(ref_num as u16)) {
return PPC_WR_PERM_ERR;
}
let Some(vfs_file) = ppc_vfs_file_mut(vfs_files, &file.path) else {
return PPC_FNF_ERR;
};
let Ok(start) = usize::try_from(file.position) else {
return PPC_PARAM_ERR;
};
let Ok(requested_len) = usize::try_from(requested_count) else {
return PPC_PARAM_ERR;
};
let Some(end) = start.checked_add(requested_len) else {
return PPC_PARAM_ERR;
};
let bytes = ppc_memory_read_bytes(memory, buffer_ptr, requested_count).unwrap_or_default();
vfs_file.data.with_mut(|data| {
if start > data.len() {
data.resize(start, 0);
}
if end > data.len() {
data.resize(end, 0);
}
data[start..end].copy_from_slice(&bytes);
});
vfs_file.dirty = true;
file.position = file.position.saturating_add(requested_count);
let _ = memory.write_u32_be(count_ptr, requested_count);
PPC_NO_ERR
}
fn ppc_fsp_create(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
) -> i16 {
let spec_ptr = cpu.gpr[3];
let creator = cpu.gpr[4];
let file_type = cpu.gpr[5];
let path = match ppc_path_for_fsspec(memory, vfs_directories, spec_ptr) {
Ok(path) => path,
Err(err) => return err,
};
if ppc_vfs_file_index(vfs_files, &path).is_some() {
return PPC_DUP_FN_ERR;
}
vfs_files.push(PpcVfsFileRecord {
path,
data: Vec::new().into(),
creator,
file_type,
finder_flags: 0,
dirty: true,
});
PPC_NO_ERR
}
fn ppc_h_create(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
default_dir_id: u32,
) -> i16 {
// Inside Macintosh: Files (1992), 2-169: HCreate identifies the parent
// with a volume reference and directory ID, then supplies creator/type.
ppc_create_data_fork_by_name(
memory,
vfs_directories,
vfs_files,
default_dir_id,
cpu.gpr[3] as u16 as i16,
cpu.gpr[4],
cpu.gpr[5],
cpu.gpr[6],
cpu.gpr[7],
)
}
fn ppc_pb_create(
operation: PpcParameterBlockCreateOperation,
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
default_dir_id: u32,
) -> i16 {
let pb = cpu.gpr[3];
if pb == 0 || !ppc_memory_can_write_bytes(memory, pb, 24) {
return PPC_PARAM_ERR;
}
let Some(name_ptr) = memory.read_u32_be(pb + 18) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let Some(vref) = memory.read_u16_be(pb + 22).map(|value| value as i16) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let hierarchical = matches!(operation, PpcParameterBlockCreateOperation::Hierarchical);
let dir_id = if hierarchical {
let Some(dir_id) = memory.read_u32_be(pb + 48) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
dir_id
} else {
0
};
// Inside Macintosh: Files (1992), 2-186 through 2-187: PBHCreate
// creates closed, empty data and resource forks in ioDirID.
let result = ppc_create_data_fork_by_name(
memory,
vfs_directories,
vfs_files,
default_dir_id,
vref,
dir_id,
name_ptr,
0,
0,
);
ppc_complete_pb(memory, pb, result)
}
fn ppc_create(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
default_dir_id: u32,
) -> i16 {
// The non-hierarchical Create call resolves against the current directory.
ppc_create_data_fork_by_name(
memory,
vfs_directories,
vfs_files,
default_dir_id,
cpu.gpr[4] as u16 as i16,
0,
cpu.gpr[3],
cpu.gpr[5],
cpu.gpr[6],
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_create_data_fork_by_name(
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
default_dir_id: u32,
vref: i16,
dir_id: u32,
name_ptr: u32,
creator: u32,
file_type: u32,
) -> i16 {
if !matches!(vref, 0 | PPC_BOOT_VOLUME_REF_NUM) {
return PPC_NSV_ERR;
}
let Some(name_bytes) = ppc_read_pstring_bytes(memory, name_ptr) else {
return PPC_PARAM_ERR;
};
let name = ppc_normalize_vfs_path(&decode_mac_roman(&name_bytes));
if name.is_empty() {
return PPC_PARAM_ERR;
}
let effective_dir_id = ppc_resolve_directory_id(vref, dir_id, default_dir_id);
let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, effective_dir_id) else {
return PPC_DIR_NF_ERR;
};
let path = ppc_join_vfs_path(parent_path, &name);
if ppc_vfs_file_index(vfs_files, &path).is_some() {
return PPC_DUP_FN_ERR;
}
vfs_files.push(PpcVfsFileRecord {
path,
data: Vec::new().into(),
creator,
file_type,
finder_flags: 0,
dirty: true,
});
PPC_NO_ERR
}
fn ppc_fsp_delete(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
deleted_vfs_file_paths: &mut Vec<String>,
files: &mut Vec<PpcFileRecord>,
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
resource_files: &mut Vec<PpcResourceFileRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
) -> i16 {
let spec_ptr = cpu.gpr[3];
let path = match ppc_path_for_fsspec(memory, vfs_directories, spec_ptr) {
Ok(path) => path,
Err(err) => return err,
};
ppc_delete_vfs_path(
&path,
vfs_files,
deleted_vfs_file_paths,
files,
vfs_resource_files,
resource_files,
vfs_resources,
)
}
#[allow(clippy::too_many_arguments)]
fn ppc_delete_by_name(
operation: PpcDeleteByNameOperation,
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &mut ProcessVfsFileRecords,
deleted_vfs_file_paths: &mut Vec<String>,
files: &mut Vec<PpcFileRecord>,
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
resource_files: &mut Vec<PpcResourceFileRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
default_dir_id: u32,
) -> i16 {
let (vref, dir_id, name_ptr, pb) = if matches!(
operation,
PpcDeleteByNameOperation::LegacyParameterBlock
| PpcDeleteByNameOperation::HierarchicalParameterBlock
) {
let pb = cpu.gpr[3];
if pb == 0 || !ppc_memory_can_write_bytes(memory, pb, 24) {
return PPC_PARAM_ERR;
}
let Some(name_ptr) = memory.read_u32_be(pb + 18) else {
return PPC_PARAM_ERR;
};
let Some(vref) = memory.read_u16_be(pb + 22).map(|value| value as i16) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
let hierarchical = matches!(
operation,
PpcDeleteByNameOperation::HierarchicalParameterBlock
);
let dir_id = if hierarchical {
let Some(dir_id) = memory.read_u32_be(pb + 48) else {
return ppc_complete_pb(memory, pb, PPC_PARAM_ERR);
};
dir_id
} else {
0
};
(vref, dir_id, name_ptr, Some(pb))
} else if matches!(operation, PpcDeleteByNameOperation::HierarchicalHighLevel) {
(cpu.gpr[3] as u16 as i16, cpu.gpr[4], cpu.gpr[5], None)
} else {
(cpu.gpr[4] as u16 as i16, 0, cpu.gpr[3], None)
};
// Inside Macintosh: Files (1992), 2-102 and 2-189: PBDelete/PBHDelete
// identify both forks by name; HDelete's high-level ABI is on 2-173.
let result = if !matches!(vref, 0 | PPC_BOOT_VOLUME_REF_NUM) {
PPC_NSV_ERR
} else if let Some(name_bytes) = ppc_read_pstring_bytes(memory, name_ptr) {
let name = ppc_normalize_vfs_path(&decode_mac_roman(&name_bytes));
if name.is_empty() {
PPC_PARAM_ERR
} else {
let effective_dir_id = ppc_resolve_directory_id(vref, dir_id, default_dir_id);
if let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, effective_dir_id)
{
let requested_path = ppc_join_vfs_path(parent_path, &name);
let path =
ppc_vfs_file_or_resource_path(vfs_files, vfs_resource_files, &requested_path)
.or_else(|| {
ppc_vfs_file_or_resource_path_by_basename(
vfs_files,
vfs_resource_files,
&name,
)
});
if let Some(path) = path {
ppc_delete_vfs_path(
&path,
vfs_files,
deleted_vfs_file_paths,
files,
vfs_resource_files,
resource_files,
vfs_resources,
)
} else {
PPC_FNF_ERR
}
} else {
PPC_DIR_NF_ERR
}
}
} else {
PPC_PARAM_ERR
};
pb.map_or(result, |pb| ppc_complete_pb(memory, pb, result))
}
fn ppc_delete_vfs_path(
path: &str,
vfs_files: &mut ProcessVfsFileRecords,
deleted_vfs_file_paths: &mut Vec<String>,
files: &mut Vec<PpcFileRecord>,
vfs_resource_files: &mut ProcessVfsResourceFileRecords,
resource_files: &mut Vec<PpcResourceFileRecord>,
vfs_resources: &mut Vec<PpcVfsResourceRecord>,
) -> i16 {
let existed = vfs_files
.iter()
.any(|file| file.path.eq_ignore_ascii_case(path))
|| vfs_resource_files
.iter()
.any(|file| file.path.eq_ignore_ascii_case(path))
|| vfs_resources
.iter()
.any(|resource| resource.path.eq_ignore_ascii_case(path));
if !existed {
return PPC_FNF_ERR;
}
vfs_files.retain(|file| !file.path.eq_ignore_ascii_case(path));
if !deleted_vfs_file_paths
.iter()
.any(|deleted| deleted.eq_ignore_ascii_case(&path))
{
deleted_vfs_file_paths.push(path.to_string());
}
files.retain(|file| !file.path.eq_ignore_ascii_case(&path));
vfs_resource_files.retain(|file| !file.path.eq_ignore_ascii_case(&path));
resource_files.retain(|file| !file.path.eq_ignore_ascii_case(&path));
vfs_resources.retain(|resource| !resource.path.eq_ignore_ascii_case(&path));
PPC_NO_ERR
}
fn ppc_ref_num_from_gpr(value: u32) -> i16 {
value as u16 as i16
}
pub(super) fn ppc_block_move(cpu: &mut PpcCpu, memory: &mut PpcSectionMem) {
let source_ptr = cpu.gpr[3];
let dest_ptr = cpu.gpr[4];
let byte_count = cpu.gpr[5] as usize;
let mut bytes = vec![0; byte_count];
if memory.read_bytes_into(source_ptr, &mut bytes).is_none() {
return;
}
let mut pixels = crate::memory::SavedPixels::from(bytes);
let presentation = memory.presentation();
presentation.capture_detail(&mut pixels, 0, source_ptr, byte_count);
if memory.write_bytes(dest_ptr, &pixels).is_some() {
presentation.restore_detail(&pixels, 0, dest_ptr, byte_count);
}
}
#[cfg(test)]
fn ppc_hand_to_hand(
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
handles: &mut Vec<PpcHandleRecord>,
free_handle_blocks: &mut Vec<PpcHandleRecord>,
) -> i16 {
let handle_variable = cpu.gpr[3];
if handle_variable == 0 || !ppc_memory_can_write_bytes(memory, handle_variable, 4) {
return PPC_PARAM_ERR;
}
let Some(source_handle) = memory.read_u32_be(handle_variable) else {
return PPC_PARAM_ERR;
};
let Some(source) = handles
.iter()
.find(|record| record.handle == source_handle)
.copied()
.or_else(|| ppc_system_handle_record(memory, source_handle))
else {
return PPC_NIL_HANDLE_ERR;
};
let Some(bytes) = ppc_memory_read_bytes(memory, source.ptr, source.size) else {
return PPC_PARAM_ERR;
};
let copy = ppc_alloc_recyclable_handle_with_bytes(
memory,
heap_cursor,
heap_limit,
handles,
free_handle_blocks,
&bytes,
);
if copy == 0 {
return PPC_MEM_FULL_ERR;
}
// Inside Macintosh: Memory (1992), pp. 2-62--2-63: HandToHand replaces
// the caller's Handle variable with an unlocked, unpurgeable data copy.
if memory.write_u32_be(handle_variable, copy).is_none() {
return PPC_PARAM_ERR;
}
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] HandToHand variable=${handle_variable:08X} source=${source_handle:08X} size={} -> ${copy:08X}",
source.size
);
}
PPC_NO_ERR
}
pub(super) fn ppc_system_handle_record(memory: &mut PpcSectionMem, handle: u32) -> Option<PpcHandleRecord> {
// Inside Macintosh: Imaging With QuickDraw (1994), pp. 4-47 and 4-83:
// a GDevice's indexed PixMap owns its ColorTable through a Handle. The
// main device is Toolbox-owned rather than application-heap-owned, but
// Memory Manager routines such as HandToHand must still accept it.
let size = match handle {
PPC_MAIN_CTABLE_HANDLE => PPC_MAIN_CTABLE_SIZE,
_ => return None,
};
let ptr = memory.read_u32_be(handle)?;
ppc_memory_read_bytes(memory, ptr, size)?;
Some(PpcHandleRecord {
handle,
ptr,
size,
capacity: size,
})
}
fn initial_ppc_vfs_directories() -> Vec<PpcVfsDirectory> {
vec![
PpcVfsDirectory {
dir_id: PPC_ROOT_DIR_ID,
parent_dir_id: 1,
path: String::new(),
creator: PPC_DIRECTORY_CREATOR,
file_type: PPC_DIRECTORY_FILE_TYPE,
finder_flags: 0,
dirty: false,
},
PpcVfsDirectory {
dir_id: PPC_SYSTEM_FOLDER_DIR_ID,
parent_dir_id: PPC_ROOT_DIR_ID,
path: "System Folder".to_string(),
creator: PPC_DIRECTORY_CREATOR,
file_type: PPC_DIRECTORY_FILE_TYPE,
finder_flags: 0,
dirty: false,
},
PpcVfsDirectory {
dir_id: PPC_PREFERENCES_DIR_ID,
parent_dir_id: PPC_SYSTEM_FOLDER_DIR_ID,
path: "System Folder/Preferences".to_string(),
creator: PPC_DIRECTORY_CREATOR,
file_type: PPC_DIRECTORY_FILE_TYPE,
finder_flags: 0,
dirty: false,
},
]
}
pub(super) fn ppc_dir_create(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &mut Vec<PpcVfsDirectory>,
next_vfs_dir_id: &mut u32,
default_dir_id: u32,
) -> i16 {
let vref = cpu.gpr[3] as u16 as i16;
let parent_dir_id = ppc_resolve_directory_id(vref, cpu.gpr[4], default_dir_id);
let directory_name_ptr = cpu.gpr[5];
let created_dir_id_ptr = cpu.gpr[6];
if directory_name_ptr == 0 || created_dir_id_ptr == 0 {
return PPC_PARAM_ERR;
}
let Some(directory_name) = ppc_read_pstring(memory, directory_name_ptr) else {
return PPC_PARAM_ERR;
};
let normalized_name = ppc_normalize_vfs_path(&directory_name);
if normalized_name.is_empty() {
return PPC_PARAM_ERR;
}
let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, parent_dir_id) else {
return PPC_FNF_ERR;
};
let path = ppc_join_vfs_path(parent_path, &normalized_name);
if let Some(existing) = ppc_directory_id_for_path(vfs_directories, &path) {
let _ = memory.write_u32_be(created_dir_id_ptr, existing);
return PPC_DUP_FN_ERR;
}
let dir_id = *next_vfs_dir_id;
let Some(next_dir_id) = next_vfs_dir_id.checked_add(1) else {
return PPC_PARAM_ERR;
};
if memory.write_u32_be(created_dir_id_ptr, dir_id).is_none() {
return PPC_PARAM_ERR;
}
*next_vfs_dir_id = next_dir_id;
vfs_directories.push(PpcVfsDirectory {
dir_id,
parent_dir_id,
path,
creator: PPC_DIRECTORY_CREATOR,
file_type: PPC_DIRECTORY_FILE_TYPE,
finder_flags: 0,
dirty: true,
});
PPC_NO_ERR
}
pub(super) fn ppc_fsp_dir_create(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &mut Vec<PpcVfsDirectory>,
next_vfs_dir_id: &mut u32,
default_dir_id: u32,
) -> i16 {
let spec_ptr = cpu.gpr[3];
let created_dir_id_ptr = cpu.gpr[5];
if spec_ptr == 0 || created_dir_id_ptr == 0 {
return PPC_PARAM_ERR;
}
let Some((vref, requested_dir_id, directory_name)) = ppc_read_fsspec_parts(memory, spec_ptr)
else {
return PPC_PARAM_ERR;
};
if directory_name.is_empty() {
return PPC_PARAM_ERR;
}
let parent_dir_id = ppc_resolve_directory_id(vref, requested_dir_id, default_dir_id);
let normalized_name = ppc_normalize_vfs_path(&decode_mac_roman(&directory_name));
if normalized_name.is_empty() {
return PPC_PARAM_ERR;
}
let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, parent_dir_id) else {
return PPC_FNF_ERR;
};
let path = ppc_join_vfs_path(parent_path, &normalized_name);
if let Some(existing) = ppc_directory_id_for_path(vfs_directories, &path) {
let _ = memory.write_u32_be(created_dir_id_ptr, existing);
return PPC_DUP_FN_ERR;
}
let dir_id = *next_vfs_dir_id;
let Some(next_dir_id) = next_vfs_dir_id.checked_add(1) else {
return PPC_PARAM_ERR;
};
if memory.write_u32_be(created_dir_id_ptr, dir_id).is_none() {
return PPC_PARAM_ERR;
}
*next_vfs_dir_id = next_dir_id;
vfs_directories.push(PpcVfsDirectory {
dir_id,
parent_dir_id,
path,
creator: PPC_DIRECTORY_CREATOR,
file_type: PPC_DIRECTORY_FILE_TYPE,
finder_flags: 0,
dirty: true,
});
PPC_NO_ERR
}
pub(super) fn ppc_find_folder_dir_id(folder_type: u32) -> u32 {
if folder_type == u32::from_be_bytes(*b"pref") {
PPC_PREFERENCES_DIR_ID
} else {
PPC_ROOT_DIR_ID
}
}
pub(super) fn ppc_new_alias(
cpu: &mut PpcCpu,
process_memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
aliases: &mut Vec<PpcAliasRecord>,
) -> i16 {
let _from_file_ptr = cpu.gpr[3];
let target_ptr = cpu.gpr[4];
let alias_out_ptr = cpu.gpr[5];
if target_ptr == 0 || alias_out_ptr == 0 {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, alias_out_ptr, 4) {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
};
let Some((target_vref, target_dir_id, target_name)) = ppc_read_fsspec_parts(memory, target_ptr)
else {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
};
let Some(alias_data) = ppc_alias_record_bytes(target_vref, target_dir_id, &target_name) else {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
};
let handle = ppc_process_alloc_handle_with_bytes(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
&alias_data,
);
if handle == 0 {
*last_mem_error = PPC_MEM_FULL_ERR;
return PPC_MEM_FULL_ERR;
}
if memory.write_u32_be(alias_out_ptr, handle).is_none() {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
}
aliases.push(PpcAliasRecord {
handle,
target_vref: target_vref as i16,
target_dir_id,
target_name,
});
*last_mem_error = PPC_NO_ERR;
PPC_NO_ERR
}
fn ppc_write_fsspec_parts(
memory: &mut PpcSectionMem,
spec_ptr: u32,
vref: i16,
dir_id: u32,
name: &[u8],
) -> bool {
if spec_ptr == 0 || name.len() > PPC_FSSPEC_MAX_NAME_LEN {
return false;
}
ppc_write_fsspec(memory, spec_ptr, vref, dir_id, name).is_some()
}
fn ppc_read_fsspec_parts(memory: &mut PpcSectionMem, spec_ptr: u32) -> Option<(i16, u32, Vec<u8>)> {
if spec_ptr == 0 {
return None;
}
let vref = memory.read_u16_be(spec_ptr)? as i16;
let dir_id = memory.read_u32_be(spec_ptr + 2)?;
let name_len = usize::from(memory.read_u8(spec_ptr + 6)?);
if name_len > PPC_FSSPEC_MAX_NAME_LEN {
return None;
}
let mut name = Vec::with_capacity(name_len);
for offset in 0..name_len {
name.push(memory.read_u8(spec_ptr.checked_add(7 + offset as u32)?)?);
}
Some((vref, dir_id, name))
}
fn ppc_alias_record_bytes(vref: i16, dir_id: u32, name: &[u8]) -> Option<Vec<u8>> {
if name.len() > PPC_FSSPEC_MAX_NAME_LEN {
return None;
}
let mut bytes = vec![0; PPC_CLASSIC_ALIAS_RECORD_SIZE];
bytes[4..6].copy_from_slice(&(PPC_CLASSIC_ALIAS_RECORD_SIZE as u16).to_be_bytes());
bytes[6..8].copy_from_slice(&PPC_CLASSIC_ALIAS_RECORD_VERSION.to_be_bytes());
ppc_write_alias_pstring(
&mut bytes,
PPC_CLASSIC_ALIAS_VOLUME_NAME_OFFSET,
27,
b"Systemless",
)?;
ppc_write_alias_pstring(&mut bytes, PPC_CLASSIC_ALIAS_FILE_NAME_OFFSET, 63, name)?;
bytes[PPC_CLASSIC_ALIAS_DIR_ID_OFFSET..PPC_CLASSIC_ALIAS_DIR_ID_OFFSET + 4]
.copy_from_slice(&dir_id.to_be_bytes());
let mystery_words = PPC_CLASSIC_ALIAS_MYSTERY_WORDS_OFFSET;
bytes[mystery_words..mystery_words + 2].copy_from_slice(&0xffffu16.to_be_bytes());
bytes[mystery_words + 2..mystery_words + 4].copy_from_slice(&0xffffu16.to_be_bytes());
bytes[mystery_words + 6..mystery_words + 8].copy_from_slice(&17u16.to_be_bytes());
let tail = PPC_CLASSIC_ALIAS_RECORD_HEADER_SIZE;
bytes[tail..tail + 2].copy_from_slice(&PPC_CLASSIC_ALIAS_TAIL_TAG.to_be_bytes());
bytes[tail + 2..tail + 4]
.copy_from_slice(&(PPC_CLASSIC_ALIAS_TAIL_PAYLOAD_SIZE as u16).to_be_bytes());
ppc_fill_classic_alias_tail_payload(
&mut bytes[tail + 4..tail + 4 + PPC_CLASSIC_ALIAS_TAIL_PAYLOAD_SIZE],
);
let end = tail + 4 + PPC_CLASSIC_ALIAS_TAIL_PAYLOAD_SIZE;
bytes[end..end + 2].copy_from_slice(&PPC_CLASSIC_ALIAS_END_TAG.to_be_bytes());
// Classic AliasRecords are volume/name based. The in-memory side table
// preserves the exact vRefNum for handles created during this run; decoded
// archive-style records resolve to the boot volume.
let _ = vref;
Some(bytes)
}
#[cfg(test)]
fn ppc_legacy_alias_record_bytes(vref: i16, dir_id: u32, name: &[u8]) -> Option<Vec<u8>> {
if name.len() > PPC_FSSPEC_MAX_NAME_LEN {
return None;
}
let mut bytes = vec![0; PPC_ALIAS_RECORD_SIZE];
bytes[0..4].copy_from_slice(&PPC_ALIAS_RECORD_MAGIC.to_be_bytes());
bytes[4..6].copy_from_slice(&(PPC_ALIAS_RECORD_SIZE as u16).to_be_bytes());
bytes[6..8].copy_from_slice(&PPC_ALIAS_RECORD_VERSION.to_be_bytes());
bytes[8..10].copy_from_slice(&(PPC_ALIAS_RECORD_FSSPEC_OFFSET as u16).to_be_bytes());
bytes[10..12].copy_from_slice(&(PPC_FSSPEC_SIZE as u16).to_be_bytes());
let fsspec = PPC_ALIAS_RECORD_FSSPEC_OFFSET;
bytes[fsspec..fsspec + 2].copy_from_slice(&(vref as u16).to_be_bytes());
bytes[fsspec + 2..fsspec + 6].copy_from_slice(&dir_id.to_be_bytes());
bytes[fsspec + 6] = name.len() as u8;
bytes[fsspec + 7..fsspec + 7 + name.len()].copy_from_slice(name);
Some(bytes)
}
fn ppc_write_alias_pstring(
bytes: &mut [u8],
offset: usize,
max_len: usize,
value: &[u8],
) -> Option<()> {
if value.len() > max_len || offset.checked_add(1 + max_len)? > bytes.len() {
return None;
}
bytes[offset] = value.len() as u8;
bytes[offset + 1..offset + 1 + value.len()].copy_from_slice(value);
Some(())
}
fn ppc_fill_classic_alias_tail_payload(payload: &mut [u8]) {
let words = [
(0usize, 0x00a8u16),
(1, 0x6166),
(2, 0x706d),
(5, 0x0003),
(6, 0x0018),
(7, 0x0039),
(8, 0x0059),
(9, 0x0075),
(10, 0x0095),
(11, 0x009e),
];
for (index, value) in words {
let offset = index * 2;
if offset + 2 <= payload.len() {
payload[offset..offset + 2].copy_from_slice(&value.to_be_bytes());
}
}
let zone_offset = 24usize;
if zone_offset + 2 <= payload.len() {
payload[zone_offset] = 1;
payload[zone_offset + 1] = b'*';
}
}
fn ppc_alias_record_from_handle(
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
alias_handle: u32,
vfs_directories: Option<&[PpcVfsDirectory]>,
) -> Option<PpcAliasRecord> {
let handle_record = handles
.iter()
.find(|record| record.handle == alias_handle)?;
let handle_size = usize::try_from(handle_record.size).ok()?;
let data_ptr = memory.read_u32_be(alias_handle)?;
ppc_legacy_alias_record_from_data(memory, alias_handle, data_ptr, handle_size).or_else(|| {
ppc_classic_alias_record_from_data(
memory,
alias_handle,
data_ptr,
handle_size,
vfs_directories,
)
})
}
fn ppc_legacy_alias_record_from_data(
memory: &mut PpcSectionMem,
alias_handle: u32,
data_ptr: u32,
handle_size: usize,
) -> Option<PpcAliasRecord> {
let magic = memory.read_u32_be(data_ptr)?;
if magic != PPC_ALIAS_RECORD_MAGIC {
return None;
}
let record_size = usize::from(memory.read_u16_be(data_ptr + 4)?);
let version = memory.read_u16_be(data_ptr + 6)?;
let fsspec_offset = usize::from(memory.read_u16_be(data_ptr + 8)?);
let fsspec_size = usize::from(memory.read_u16_be(data_ptr + 10)?);
if version != PPC_ALIAS_RECORD_VERSION
|| record_size > handle_size
|| fsspec_size != PPC_FSSPEC_SIZE
|| fsspec_offset.checked_add(PPC_FSSPEC_SIZE)? > record_size
{
return None;
}
let fsspec_ptr = data_ptr.checked_add(u32::try_from(fsspec_offset).ok()?)?;
let (target_vref, target_dir_id, target_name) = ppc_read_fsspec_parts(memory, fsspec_ptr)?;
Some(PpcAliasRecord {
handle: alias_handle,
target_vref,
target_dir_id,
target_name,
})
}
fn ppc_classic_alias_record_from_data(
memory: &mut PpcSectionMem,
alias_handle: u32,
data_ptr: u32,
handle_size: usize,
vfs_directories: Option<&[PpcVfsDirectory]>,
) -> Option<PpcAliasRecord> {
if handle_size < PPC_CLASSIC_ALIAS_RECORD_HEADER_SIZE {
return None;
}
let record_size = usize::from(memory.read_u16_be(data_ptr + 4)?);
let version = memory.read_u16_be(data_ptr + 6)?;
if version != PPC_CLASSIC_ALIAS_RECORD_VERSION
|| record_size < PPC_CLASSIC_ALIAS_RECORD_HEADER_SIZE
|| record_size > handle_size
{
return None;
}
let mut target_dir_id = memory
.read_u32_be(data_ptr.checked_add(u32::try_from(PPC_CLASSIC_ALIAS_DIR_ID_OFFSET).ok()?)?)?;
let mut target_name = ppc_read_fixed_pstring_bytes(
memory,
data_ptr.checked_add(u32::try_from(PPC_CLASSIC_ALIAS_FILE_NAME_OFFSET).ok()?)?,
PPC_FSSPEC_MAX_NAME_LEN,
)?;
if target_dir_id == u32::MAX || target_name.is_empty() {
if let Some((full_path_dir_id, full_path_name)) =
ppc_classic_alias_full_path_target(memory, data_ptr, record_size, vfs_directories)
{
target_dir_id = full_path_dir_id;
target_name = full_path_name;
}
}
if target_dir_id == u32::MAX || target_name.len() > PPC_FSSPEC_MAX_NAME_LEN {
return None;
}
Some(PpcAliasRecord {
handle: alias_handle,
target_vref: PPC_BOOT_VOLUME_REF_NUM,
target_dir_id,
target_name,
})
}
fn ppc_alias_record_from_bytes(
bytes: &[u8],
vfs_directories: Option<&[PpcVfsDirectory]>,
) -> Option<PpcAliasRecord> {
ppc_legacy_alias_record_from_bytes(bytes)
.or_else(|| ppc_classic_alias_record_from_bytes(bytes, vfs_directories))
}
fn ppc_legacy_alias_record_from_bytes(bytes: &[u8]) -> Option<PpcAliasRecord> {
let magic = ppc_slice_u32_be(bytes, 0)?;
if magic != PPC_ALIAS_RECORD_MAGIC {
return None;
}
let record_size = usize::from(ppc_slice_u16_be(bytes, 4)?);
let version = ppc_slice_u16_be(bytes, 6)?;
let fsspec_offset = usize::from(ppc_slice_u16_be(bytes, 8)?);
let fsspec_size = usize::from(ppc_slice_u16_be(bytes, 10)?);
if version != PPC_ALIAS_RECORD_VERSION
|| record_size > bytes.len()
|| fsspec_size != PPC_FSSPEC_SIZE
|| fsspec_offset.checked_add(PPC_FSSPEC_SIZE)? > record_size
{
return None;
}
let target_vref = ppc_slice_u16_be(bytes, fsspec_offset)? as i16;
let target_dir_id = ppc_slice_u32_be(bytes, fsspec_offset + 2)?;
let target_name =
ppc_slice_fixed_pstring_bytes(bytes, fsspec_offset + 6, PPC_FSSPEC_MAX_NAME_LEN)?;
Some(PpcAliasRecord {
handle: 0,
target_vref,
target_dir_id,
target_name,
})
}
fn ppc_classic_alias_record_from_bytes(
bytes: &[u8],
vfs_directories: Option<&[PpcVfsDirectory]>,
) -> Option<PpcAliasRecord> {
if bytes.len() < PPC_CLASSIC_ALIAS_RECORD_HEADER_SIZE {
return None;
}
let record_size = usize::from(ppc_slice_u16_be(bytes, 4)?);
let version = ppc_slice_u16_be(bytes, 6)?;
if version != PPC_CLASSIC_ALIAS_RECORD_VERSION
|| record_size < PPC_CLASSIC_ALIAS_RECORD_HEADER_SIZE
|| record_size > bytes.len()
{
return None;
}
let mut target_dir_id = ppc_slice_u32_be(bytes, PPC_CLASSIC_ALIAS_DIR_ID_OFFSET)?;
let mut target_name = ppc_slice_fixed_pstring_bytes(
bytes,
PPC_CLASSIC_ALIAS_FILE_NAME_OFFSET,
PPC_FSSPEC_MAX_NAME_LEN,
)?;
if target_dir_id == u32::MAX || target_name.is_empty() {
if let Some((full_path_dir_id, full_path_name)) =
ppc_classic_alias_full_path_target_from_bytes(bytes, record_size, vfs_directories)
{
target_dir_id = full_path_dir_id;
target_name = full_path_name;
}
}
if target_dir_id == u32::MAX || target_name.len() > PPC_FSSPEC_MAX_NAME_LEN {
return None;
}
Some(PpcAliasRecord {
handle: 0,
target_vref: PPC_BOOT_VOLUME_REF_NUM,
target_dir_id,
target_name,
})
}
fn ppc_classic_alias_full_path_target_from_bytes(
bytes: &[u8],
record_size: usize,
vfs_directories: Option<&[PpcVfsDirectory]>,
) -> Option<(u32, Vec<u8>)> {
let mut offset = PPC_CLASSIC_ALIAS_RECORD_HEADER_SIZE;
while offset.checked_add(4)? <= record_size {
let tag = ppc_slice_u16_be(bytes, offset)?;
if tag == PPC_CLASSIC_ALIAS_END_TAG {
return None;
}
let len = usize::from(ppc_slice_u16_be(bytes, offset + 2)?);
let payload_offset = offset.checked_add(4)?;
let payload_end = payload_offset.checked_add(len)?;
if payload_end > record_size {
return None;
}
if tag == PPC_CLASSIC_ALIAS_FULL_PATH_TAG {
return ppc_classic_alias_target_from_full_path(
bytes.get(payload_offset..payload_end)?,
vfs_directories,
);
}
offset = payload_offset.checked_add((len + 1) & !1)?;
}
None
}
fn ppc_slice_u16_be(bytes: &[u8], offset: usize) -> Option<u16> {
Some(u16::from_be_bytes(
bytes.get(offset..offset.checked_add(2)?)?.try_into().ok()?,
))
}
fn ppc_slice_u32_be(bytes: &[u8], offset: usize) -> Option<u32> {
Some(u32::from_be_bytes(
bytes.get(offset..offset.checked_add(4)?)?.try_into().ok()?,
))
}
fn ppc_slice_fixed_pstring_bytes(bytes: &[u8], offset: usize, max_len: usize) -> Option<Vec<u8>> {
let len = usize::from(*bytes.get(offset)?);
if len > max_len {
return None;
}
Some(
bytes
.get(offset + 1..offset.checked_add(1 + len)?)?
.to_vec(),
)
}
fn ppc_classic_alias_full_path_target(
memory: &mut PpcSectionMem,
data_ptr: u32,
record_size: usize,
vfs_directories: Option<&[PpcVfsDirectory]>,
) -> Option<(u32, Vec<u8>)> {
let mut offset = PPC_CLASSIC_ALIAS_RECORD_HEADER_SIZE;
while offset.checked_add(4)? <= record_size {
let tag = memory.read_u16_be(data_ptr.checked_add(u32::try_from(offset).ok()?)?)?;
if tag == PPC_CLASSIC_ALIAS_END_TAG {
return None;
}
let len = usize::from(
memory
.read_u16_be(data_ptr.checked_add(u32::try_from(offset.checked_add(2)?).ok()?)?)?,
);
let payload_offset = offset.checked_add(4)?;
let payload_end = payload_offset.checked_add(len)?;
if payload_end > record_size {
return None;
}
if tag == PPC_CLASSIC_ALIAS_FULL_PATH_TAG {
let payload_ptr = data_ptr.checked_add(u32::try_from(payload_offset).ok()?)?;
let mut path = Vec::with_capacity(len);
for path_offset in 0..len {
path.push(memory.read_u8(payload_ptr.checked_add(path_offset as u32)?)?);
}
return ppc_classic_alias_target_from_full_path(&path, vfs_directories);
}
offset = payload_offset.checked_add((len + 1) & !1)?;
}
None
}
fn ppc_classic_alias_target_from_full_path(
path: &[u8],
vfs_directories: Option<&[PpcVfsDirectory]>,
) -> Option<(u32, Vec<u8>)> {
let parts = path
.split(|byte| *byte == b':')
.filter(|part| !part.is_empty())
.collect::<Vec<_>>();
if parts.len() < 2 {
return None;
}
let target_name = parts.last()?.to_vec();
if target_name.len() > PPC_FSSPEC_MAX_NAME_LEN {
return None;
}
let parent_parts = &parts[1..parts.len().saturating_sub(1)];
let parent_path = parent_parts
.iter()
.map(|part| decode_mac_roman(part))
.collect::<Vec<_>>()
.join("/");
let normalized_parent_path = ppc_normalize_vfs_path(&parent_path);
if let Some(vfs_directories) = vfs_directories {
if let Some(dir_id) = ppc_directory_id_for_path(vfs_directories, &normalized_parent_path) {
return Some((dir_id, target_name));
}
}
let dir_id = if normalized_parent_path.is_empty() {
PPC_ROOT_DIR_ID
} else if normalized_parent_path.eq_ignore_ascii_case("System Folder") {
PPC_SYSTEM_FOLDER_DIR_ID
} else if normalized_parent_path.eq_ignore_ascii_case("System Folder/Preferences") {
PPC_PREFERENCES_DIR_ID
} else {
return None;
};
Some((dir_id, target_name))
}
fn ppc_read_fixed_pstring_bytes(
memory: &mut PpcSectionMem,
addr: u32,
max_len: usize,
) -> Option<Vec<u8>> {
let len = usize::from(memory.read_u8(addr)?);
if len > max_len {
return None;
}
let mut bytes = Vec::with_capacity(len);
for offset in 0..len {
bytes.push(memory.read_u8(addr.checked_add(1 + offset as u32)?)?);
}
Some(bytes)
}
pub(super) fn ppc_resolve_alias(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
handles: &[PpcHandleRecord],
aliases: &[PpcAliasRecord],
) -> i16 {
let _from_file_ptr = cpu.gpr[3];
let alias_handle = cpu.gpr[4];
let target_ptr = cpu.gpr[5];
let was_changed_ptr = cpu.gpr[6];
if alias_handle == 0 || target_ptr == 0 || was_changed_ptr == 0 {
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, target_ptr, PPC_FSSPEC_SIZE as u32)
|| !ppc_memory_can_write_bytes(memory, was_changed_ptr, 1)
{
return PPC_PARAM_ERR;
};
let alias = aliases
.iter()
.find(|record| record.handle == alias_handle)
.cloned()
.or_else(|| {
ppc_alias_record_from_handle(memory, handles, alias_handle, Some(vfs_directories))
});
let Some(alias) = alias else {
return PPC_PARAM_ERR;
};
if !ppc_write_fsspec_parts(
memory,
target_ptr,
alias.target_vref,
alias.target_dir_id,
&alias.target_name,
) || memory.write_u8(was_changed_ptr, 0).is_none()
{
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
pub(super) fn ppc_update_alias(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
last_mem_error: &mut i16,
vfs_directories: &[PpcVfsDirectory],
handles: &mut [PpcHandleRecord],
aliases: &mut Vec<PpcAliasRecord>,
) -> i16 {
let _from_file_ptr = cpu.gpr[3];
let target_ptr = cpu.gpr[4];
let alias_handle = cpu.gpr[5];
let was_changed_ptr = cpu.gpr[6];
if target_ptr == 0 || alias_handle == 0 || was_changed_ptr == 0 {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, was_changed_ptr, 1) {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
}
let Some((target_vref, target_dir_id, target_name)) = ppc_read_fsspec_parts(memory, target_ptr)
else {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
};
let Some(alias_data) = ppc_alias_record_bytes(target_vref, target_dir_id, &target_name) else {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
};
let Some(handle_index) = handles
.iter()
.position(|record| record.handle == alias_handle)
else {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
};
let existing_alias = aliases
.iter()
.find(|record| record.handle == alias_handle)
.cloned()
.or_else(|| {
ppc_alias_record_from_handle(memory, handles, alias_handle, Some(vfs_directories))
});
let Some(existing_alias) = existing_alias else {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
};
let changed = existing_alias.target_vref != target_vref
|| existing_alias.target_dir_id != target_dir_id
|| existing_alias.target_name != target_name;
if !changed {
if memory.write_u8(was_changed_ptr, 0).is_none() {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
}
*last_mem_error = PPC_NO_ERR;
return PPC_NO_ERR;
}
let handle_size = usize::try_from(handles[handle_index].size).unwrap_or(usize::MAX);
if alias_data.len() > handle_size {
*last_mem_error = PPC_MEM_FULL_ERR;
return PPC_MEM_FULL_ERR;
}
let Some(data_ptr) = memory.read_u32_be(alias_handle) else {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
};
let alias_data_len = u32::try_from(alias_data.len()).unwrap_or(u32::MAX);
if !ppc_memory_can_write_bytes(memory, data_ptr, alias_data_len) {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
}
for (offset, byte) in alias_data.iter().copied().enumerate() {
if memory.write_u8(data_ptr + offset as u32, byte).is_none() {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
}
}
handles[handle_index].size = alias_data_len;
if let Some(record) = aliases
.iter_mut()
.find(|record| record.handle == alias_handle)
{
record.target_vref = target_vref;
record.target_dir_id = target_dir_id;
record.target_name = target_name;
} else {
aliases.push(PpcAliasRecord {
handle: alias_handle,
target_vref,
target_dir_id,
target_name,
});
}
if memory.write_u8(was_changed_ptr, 1).is_none() {
*last_mem_error = PPC_NO_ERR;
return PPC_PARAM_ERR;
}
*last_mem_error = PPC_NO_ERR;
PPC_NO_ERR
}
pub(super) fn ppc_resolve_alias_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
) -> i16 {
let spec_ptr = cpu.gpr[3];
let _resolve_alias_chains = cpu.gpr[4] != 0;
let target_is_folder_ptr = cpu.gpr[5];
let was_aliased_ptr = cpu.gpr[6];
if target_is_folder_ptr == 0 || was_aliased_ptr == 0 {
return PPC_PARAM_ERR;
}
let path = match ppc_path_for_fsspec(memory, vfs_directories, spec_ptr) {
Ok(path) => path,
Err(err) => return err,
};
let target_is_folder = ppc_directory_id_for_path(vfs_directories, &path).is_some();
let known_file = target_is_folder
|| ppc_vfs_file_index(vfs_files, &path).is_some()
|| ppc_vfs_resource_file_index(vfs_resource_files, &path).is_some();
if !known_file {
return PPC_FNF_ERR;
}
if !ppc_memory_can_write_bytes(memory, target_is_folder_ptr, 1)
|| !ppc_memory_can_write_bytes(memory, was_aliased_ptr, 1)
{
return PPC_PARAM_ERR;
}
if let Some(alias) = ppc_alias_record_for_path(vfs_directories, vfs_resources, &path) {
if !ppc_memory_can_write_bytes(memory, spec_ptr, PPC_FSSPEC_SIZE as u32) {
return PPC_PARAM_ERR;
}
let target_exists = ppc_fsspec_target_exists(
vfs_directories,
vfs_files,
vfs_resource_files,
alias.target_dir_id,
&alias.target_name,
);
let target_is_folder =
ppc_fsspec_target_is_folder(vfs_directories, alias.target_dir_id, &alias.target_name);
if !ppc_write_fsspec_parts(
memory,
spec_ptr,
alias.target_vref,
alias.target_dir_id,
&alias.target_name,
) || memory
.write_u8(target_is_folder_ptr, u8::from(target_is_folder))
.is_none()
|| memory.write_u8(was_aliased_ptr, 1).is_none()
{
return PPC_PARAM_ERR;
}
return if target_exists {
PPC_NO_ERR
} else {
PPC_FNF_ERR
};
}
if memory
.write_u8(target_is_folder_ptr, u8::from(target_is_folder))
.is_none()
|| memory.write_u8(was_aliased_ptr, 0).is_none()
{
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
fn ppc_alias_record_for_path(
vfs_directories: &[PpcVfsDirectory],
vfs_resources: &[PpcVfsResourceRecord],
path: &str,
) -> Option<PpcAliasRecord> {
vfs_resources
.iter()
.filter(|resource| {
resource.path.eq_ignore_ascii_case(path) && resource.res_type == PPC_ALIAS_RECORD_MAGIC
})
.min_by_key(|resource| (u8::from(resource.res_id != 0), resource.res_id))
.and_then(|resource| ppc_alias_record_from_bytes(&resource.data, Some(vfs_directories)))
}
fn ppc_fsspec_target_is_folder(
vfs_directories: &[PpcVfsDirectory],
dir_id: u32,
name_bytes: &[u8],
) -> bool {
if name_bytes.is_empty() {
return ppc_directory_path_for_id(vfs_directories, dir_id).is_some();
}
let Some(parent_path) = ppc_directory_path_for_id(vfs_directories, dir_id) else {
return false;
};
let normalized_name = ppc_normalize_vfs_path(&decode_mac_roman(name_bytes));
if normalized_name.is_empty() {
return false;
}
let path = ppc_join_vfs_path(parent_path, &normalized_name);
ppc_directory_id_for_path(vfs_directories, &path).is_some()
}
pub(super) fn ppc_resolve_directory_id(vref: i16, dir_id: u32, default_dir_id: u32) -> u32 {
if dir_id <= 1 {
if dir_id == 0 && vref == 0 {
return default_dir_id;
}
if dir_id == 0 {
return PPC_ROOT_DIR_ID;
}
return dir_id;
}
dir_id
}
fn ppc_resolve_volume_ref_num(vref: i16) -> i16 {
if vref == 0 {
PPC_BOOT_VOLUME_REF_NUM
} else {
vref
}
}
fn ppc_read_pstring(memory: &mut PpcSectionMem, addr: u32) -> Option<String> {
Some(decode_mac_roman(&ppc_read_pstring_bytes(memory, addr)?))
}
fn ppc_equal_string(cpu: &PpcCpu, memory: &mut PpcSectionMem) -> u32 {
let a_ptr = cpu.gpr[3];
let b_ptr = cpu.gpr[4];
let case_sensitive = (cpu.gpr[5] & 0xff) != 0;
let _diac_sensitive = (cpu.gpr[6] & 0xff) != 0;
let Some(a_bytes) = ppc_read_pstring_bytes(memory, a_ptr) else {
return 0;
};
let Some(b_bytes) = ppc_read_pstring_bytes(memory, b_ptr) else {
return 0;
};
let equal = if case_sensitive {
a_bytes == b_bytes
} else {
a_bytes.eq_ignore_ascii_case(&b_bytes)
};
if ppc_hle_trace_enabled() {
eprintln!(
"[PPC-TRACE] EqualString a={:?} b={:?} case_sensitive={} -> {}",
decode_mac_roman(&a_bytes),
decode_mac_roman(&b_bytes),
case_sensitive,
equal
);
}
u32::from(equal)
}
pub(super) fn ppc_read_pstring_bytes(memory: &mut PpcSectionMem, addr: u32) -> Option<Vec<u8>> {
let len = memory.read_u8(addr)? as usize;
let mut bytes = Vec::with_capacity(len);
for offset in 0..len {
bytes.push(memory.read_u8(addr.checked_add(1 + offset as u32)?)?);
}
Some(bytes)
}
pub(super) fn ppc_normalize_vfs_path(name: &str) -> String {
name.replace(':', "/")
.split('/')
.filter(|part| !part.is_empty() && *part != ".")
.collect::<Vec<_>>()
.join("/")
}
pub(super) fn ppc_join_vfs_path(parent_path: &str, child_name: &str) -> String {
if parent_path.is_empty() {
child_name.to_string()
} else {
format!("{parent_path}/{child_name}")
}
}
pub(super) fn ppc_directory_path_for_id(vfs_directories: &[PpcVfsDirectory], dir_id: u32) -> Option<&str> {
vfs_directories
.iter()
.find(|directory| directory.dir_id == dir_id)
.map(|directory| directory.path.as_str())
}
pub(super) fn ppc_directory_id_for_path(vfs_directories: &[PpcVfsDirectory], path: &str) -> Option<u32> {
vfs_directories
.iter()
.find(|directory| directory.path.eq_ignore_ascii_case(path))
.map(|directory| directory.dir_id)
}
pub(super) fn ppc_heap_alloc(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
size: u32,
clear: bool,
) -> u32 {
let Some(aligned) = ppc_allocation_size(size) else {
return 0;
};
let Some((ptr, next)) = ppc_heap_allocation_bounds(memory, *heap_cursor, heap_limit, aligned)
else {
return 0;
};
if ppc_memory_can_read_bytes(memory, ptr, aligned) {
if clear {
for offset in 0..aligned {
let _ = memory.write_u8(ptr + offset, 0);
}
}
} else {
memory.add_region(ptr, vec![0u8; aligned as usize]);
}
*heap_cursor = next;
ppc_update_zone_free_bytes(memory, next, heap_limit);
ptr
}
pub(super) fn ppc_process_heap_alloc(
memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
size: u32,
clear: bool,
) -> u32 {
let ptr = memory_manager.reserve_native_bytes(memory, size, clear);
if let Some(heap) = memory_manager.native_heap_state() {
*heap_cursor = heap.heap_cursor;
let allocation_limit = memory_manager.native_allocation_limit(heap.heap_limit);
ppc_update_zone_free_bytes(memory, heap.heap_cursor, allocation_limit);
}
ptr
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_process_alloc_handle_with_bytes(
memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
bytes: &[u8],
) -> u32 {
let handle = memory_manager.copy_bytes_to_new_native_handle(memory, bytes);
ppc_apply_process_native_resource_handle(
memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
handle,
);
handle
}
#[allow(clippy::too_many_arguments)]
fn ppc_process_alloc_handle(
memory_manager: &mut ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
size: u32,
clear: bool,
) -> u32 {
let handle = memory_manager.new_native_handle(memory, size, clear);
ppc_apply_process_native_resource_handle(
memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
handle,
);
handle
}
pub(super) struct PpcProcessAllocatorView<'a> {
pub(super) memory_manager: &'a mut ProcessNativeMemoryManager,
}
impl PpcProcessAllocatorView<'_> {
fn reserve_bytes(
&mut self,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
size: u32,
clear: bool,
) -> u32 {
ppc_process_heap_alloc(self.memory_manager, memory, heap_cursor, size, clear)
}
fn allocate_handle(
&mut self,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
size: u32,
clear: bool,
) -> u32 {
ppc_process_alloc_handle(
self.memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
size,
clear,
)
}
fn allocate_handle_with_bytes(
&mut self,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
bytes: &[u8],
) -> u32 {
ppc_process_alloc_handle_with_bytes(
self.memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
bytes,
)
}
fn resize_handle(
&mut self,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
handle: u32,
size: u32,
) -> i16 {
let result = self
.memory_manager
.set_native_handle_size(memory, handle, size);
ppc_apply_process_native_resource_handle(
self.memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
handle,
);
result
}
fn dispose_handle(
&mut self,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
handle: u32,
) -> bool {
ppc_dispose_process_native_handle(
self.memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
)
}
}
pub(super) fn ppc_allocator_view_reserve_bytes(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
size: u32,
clear: bool,
) -> u32 {
if let Some(allocator) = allocator {
allocator.reserve_bytes(memory, heap_cursor, size, clear)
} else {
ppc_heap_alloc(memory, heap_cursor, heap_limit, size, clear)
}
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_allocator_view_allocate_handle(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
size: u32,
clear: bool,
) -> u32 {
if let Some(allocator) = allocator {
allocator.allocate_handle(memory, heap_cursor, last_mem_error, handles, size, clear)
} else {
ppc_alloc_handle(memory, heap_cursor, heap_limit, handles, size, clear)
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_allocator_view_allocate_handle_with_bytes(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
bytes: &[u8],
) -> u32 {
if let Some(allocator) = allocator {
allocator.allocate_handle_with_bytes(memory, heap_cursor, last_mem_error, handles, bytes)
} else {
ppc_alloc_handle_with_bytes(memory, heap_cursor, heap_limit, handles, bytes)
}
}
#[allow(clippy::too_many_arguments)]
pub(super) fn ppc_allocator_view_resize_handle(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
handle: u32,
size: u32,
) -> i16 {
if let Some(allocator) = allocator {
allocator.resize_handle(memory, heap_cursor, last_mem_error, handles, handle, size)
} else {
ppc_set_handle_size(memory, heap_cursor, heap_limit, handles, handle, size)
}
}
#[allow(clippy::too_many_arguments)]
fn ppc_allocator_view_dispose_handle(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
legacy_handle_states: Option<&mut Vec<PpcHandleStateRecord>>,
handle: u32,
) -> bool {
if let Some(allocator) = allocator {
allocator.dispose_handle(
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
)
} else {
ppc_dispose_tracked_handle(
handle,
memory,
handles,
legacy_handle_states.expect("legacy handle disposal requires handle state"),
)
}
}
fn ppc_heap_allocation_bounds(
memory: &PpcSectionMem,
heap_cursor: u32,
heap_limit: u32,
aligned_size: u32,
) -> Option<(u32, u32)> {
// The native bump heap shares one guest address space with runner-owned
// system code. Treat both its staged exclusion and live read-only mapping
// as a reserved hole so a successful Memory Manager call never returns
// storage whose writes the Trap Manager topology must reject.
ppc_aligned_heap_allocation_bounds(
memory,
heap_cursor,
heap_limit,
aligned_size,
PPC_HEAP_ALIGNMENT,
)
}
pub(super) fn ppc_aligned_heap_allocation_bounds(
memory: &PpcSectionMem,
heap_cursor: u32,
heap_limit: u32,
size: u32,
alignment: u32,
) -> Option<(u32, u32)> {
let mut ptr = align_up(heap_cursor, alignment).ok()?;
loop {
let next = ptr.checked_add(size)?;
if next >= heap_limit {
return None;
}
let Some(reserved_end) = memory.readonly_allocation_overlap_end(ptr, size) else {
return Some((ptr, next));
};
ptr = align_up(reserved_end, alignment).ok()?;
}
}
fn ppc_seed_zone_header(
memory: &mut PpcSectionMem,
zone: u32,
heap_base: u32,
heap_limit: u32,
more_masters: u16,
) {
// Inside Macintosh: Memory (1992), pp. 2-19--2-21, specifies the classic
// Zone record through heapData. Universal Interfaces MacMemory.h refines
// the former maxNRel field at byte 30 into heapType: k32BitHeap is bit 0
// and kNewStyleHeap (the PowerPC Modern Memory Manager) is bit 1.
let free_bytes = ppc_heap_free_capacity(memory, heap_base, heap_limit).0;
let _ = memory.write_u32_be(zone, heap_limit); // bkLim
let _ = memory.write_u32_be(zone + 4, 0); // purgePtr
let _ = memory.write_u32_be(zone + 8, 0); // hFstFree
let _ = memory.write_u32_be(zone + 12, free_bytes); // zcbFree
let _ = memory.write_u32_be(zone + 16, 0); // gzProc
let _ = memory.write_u16_be(zone + 20, more_masters); // moreMast
let _ = memory.write_u16_be(zone + 22, 0); // flags
let _ = memory.write_u16_be(zone + 24, 0); // cntRel
let _ = memory.write_u16_be(zone + 26, 0); // maxRel
let _ = memory.write_u16_be(zone + 28, 0); // cntNRel
let _ = memory.write_u8(
zone + PPC_ZONE_HEAP_TYPE_OFFSET,
PPC_ZONE_32_BIT_HEAP | PPC_ZONE_NEW_STYLE_HEAP,
);
let _ = memory.write_u8(zone + PPC_ZONE_HEAP_TYPE_OFFSET + 1, 0);
let _ = memory.write_u16_be(zone + 32, 0); // cntEmpty
let _ = memory.write_u16_be(zone + 34, 0); // cntHandles
let _ = memory.write_u32_be(zone + 36, free_bytes); // minCBFree
let _ = memory.write_u32_be(zone + 40, 0); // purgeProc
let _ = memory.write_u32_be(zone + 44, 0); // sparePtr
let _ = memory.write_u32_be(zone + 48, heap_base); // allocPtr
let _ = memory.write_u16_be(zone + 52, 0); // heapData
}
pub(super) fn ppc_update_zone_free_bytes(memory: &mut PpcSectionMem, heap_cursor: u32, heap_limit: u32) {
let free_bytes = ppc_heap_free_capacity(memory, heap_cursor, heap_limit).0;
let _ = memory.write_u32_be(PPC_APPLICATION_ZONE + 12, free_bytes);
let _ = memory.write_u32_be(PPC_SYSTEM_ZONE + 12, free_bytes);
}
#[allow(clippy::too_many_arguments)]
fn ppc_allocator_view_replace_handle_bytes(
allocator: Option<&mut PpcProcessAllocatorView<'_>>,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
handle: u32,
bytes: &[u8],
) -> i16 {
let Ok(size) = u32::try_from(bytes.len()) else {
return PPC_MEM_FULL_ERR;
};
let result = ppc_allocator_view_resize_handle(
allocator,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
size,
);
if result != PPC_NO_ERR {
return result;
}
let Some(ptr) = memory.read_u32_be(handle).filter(|ptr| *ptr != 0) else {
return PPC_NIL_HANDLE_ERR;
};
if memory.write_bytes(ptr, bytes).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
#[cfg(test)]
fn ppc_alloc_ptr(
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
ptrs: &mut Vec<PpcPtrRecord>,
free_ptr_blocks: &mut Vec<PpcPtrRecord>,
size: u32,
clear: bool,
) -> u32 {
let required = match ppc_allocation_size(size) {
Some(required) => required,
None => return 0,
};
let reusable_index = free_ptr_blocks
.iter()
.enumerate()
.filter_map(|(index, record)| {
let capacity = ppc_allocation_size(record.size)?;
(capacity >= required).then_some((index, capacity))
})
.min_by_key(|(_, capacity)| *capacity)
.map(|(index, _)| index);
let ptr = if let Some(index) = reusable_index {
free_ptr_blocks.swap_remove(index).ptr
} else {
ppc_heap_alloc(memory, heap_cursor, heap_limit, size, false)
};
if ptr == 0 {
return 0;
}
if clear {
for offset in 0..required {
if memory.write_u8(ptr + offset, 0).is_none() {
return 0;
}
}
}
// Inside Macintosh: Memory (1992), pp. 2-42 and 2-44: DisposePtr
// returns a nonrelocatable block to the application heap for later use.
ptrs.push(PpcPtrRecord { ptr, size });
ptr
}
#[allow(clippy::too_many_arguments)]
fn ppc_dispatch_legacy_memory_utility(
operation: PpcLegacyMemoryUtilityOperation,
cpu: &mut PpcCpu,
process_memory_manager: &ProcessNativeMemoryManager,
memory: &mut PpcSectionMem,
heap_cursor: &mut u32,
heap_limit: u32,
last_mem_error: &mut i16,
handles: &[PpcHandleRecord],
) -> Option<PpcImportAction> {
let free_ptr_blocks = process_memory_manager.native_free_ptr_blocks();
// Inside Macintosh: Operating System Utilities (1994), pp. 3-28--3-29,
// and Memory (1992), pp. 2-42--2-83, define these routines independently
// of any application. Keeping their implementations in one dispatcher is
// only an ABI grouping; behavior is selected solely by the imported API.
match operation {
PpcLegacyMemoryUtilityOperation::BitNot => Some(PpcImportAction::Return(!cpu.gpr[3])),
PpcLegacyMemoryUtilityOperation::BitSet | PpcLegacyMemoryUtilityOperation::BitClear => {
let bit_number = cpu.gpr[4];
let byte_addr = cpu.gpr[3].checked_add(bit_number / 8)?;
let mask = 0x80u8 >> (bit_number & 7);
let old = memory.read_u8(byte_addr)?;
let value = if operation == PpcLegacyMemoryUtilityOperation::BitSet {
old | mask
} else {
old & !mask
};
memory.write_u8(byte_addr, value)?;
Some(PpcImportAction::ReturnPreserve)
}
PpcLegacyMemoryUtilityOperation::FixToExtended => {
let fixed = cpu.gpr[3] as i32;
cpu.fpr[1] = (f64::from(fixed) / 65_536.0).to_bits();
Some(PpcImportAction::ReturnPreserve)
}
PpcLegacyMemoryUtilityOperation::GetMyZone => {
Some(PpcImportAction::Return(PPC_APPLICATION_ZONE))
}
PpcLegacyMemoryUtilityOperation::HandleZone => {
let handle = cpu.gpr[3];
let valid = handle == 0 || handles.iter().any(|record| record.handle == handle);
*last_mem_error = if valid { PPC_NO_ERR } else { -111 };
Some(PpcImportAction::Return(if valid {
PPC_APPLICATION_ZONE
} else {
0
}))
}
PpcLegacyMemoryUtilityOperation::LockMemory
| PpcLegacyMemoryUtilityOperation::UnlockMemory => {
// The native heap is resident host memory, so a valid mapped range
// is already immovable for the lifetime requested by the caller.
let start = cpu.gpr[3];
let len = cpu.gpr[4];
let mapped = len == 0
|| (start != 0
&& memory.read_u8(start).is_some()
&& start
.checked_add(len - 1)
.and_then(|end| memory.read_u8(end))
.is_some());
let result = if mapped { PPC_NO_ERR } else { PPC_PARAM_ERR };
Some(PpcImportAction::Return(ppc_i16_result(result)))
}
PpcLegacyMemoryUtilityOperation::MaxBlock => {
Some(PpcImportAction::Return(ppc_largest_free_ptr_block(
memory,
*heap_cursor,
heap_limit,
free_ptr_blocks,
)))
}
PpcLegacyMemoryUtilityOperation::PurgeSpace => {
let total = ppc_heap_free_capacity(memory, *heap_cursor, heap_limit)
.0
.saturating_add(
free_ptr_blocks
.iter()
.filter(|block| ppc_free_ptr_block_fits_limit(block, heap_limit))
.fold(0u32, |sum, block| sum.saturating_add(block.size)),
);
let contiguous =
ppc_largest_free_ptr_block(memory, *heap_cursor, heap_limit, free_ptr_blocks);
if cpu.gpr[3] != 0 {
memory.write_u32_be(cpu.gpr[3], total)?;
}
if cpu.gpr[4] != 0 {
memory.write_u32_be(cpu.gpr[4], contiguous)?;
}
Some(PpcImportAction::ReturnPreserve)
}
PpcLegacyMemoryUtilityOperation::ReserveMem => {
let requested = cpu.gpr[3];
let available = ppc_largest_free_ptr_block(
memory,
*heap_cursor,
heap_limit,
free_ptr_blocks,
);
*last_mem_error = if requested <= available {
PPC_NO_ERR
} else {
PPC_MEM_FULL_ERR
};
Some(PpcImportAction::ReturnPreserve)
}
PpcLegacyMemoryUtilityOperation::SetGrowZone => {
memory.write_u32_be(PPC_APPLICATION_ZONE + 16, cpu.gpr[3])?;
Some(PpcImportAction::ReturnPreserve)
}
PpcLegacyMemoryUtilityOperation::StackSpace => Some(PpcImportAction::Return(
cpu.gpr[1].saturating_sub(
process_memory_manager.application_heap_limit(heap_limit),
),
)),
PpcLegacyMemoryUtilityOperation::TempFreeMem => Some(PpcImportAction::Return(
ppc_heap_free_capacity(memory, *heap_cursor, heap_limit).0,
)),
}
}
pub(super) fn ppc_largest_free_ptr_block(
memory: &PpcSectionMem,
heap_cursor: u32,
heap_limit: u32,
free_ptr_blocks: &[PpcPtrRecord],
) -> u32 {
free_ptr_blocks
.iter()
.filter(|record| ppc_free_ptr_block_fits_limit(record, heap_limit))
.map(|record| record.size)
.max()
.unwrap_or(0)
.max(ppc_heap_free_capacity(memory, heap_cursor, heap_limit).1)
}
fn ppc_free_ptr_block_fits_limit(record: &ProcessPtrRecord, heap_limit: u32) -> bool {
ppc_allocation_size(record.size)
.and_then(|capacity| record.ptr.checked_add(capacity))
.is_some_and(|end| end <= heap_limit)
}
pub(super) fn ppc_memory_can_write_bytes(memory: &mut PpcSectionMem, addr: u32, len: u32) -> bool {
memory.preflight_writable_range(addr, len)
}
pub(super) fn ppc_init_zone_header(
memory: &mut PpcSectionMem,
start: u32,
limit: u32,
more_masters_raw: u16,
grow_zone: u32,
) {
const ZONE_HEADER_SIZE: u32 = 52;
let Some(header_end) = start.checked_add(ZONE_HEADER_SIZE) else {
return;
};
if limit < header_end || !ppc_memory_can_write_bytes(memory, start, ZONE_HEADER_SIZE) {
return;
}
let more_masters = i16::from_be_bytes(more_masters_raw.to_be_bytes()).max(0) as u32;
let free_bytes = limit
.saturating_sub(start)
.saturating_sub(72 + (4 * more_masters));
let first_master_ptr = if more_masters == 0 {
0
} else {
start.wrapping_add(60)
};
let _ = memory.write_u32_be(start, limit); // bkLim
let _ = memory.write_u32_be(start + 4, 0); // purgePtr
let _ = memory.write_u32_be(start + 8, first_master_ptr); // hFstFree
let _ = memory.write_u32_be(start + 12, free_bytes); // zcbFree
let _ = memory.write_u32_be(start + 16, grow_zone); // gzProc
let _ = memory.write_u16_be(start + 20, more_masters_raw); // moreMast
let _ = memory.write_u16_be(start + 22, 0); // flags
let _ = memory.write_u16_be(start + 24, 0); // cntRel
let _ = memory.write_u16_be(start + 26, 0); // maxRel
let _ = memory.write_u16_be(start + 28, 0); // cntNRel
let _ = memory.write_u16_be(start + 30, 0); // maxNRel
let _ = memory.write_u16_be(start + 32, 0); // cntEmpty
let _ = memory.write_u16_be(start + 34, 0); // cntHandles
let _ = memory.write_u32_be(start + 36, free_bytes); // minCBFree
let _ = memory.write_u32_be(start + 40, 0); // purgeProc
let _ = memory.write_u32_be(start + 44, 0); // sparePtr
let _ = memory.write_u32_be(start + 48, start + ZONE_HEADER_SIZE); // allocPtr
let _ = memory.write_u32_be(PPC_THE_ZONE_ADDR, start);
}
pub(super) fn ppc_memory_can_read_bytes(memory: &mut PpcSectionMem, addr: u32, len: u32) -> bool {
for offset in 0..len {
let Some(byte_addr) = addr.checked_add(offset) else {
return false;
};
if memory.read_u8(byte_addr).is_none() {
return false;
}
}
true
}
pub(super) fn ppc_memory_read_bytes(memory: &mut PpcSectionMem, addr: u32, len: u32) -> Option<Vec<u8>> {
let mut bytes = Vec::with_capacity(usize::try_from(len).ok()?);
for offset in 0..len {
bytes.push(memory.read_u8(addr.checked_add(offset)?)?);
}
Some(bytes)
}
pub(super) fn ppc_optional_output_can_write(memory: &mut PpcSectionMem, addr: u32, len: u32) -> bool {
addr == 0 || ppc_memory_can_write_bytes(memory, addr, len)
}
pub(super) fn ppc_optional_pstring_output_can_write(
memory: &mut PpcSectionMem,
addr: u32,
bytes: &[u8],
) -> bool {
let len = bytes.len().min(255) as u32;
addr == 0 || ppc_memory_can_write_bytes(memory, addr, len + 1)
}
pub(super) fn ppc_heap_can_alloc_sequence(
memory: &PpcSectionMem,
heap_cursor: u32,
heap_limit: u32,
sizes: &[u32],
) -> bool {
let mut simulated_cursor = heap_cursor;
for size in sizes {
let Some(aligned_size) = ppc_allocation_size(*size) else {
return false;
};
let Some((_, next)) =
ppc_heap_allocation_bounds(memory, simulated_cursor, heap_limit, aligned_size)
else {
return false;
};
simulated_cursor = next;
}
true
}
fn ppc_heap_can_alloc_repeated(
memory: &PpcSectionMem,
heap_cursor: u32,
heap_limit: u32,
size: u32,
count: u32,
) -> bool {
let Some(aligned_size) = ppc_allocation_size(size) else {
return false;
};
let mut simulated_cursor = heap_cursor;
for _ in 0..count {
let Some((_, next)) =
ppc_heap_allocation_bounds(memory, simulated_cursor, heap_limit, aligned_size)
else {
return false;
};
simulated_cursor = next;
}
true
}
#[cfg(test)]
fn ppc_heap_allocation_sequence_size(sizes: &[u32]) -> Option<u32> {
sizes.iter().try_fold(0u32, |total_size, size| {
total_size.checked_add(ppc_allocation_size(*size)?)
})
}
fn ppc_allocation_size(size: u32) -> Option<u32> {
// The native Power Mac Memory Manager returns NewPtr/NewHandle storage on
// 16-byte boundaries. Native renderers depend on this stronger guarantee:
// for example, packed mask blitters derive their starting bit from the low
// address bits of a PixMap's pixel storage.
Some(size.checked_add(PPC_HEAP_ALIGNMENT - 1)? & !(PPC_HEAP_ALIGNMENT - 1))
.map(|size| size.max(PPC_HEAP_ALIGNMENT))
}
pub(super) fn ppc_heap_free_capacity(memory: &PpcSectionMem, heap_cursor: u32, heap_limit: u32) -> (u32, u32) {
memory.readonly_allocation_available_bytes(heap_cursor, heap_limit)
}
pub(super) fn ppc_i16_result(value: i16) -> u32 {
i32::from(value) as u32
}
fn ppc_run_result_cycles(result: PpcRunResult) -> u64 {
match result {
PpcRunResult::CycleLimit { cycles }
| PpcRunResult::Halted { cycles, .. }
| PpcRunResult::Unimplemented { cycles, .. }
| PpcRunResult::MemoryFault { cycles, .. }
| PpcRunResult::Exception { cycles, .. }
| PpcRunResult::FetchFault { cycles, .. } => cycles,
}
}
fn ppc_run_result_with_cycles(result: PpcRunResult, cycles: u64) -> PpcRunResult {
match result {
PpcRunResult::CycleLimit { .. } => PpcRunResult::CycleLimit { cycles },
PpcRunResult::Halted { pc, .. } => PpcRunResult::Halted { pc, cycles },
PpcRunResult::Unimplemented { pc, error, .. } => {
PpcRunResult::Unimplemented { pc, error, cycles }
}
PpcRunResult::MemoryFault {
pc,
addr,
was_write,
..
} => PpcRunResult::MemoryFault {
pc,
addr,
was_write,
cycles,
},
PpcRunResult::Exception { pc, exception, .. } => PpcRunResult::Exception {
pc,
exception,
cycles,
},
PpcRunResult::FetchFault { pc, .. } => PpcRunResult::FetchFault { pc, cycles },
}
}
struct PpcRetiredThreadStorageEdge<'a> {
manager: &'a mut ProcessNativeMemoryManager,
}
impl RetiredThreadStorageEdge for PpcRetiredThreadStorageEdge<'_> {
fn release_classic(&mut self, stack_base: u32) {
self.manager
.dispose_classic_ptr_from_native_import(stack_base);
}
fn release_native(&mut self, stack_base: u32) {
self.manager.dispose_native_ptr(stack_base);
}
}
pub(super) fn ppc_release_retired_thread_storage(
manager: &mut ProcessNativeMemoryManager,
retirement: NativeRetirement,
recycle: bool,
) {
let storage = match retirement {
NativeRetirement::Removed(storage) | NativeRetirement::Switched(storage) => storage,
};
ThreadManager::release_retired_storage(
storage,
recycle,
&mut PpcRetiredThreadStorageEdge { manager },
);
}
pub(super) fn ppc_resolve_callback_target(
memory: &mut PpcSectionMem,
proc_ptr: u32,
default_rtoc: u32,
selector: Option<u32>,
) -> Option<PpcCallbackTarget> {
let procedure = resolve_guest_procedure(
memory,
proc_ptr,
default_rtoc,
selector,
GuestIsa::PowerPc,
GuestIsa::PowerPc,
)?;
(procedure.isa == GuestIsa::PowerPc).then_some(PpcCallbackTarget {
entry: procedure.entry,
rtoc: procedure.rtoc,
proc_info: procedure.proc_info,
routine_flags: procedure.routine_flags,
})
}
fn import_data_address_for(library_name: &str, symbol_name: &str) -> Option<u32> {
match (library_name, symbol_name) {
("StdCLib", "_IntEnv") => Some(PPC_IMPORT_DATA_BASE),
("StdCLib", "__C_phase") => Some(PPC_IMPORT_DATA_BASE + 0x400),
("StdCLib", "__target_for_exit") => Some(PPC_IMPORT_DATA_BASE + 0x404),
("StdCLib", "_exit_status") => Some(PPC_IMPORT_DATA_BASE + 0x408),
("StdCLib", "_iob") => Some(PPC_STDIO_IOB_ADDR),
("StdCLib", "__p_CType") => Some(PPC_IMPORT_CTYPE_POINTER),
("StdCLib", "_DBL_EPSILON") => Some(PPC_IMPORT_STD_DBL_EPSILON),
("StdCLib", "_DBL_MAX") => Some(PPC_IMPORT_STD_DBL_MAX),
("StdCLib", "_DBL_MIN") => Some(PPC_IMPORT_STD_DBL_MIN),
("StdCLib", "_FLT_EPSILON") => Some(PPC_IMPORT_STD_FLT_EPSILON),
("StdCLib", "_FLT_MAX") => Some(PPC_IMPORT_STD_FLT_MAX),
("StdCLib", "_FLT_MIN") => Some(PPC_IMPORT_STD_FLT_MIN),
("StdCLib", "errno") => Some(PPC_IMPORT_STD_ERRNO),
("StdCLib", "MacOSErr") => Some(PPC_IMPORT_STD_MAC_OS_ERR),
// PowerPC Numerics exposes `pi` as an addressable MathLib export.
// Some CFM clients label the import as a transition-vector symbol but
// dereference it directly as a double, so bind the known export to
// stable data storage regardless of the PEF class tag.
("MathLib", "pi") => Some(PPC_IMPORT_MATH_PI),
("MathLib", "_FE_DFL_ENV") => Some(PPC_IMPORT_MATH_FE_DFL_ENV),
_ => None,
}
}
fn ppc_seed_import_data(memory: &mut PpcSectionMem) {
// The Metrowerks runtime imports these as true CFM data symbols, not
// callable entry points. Give them stable writable storage and point the
// ctype indirection at a complete 256-entry classification table.
let _ = memory.write_u32_be(PPC_IMPORT_CTYPE_POINTER, PPC_IMPORT_CTYPE_TABLE);
let _ = memory.write_u64_be(PPC_IMPORT_MATH_PI, std::f64::consts::PI.to_bits());
// Inside Macintosh: PowerPC Numerics (1994), Chapter 8 and Appendix C:
// PowerPC fenv_t is a 32-bit word, with zero selecting round-to-nearest
// and leaving every floating-point exception flag clear.
let _ = memory.write_u32_be(PPC_IMPORT_MATH_FE_DFL_ENV, 0);
// Universal Interfaces 3.4 float.h exposes these values by dereferencing
// imported StdCLib objects. Seed their exact IEEE single- and
// double-precision representations in big-endian guest memory.
let _ = memory.write_u64_be(PPC_IMPORT_STD_DBL_EPSILON, f64::EPSILON.to_bits());
let _ = memory.write_u64_be(PPC_IMPORT_STD_DBL_MAX, f64::MAX.to_bits());
let _ = memory.write_u64_be(PPC_IMPORT_STD_DBL_MIN, f64::MIN_POSITIVE.to_bits());
let _ = memory.write_u32_be(PPC_IMPORT_STD_FLT_EPSILON, f32::EPSILON.to_bits());
let _ = memory.write_u32_be(PPC_IMPORT_STD_FLT_MAX, f32::MAX.to_bits());
let _ = memory.write_u32_be(PPC_IMPORT_STD_FLT_MIN, f32::MIN_POSITIVE.to_bits());
// Universal Interfaces 3.4 errno.h declares StdCLib's writable `errno`
// as an int and `MacOSErr` as a short. Both begin clear at process launch.
let _ = memory.write_u32_be(PPC_IMPORT_STD_ERRNO, 0);
let _ = memory.write_u16_be(PPC_IMPORT_STD_MAC_OS_ERR, 0);
let _ = memory.write_bytes(
PPC_STDIO_IOB_ADDR,
&vec![0; (3 * PPC_STDIO_FILE_SIZE) as usize],
);
for byte in 0u16..=255 {
let _ = memory.write_u8(
PPC_IMPORT_CTYPE_TABLE + u32::from(byte),
ppc_ctype_entry(byte as u8),
);
}
}
pub(crate) fn ppc_initial_stdio_streams() -> HashMap<u32, PpcStdioStreamRecord> {
(0..3u32)
.map(|index| {
(
PPC_STDIO_IOB_ADDR + index * PPC_STDIO_FILE_SIZE,
PpcStdioStreamRecord {
ref_num: None,
path: None,
position: 0,
standard: true,
readable: index == 0,
writable: index != 0,
append: false,
closed: false,
eof: false,
error: false,
},
)
})
.collect()
}
fn import_tvector_bytes(count: usize) -> Vec<u8> {
let mut bytes = Vec::with_capacity(count * 8);
for index in 0..count {
let trap_pc = PPC_IMPORT_TRAP_BASE + (index as u32) * 4;
bytes.extend_from_slice(&trap_pc.to_be_bytes());
bytes.extend_from_slice(&0u32.to_be_bytes());
}
bytes
}
fn import_trap_bytes(count: usize) -> Vec<u8> {
let mut bytes = Vec::with_capacity(count * 4);
for _ in 0..count {
bytes.extend_from_slice(&BLR.to_be_bytes());
}
bytes
}
fn ppc_application_init_return_trampoline(main_entry: u32, main_rtoc: u32) -> Vec<u8> {
// r3 is the initializer's OSErr. A failed initializer terminates launch;
// success restores the main routine's TOC and branches to its entry point.
// The generated code is ordinary PowerPC ABI glue, not an HLE import.
let words = [
0x2c03_0000, // cmpwi r3, 0
0x4082_0020, // bne failure
0x3c40_0000 | (main_rtoc >> 16),
0x6042_0000 | (main_rtoc & 0xffff),
0x3d80_0000 | (main_entry >> 16),
0x618c_0000 | (main_entry & 0xffff),
0x7d89_03a6, // mtctr r12
0x4e80_0420, // bctr
0x3980_0000, // failure: li r12, 0
0x7d89_03a6, // mtctr r12
0x4e80_0420, // bctr
];
words
.into_iter()
.flat_map(u32::to_be_bytes)
.collect::<Vec<_>>()
}
fn alignment_bytes(power: u8) -> Result<u32, PpcLoadError> {
if power >= 31 {
return Err(PpcLoadError::AddressOverflow);
}
Ok(1u32 << power)
}
fn align_up(value: u32, align: u32) -> Result<u32, PpcLoadError> {
if align <= 1 {
return Ok(value);
}
let mask = align - 1;
value
.checked_add(mask)
.map(|v| v & !mask)
.ok_or(PpcLoadError::AddressOverflow)
}
fn normalize_stack_size(requested: u32) -> Result<u32, PpcLoadError> {
let requested = if requested == 0 {
PPC_DEFAULT_STACK_SIZE
} else {
requested
};
let requested = requested.max(PPC_INITIAL_STACK_FRAME_SIZE);
let aligned =
align_up(requested, 16).map_err(|_| PpcLoadError::StackSizeOutOfRange { requested })?;
if aligned > PPC_MAX_STACK_SIZE {
return Err(PpcLoadError::StackSizeOutOfRange { requested });
}
Ok(aligned)
}
fn read_u32(data: &[u8], offset: usize) -> Option<u32> {
Some(u32::from_be_bytes(
data.get(offset..offset + 4)?.try_into().ok()?,
))
}
#[cfg(test)]
pub(crate) mod tests;