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) 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,
gworlds,
window_list,
current_gdevice,
screen_clut,
color_manager_clut,
toolbox_startup,
event_queue,
tick_count,
input,
} = context;
match binding.dispatcher_target {
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 {
memory
.read_u32_be(window_ptr.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET))
.unwrap_or(0)
};
if window_ptr == u32::MAX {
toolbox_startup.application_palette = palette_handle;
toolbox_startup.application_palette_updates = 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| {
memory
.read_u32_be(
record
.port
.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET),
)
.unwrap_or(0)
== 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
.and_then(|front| {
memory.read_u32_be(front.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET))
})
.unwrap_or(0)
== 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_memory_can_read_bytes(
memory,
window_ptr.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET),
4,
)
{
memory
.read_u32_be(window_ptr.wrapping_add(PPC_CGRAF_PORT_PALETTE_HANDLE_OFFSET))
.unwrap_or(0)
} else {
0
};
Some(PpcImportAction::Return(palette))
}
_ => None,
}
}