use super::graphics::*;
use super::regions::*;
use super::*;
use crate::quickdraw::raster::paint::{
paint_rect, supports, ClipRows, Depth, DrawOutcome, Ink, PatternKind, Surface, TransferMode,
EMPTY_RECT,
};
use crate::quickdraw::raster::region_rows::intersect_rows;
use crate::trap::types::Rect;
pub(crate) fn ppc_fill_rect(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
rect: (i16, i16, i16, i16),
pattern: [u8; 8],
fore: (PpcRgbColor, Option<u8>),
back: (PpcRgbColor, Option<u8>),
) -> bool {
match ppc_fill_rect_with_core(memory, gworlds, current_gworld, rect, pattern, fore, back) {
Some(DrawOutcome::Drawn { .. }) => true,
Some(DrawOutcome::Declined) => {
ppc_paint_rect_bounds(memory, gworlds, current_gworld, rect, fore.0, fore.1)
}
None => false,
}
}
fn ppc_fill_rect_with_core(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
(top, left, bottom, right): (i16, i16, i16, i16),
pattern: [u8; 8],
fore: (PpcRgbColor, Option<u8>),
back: (PpcRgbColor, Option<u8>),
) -> Option<DrawOutcome> {
let surface = ppc_live_quickdraw_surface(memory, gworlds, current_gworld)?;
let front_buffer = surface.front_buffer;
let Some(depth) = Depth::from_bits(front_buffer.depth)
.filter(|depth| supports(*depth, TransferMode::PatCopy, PatternKind::Mono))
else {
return Some(DrawOutcome::Declined);
};
let raster_surface = Surface {
base: front_buffer.base_addr,
row_bytes: front_buffer.row_bytes,
depth,
bounds: ppc_surface_port_bounds(surface),
};
let Some(area) = raster_surface.clip(Rect {
top,
left,
bottom,
right,
}) else {
return Some(DrawOutcome::Drawn {
touched: EMPTY_RECT,
});
};
let uses_fore = pattern.iter().any(|row| *row != 0);
let uses_back = pattern.iter().any(|row| *row != 0xff);
let (fg, bg) = ppc_quickdraw_surface_pattern_pixels(
memory,
surface,
uses_fore.then_some(fore),
uses_back.then_some(back),
)?;
let Some(clip) = ppc_port_clip_rows(memory, current_gworld, area.top, area.bottom) else {
return Some(DrawOutcome::Declined);
};
let ink = Ink {
fg: u32::from(fg),
bg: u32::from(bg),
pattern,
mode: TransferMode::PatCopy,
pat_origin: (0, 0),
};
let mut scratch = Vec::new();
Some(paint_rect(
memory,
&raster_surface,
&clip,
&ink,
area,
&mut scratch,
))
}
fn ppc_surface_port_bounds(surface: PpcQuickDrawSurface) -> Rect {
let far =
|near: i16, len: u32| (i64::from(near) + i64::from(len)).min(i64::from(i16::MAX)) as i16;
Rect {
top: surface.top,
left: surface.left,
bottom: far(surface.top, surface.front_buffer.height),
right: far(surface.left, surface.front_buffer.width),
}
}
pub(super) fn ppc_port_clip_rows(
memory: &mut PpcSectionMem,
port: u32,
top: i16,
bottom: i16,
) -> Option<ClipRows> {
let storages = [
PPC_CGRAF_PORT_VIS_RGN_OFFSET,
PPC_CGRAF_PORT_CLIP_RGN_OFFSET,
]
.map(|offset| {
memory
.read_u32_be(port.wrapping_add(offset))
.and_then(|rgn| ppc_region_storage(memory, rgn))
});
let regions = storages.iter().flatten();
if regions.clone().all(|storage| storage.len() == 10) {
let mut bbox = ClipRows::UNBOUNDED;
for storage in regions {
let Some((rgn_top, rgn_left, rgn_bottom, rgn_right)) = ppc_region_storage_bbox(storage)
else {
return Some(ClipRows::rectangular(EMPTY_RECT));
};
bbox = Rect {
top: bbox.top.max(rgn_top),
left: bbox.left.max(rgn_left),
bottom: bbox.bottom.min(rgn_bottom),
right: bbox.right.min(rgn_right),
};
}
return Some(ClipRows::rectangular(bbox));
}
let mut rows: Option<Vec<Vec<i16>>> = None;
for storage in regions {
let band = ppc_region_rows_for_band(storage, top, bottom)?;
rows = Some(match rows {
None => band,
Some(rows) => rows
.iter()
.zip(&band)
.map(|(row, region_row)| intersect_rows(row, region_row))
.collect(),
});
}
Some(ClipRows::from_rows(top, rows.unwrap_or_default()))
}