use super::*;
pub(super) struct PpcPaletteDispatchContext<'a> {
pub(super) binding: &'a PpcImportBinding,
pub(super) cpu: &'a mut PpcCpu,
pub(super) memory: &'a mut PpcSectionMem,
pub(super) process_memory_manager: &'a mut ProcessNativeMemoryManager,
pub(super) heap_cursor: &'a mut u32,
pub(super) heap_limit: u32,
pub(super) last_mem_error: &'a mut i16,
pub(super) handles: &'a mut Vec<PpcHandleRecord>,
pub(super) vfs_resources: &'a [PpcVfsResourceRecord],
pub(super) current_resource_refnum: &'a i16,
pub(super) gworlds: &'a [PpcGWorldRecord],
pub(super) window_list: &'a SharedProcessWindowList,
pub(super) current_gdevice: u32,
pub(super) screen_clut: &'a mut [[u16; 3]; 256],
pub(super) color_manager_clut: &'a mut [[u16; 3]; 256],
pub(super) toolbox_startup: &'a mut PpcToolboxStartupState,
pub(super) event_queue: &'a mut EventQueue,
pub(super) tick_count: u32,
pub(super) input: PpcInputSnapshot,
}
pub(super) fn dispatch_palette_import(
context: PpcPaletteDispatchContext<'_>,
) -> Option<PpcImportAction> {
let PpcPaletteDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
gworlds,
window_list,
current_gdevice,
screen_clut,
color_manager_clut,
toolbox_startup,
event_queue,
tick_count,
input,
} = context;
match binding.dispatcher_target {
PpcImportDispatcherTarget::InitPalettes | PpcImportDispatcherTarget::InitWindows => {
ppc_initialize_application_palette(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
*current_resource_refnum,
toolbox_startup,
);
if binding.dispatcher_target == PpcImportDispatcherTarget::InitPalettes {
Some(PpcImportAction::ReturnPreserve)
} else {
None
}
}
PpcImportDispatcherTarget::ActivatePalette => {
let window_ptr = cpu.gpr[3];
let applied = ppc_front_visible_process_window(memory, window_list) == Some(window_ptr)
&& ppc_gworld_device(gworlds, window_ptr).is_some_and(|gdevice| {
ppc_activate_window_palette(
memory,
window_ptr,
gdevice,
current_gdevice,
screen_clut,
color_manager_clut,
toolbox_startup,
)
});
if applied {
ppc_enqueue_window_update_event(event_queue, window_ptr, tick_count, input);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::NSetPalette => {
let window_ptr = cpu.gpr[3];
let palette_handle = cpu.gpr[4];
let updates = cpu.gpr[5] as u16;
let previous_palette_handle = if window_ptr == u32::MAX {
toolbox_startup.application_palette
} else {
ppc_window_palette_handle(memory, toolbox_startup, window_ptr)
};
if window_ptr == u32::MAX {
toolbox_startup.application_palette = palette_handle;
toolbox_startup.application_palette_updates = updates;
} else if window_ptr != 0
&& memory.read_u16_be(window_ptr.wrapping_add(PPC_CWINDOW_WINDOW_KIND_OFFSET))
== Some(crate::dialog_manager::DIALOG_WINDOW_KIND)
{
toolbox_startup
.dialog_palettes
.insert(window_ptr, (palette_handle, updates));
} else if window_ptr != 0
&& ppc_memory_can_write_bytes(
memory,
window_ptr.wrapping_add(PPC_CGRAF_PORT_PALETTE_UPDATES_OFFSET),
2,
)
{
let _ = memory.write_u32_be(
window_ptr.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET),
palette_handle,
);
let _ = memory.write_u16_be(
window_ptr.wrapping_add(PPC_CGRAF_PORT_PALETTE_UPDATES_OFFSET),
updates,
);
}
if previous_palette_handle != 0 && previous_palette_handle != palette_handle {
let still_associated = toolbox_startup.application_palette
== previous_palette_handle
|| gworlds.iter().any(|record| {
ppc_window_palette_handle(memory, toolbox_startup, record.port)
== previous_palette_handle
});
if !still_associated {
ppc_release_palette_allocations_and_restore(
memory,
toolbox_startup,
previous_palette_handle,
current_gdevice,
screen_clut,
color_manager_clut,
);
}
}
let previous_device_colors = *screen_clut;
let front_window = ppc_front_visible_process_window(memory, window_list);
let activation_window = if window_ptr == u32::MAX {
front_window.unwrap_or(PPC_MAIN_GWORLD)
} else {
window_ptr
};
let front_uses_default = front_window.map_or(true, |front| {
ppc_window_palette_handle(memory, toolbox_startup, front) == 0
});
let applies_now = if window_ptr == u32::MAX {
front_window.is_none() || front_uses_default
} else {
window_ptr == PPC_MAIN_GWORLD || front_window == Some(window_ptr)
};
let gdevice = ppc_gworld_device(gworlds, activation_window).unwrap_or(current_gdevice);
let applied = activation_window != 0
&& applies_now
&& ppc_activate_window_palette(
memory,
activation_window,
gdevice,
current_gdevice,
screen_clut,
color_manager_clut,
toolbox_startup,
);
if applied
&& *screen_clut != previous_device_colors
&& previous_palette_handle != 0
&& previous_palette_handle != palette_handle
&& updates != 0
&& window_ptr != u32::MAX
{
ppc_enqueue_window_update_event(event_queue, window_ptr, tick_count, input);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::GetPalette => {
let window_ptr = cpu.gpr[3];
let palette = if window_ptr == u32::MAX {
toolbox_startup.application_palette
} else if window_ptr != 0 {
ppc_window_palette_handle(memory, toolbox_startup, window_ptr)
} else {
0
};
Some(PpcImportAction::Return(palette))
}
_ => None,
}
}
fn ppc_initialize_application_palette(
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: &[PpcVfsResourceRecord],
current_refnum: i16,
startup: &mut PpcToolboxStartupState,
) {
if startup.application_palette != 0 {
return;
}
let valid_palette = |bytes: &[u8]| {
bytes
.get(..2)
.map(|count| u16::from_be_bytes([count[0], count[1]]))
.filter(|count| bytes.len() >= 16 + usize::from(*count) * 16)
};
let resource = [current_refnum, 0].into_iter().find_map(|refnum| {
resources.iter().find(|resource| {
resource.ref_num == refnum
&& resource.res_type == u32::from_be_bytes(*b"pltt")
&& resource.res_id == 0
&& valid_palette(&resource.data).is_some()
})
});
let mut bytes = if let Some(resource) = resource {
let count = valid_palette(&resource.data).unwrap();
resource.data[..16 + usize::from(count) * 16].to_vec()
} else {
let mut bytes = vec![0; 48];
bytes[..2].copy_from_slice(&2u16.to_be_bytes());
bytes[16..22].fill(0xff); bytes
};
let count = u16::from_be_bytes([bytes[0], bytes[1]]);
bytes[2..16].fill(0);
for entry in 0..usize::from(count) {
bytes[16 + entry * 16 + 10..16 + (entry + 1) * 16].fill(0);
}
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let handle = ppc_allocator_view_allocate_handle_with_bytes(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
&bytes,
);
if handle != 0 {
startup.application_palette = handle;
startup.application_palette_updates = 0;
}
}