299 lines
8.8 KiB
Rust
299 lines
8.8 KiB
Rust
use crate::geometry::*;
|
|
|
|
use crate::lib8::interpolate::scale8;
|
|
|
|
use std::cmp::max;
|
|
use std::fmt::{Formatter, Debug};
|
|
use ansi_term::Color;
|
|
use rgb::Rgb;
|
|
|
|
pub trait CoordinateView: Debug {
|
|
fn next(&mut self) -> Option<(VirtualCoordinates, PhysicalCoordinates)>;
|
|
}
|
|
|
|
pub trait PixelMapping<CoordData: CoordLimits<Data = CoordData>> {
|
|
fn select(&self, rect: &Rectangle<CoordData, Virtual>) -> impl CoordinateView;
|
|
}
|
|
|
|
pub trait DisplayDump<T: PixelMapping<CoordData>, CoordData: CoordLimits<Data = CoordData>> {
|
|
fn dump(&self, map: &T);
|
|
}
|
|
|
|
impl<const PIXEL_NUM: usize> DisplayDump<LinearPixelMapping, u8> for [Rgb<u8>; PIXEL_NUM] {
|
|
fn dump(&self, _map: &LinearPixelMapping) {
|
|
for ref pixel in self {
|
|
print!("{}", Color::RGB(pixel.r, pixel.g, pixel.b).paint("█"));
|
|
}
|
|
println!();
|
|
}
|
|
}
|
|
|
|
impl<const PIXEL_NUM: usize> DisplayDump<StrideMapping, u8> for [Rgb<u8>; PIXEL_NUM] {
|
|
fn dump(&self, map: &StrideMapping) {
|
|
for y in 0..map.stride_count {
|
|
let stride = &map.strides[y];
|
|
for x in 0..stride.length {
|
|
let idx = if stride.reverse {
|
|
stride.physical_idx + stride.length as usize - x as usize
|
|
} else {
|
|
stride.physical_idx + x as usize
|
|
};
|
|
if idx >= self.len() {
|
|
println!();
|
|
println!("frame!!!");
|
|
return;
|
|
}
|
|
let pixel = &self[idx];
|
|
print!("{}", Color::RGB(pixel.r, pixel.g, pixel.b).paint("█"));
|
|
}
|
|
println!();
|
|
}
|
|
println!("frame!!!");
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct LinearCoordView {
|
|
rect: Rectangle<u8, Virtual>,
|
|
idx: u8,
|
|
}
|
|
|
|
impl CoordinateView for LinearCoordView {
|
|
fn next(&mut self) -> Option<(VirtualCoordinates, PhysicalCoordinates)> {
|
|
if self.idx == self.rect.bottom_right.x {
|
|
None
|
|
} else {
|
|
let virt = VirtualCoordinates::new(self.idx, 0);
|
|
let phys = PhysicalCoordinates::new(self.idx as usize, 0);
|
|
self.idx += 1;
|
|
return Some((virt, phys))
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct LinearPixelMapping {
|
|
}
|
|
|
|
impl LinearPixelMapping {
|
|
pub fn new() -> Self {
|
|
Self {}
|
|
}
|
|
}
|
|
|
|
impl PixelMapping<u8> for LinearPixelMapping {
|
|
fn select(&self, rect: &Rectangle<u8, Virtual>) -> impl CoordinateView {
|
|
LinearCoordView {
|
|
rect: rect.clone(),
|
|
idx: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub struct Stride {
|
|
pub length: u8,
|
|
pub x: u8,
|
|
pub y: u8,
|
|
pub reverse: bool,
|
|
pub physical_idx: usize
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct StrideMapping<const STRIDE_NUM: usize = 24> {
|
|
pub strides: [Stride; STRIDE_NUM],
|
|
pub stride_count: usize,
|
|
pixel_count: usize,
|
|
top: u8,
|
|
left: u8,
|
|
height: u8,
|
|
width: u8
|
|
}
|
|
|
|
impl<const STRIDE_NUM: usize> StrideMapping<STRIDE_NUM> {
|
|
pub fn new() -> Self {
|
|
/*let stride_json = vec!(
|
|
(0, 0, 17),
|
|
(1, 0, 17),
|
|
(2, 0, 17),
|
|
(3, 0, 17),
|
|
(4, 0, 16),
|
|
(5, 0, 17),
|
|
(6, 0, 17),
|
|
(7, 0, 17),
|
|
(8, 0, 17),
|
|
(9, 0, 17),
|
|
(10, 0, 17),
|
|
(11, 0, 17),
|
|
(12, 0, 18),
|
|
(13, 0, 17),
|
|
(14, 0, 18),
|
|
(15, 0, 17),
|
|
(16, 0, 17),
|
|
(17, 0, 17)
|
|
);*/
|
|
let stride_json = vec!(
|
|
(0, 0, 16, false),
|
|
(1, 0, 16, true),
|
|
(2, 0, 16, false),
|
|
(3, 0, 16, true),
|
|
(4, 0, 16, false),
|
|
(5, 0, 16, true),
|
|
(6, 0, 16, false),
|
|
(7, 0, 16, true),
|
|
(8, 0, 16, false),
|
|
(9, 0, 16, true),
|
|
(10, 0, 16, false),
|
|
(11, 0, 16, true),
|
|
(12, 0, 16, false),
|
|
(13, 0, 16, true),
|
|
(14, 0, 16, false),
|
|
(15, 0, 16, true),
|
|
);
|
|
let mut strides = [Stride::default(); STRIDE_NUM];
|
|
let stride_count = stride_json.len();
|
|
let mut physical_idx = 0;
|
|
let mut height = 0;
|
|
let mut width = 0;
|
|
for stride_idx in 0..stride_count {
|
|
let json_data = stride_json[stride_idx];
|
|
let x = json_data.0;
|
|
let y = json_data.1;
|
|
let length = json_data.2;
|
|
let reverse = json_data.3;
|
|
strides[stride_idx] = Stride {
|
|
length,
|
|
x,
|
|
y,
|
|
reverse,
|
|
physical_idx
|
|
};
|
|
physical_idx += length as usize;
|
|
width = max(width, stride_idx + x as usize);
|
|
height = max(height, length as usize + y as usize)
|
|
}
|
|
let top = 0;
|
|
let left = 0;
|
|
|
|
log::info!("strides={:?}", strides);
|
|
|
|
Self {
|
|
strides,
|
|
stride_count,
|
|
pixel_count: physical_idx,
|
|
top,
|
|
left,
|
|
height: height as u8,
|
|
width: width as u8
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PixelMapping<u8> for StrideMapping {
|
|
fn select(&self, rect: &Rectangle<u8, Virtual>) -> impl CoordinateView {
|
|
let ret = StrideView::new(self, rect);
|
|
//log::info!("select={:?}", ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct StrideSpace {}
|
|
impl CoordinateSpace for StrideSpace {}
|
|
|
|
type StrideCoords = Coordinates<u8, StrideSpace>;
|
|
|
|
struct StrideView<'a> {
|
|
map: &'a StrideMapping,
|
|
rect: Rectangle<u8, Virtual>,
|
|
span_start: u8,
|
|
span_end: u8,
|
|
offset_start: u8,
|
|
offset_end: u8,
|
|
virt_step_width: u8,
|
|
virt_step_height: u8,
|
|
cur_pixel: StrideCoords
|
|
}
|
|
|
|
impl<'a> Debug for StrideView<'a> {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
f.debug_struct("StrideView")
|
|
.field("rect", &self.rect)
|
|
.field("span", &(self.span_start, self.span_end))
|
|
.field("offset", &(self.offset_start, self.offset_end))
|
|
.field("step", &(self.virt_step_width, self.virt_step_height))
|
|
.field("cur", &self.cur_pixel).finish()
|
|
}
|
|
}
|
|
|
|
impl<'a> StrideView<'a> {
|
|
fn new(map: &'a StrideMapping, rect: &Rectangle<u8, Virtual>) -> Self {
|
|
let span_start = scale8(rect.top_left.x, map.width);
|
|
let span_end = scale8(rect.bottom_right.x, map.width);
|
|
let offset_start = scale8(rect.top_left.y, map.height);
|
|
let offset_end = scale8(rect.bottom_right.y, map.height);
|
|
let virt_step_width = u8::MAX / std::cmp::max(1, span_end - span_start);
|
|
let virt_step_height = u8::MAX / std::cmp::max(1, offset_end - offset_start);
|
|
return Self {
|
|
map,
|
|
rect: rect.clone(),
|
|
span_start,
|
|
span_end,
|
|
offset_start,
|
|
offset_end,
|
|
virt_step_width,
|
|
virt_step_height,
|
|
cur_pixel: StrideCoords::new(span_start, offset_start)
|
|
};
|
|
}
|
|
}
|
|
|
|
impl<'a> CoordinateView for StrideView<'a> {
|
|
fn next(&mut self) -> Option<(VirtualCoordinates, PhysicalCoordinates)> {
|
|
let mut search_idx = self.cur_pixel.x;
|
|
let mut next_offset = self.cur_pixel.y + 1;
|
|
//log::info!("view={:?}", self);
|
|
|
|
while search_idx <= self.span_end {
|
|
let cur = &self.map.strides[search_idx as usize];
|
|
|
|
if next_offset < self.offset_start || next_offset < cur.y {
|
|
search_idx += 1;
|
|
continue;
|
|
}
|
|
|
|
if next_offset > cur.y + cur.length || next_offset > self.offset_end {
|
|
search_idx += 1;
|
|
if search_idx <= self.span_end {
|
|
next_offset = self.map.strides[search_idx as usize].y;
|
|
continue
|
|
} else {
|
|
//log::info!("search end");
|
|
return None;
|
|
}
|
|
}
|
|
|
|
self.cur_pixel = StrideCoords::new(search_idx, next_offset);
|
|
let virt = VirtualCoordinates::new(
|
|
(self.cur_pixel.x * self.virt_step_width).try_into().unwrap(),
|
|
((self.cur_pixel.y - cur.y) * self.virt_step_height).try_into().unwrap()
|
|
);
|
|
let stride_pos = StrideCoords::new(self.cur_pixel.x.try_into().unwrap(), (self.cur_pixel.y - cur.y).try_into().unwrap());
|
|
|
|
let span = &self.map.strides[stride_pos.x as usize];
|
|
//log::info!("span={:?} stride={:?} cur={:?}", span, stride_pos, self.cur_pixel);
|
|
let phys_idx = if span.reverse {
|
|
span.physical_idx + (span.length - 1 - stride_pos.y) as usize
|
|
} else {
|
|
span.physical_idx + stride_pos.y as usize
|
|
};
|
|
let phys = PhysicalCoordinates::new(phys_idx, 0);
|
|
//log::info!("virt={:?} phys={:?}", virt, phys);
|
|
return Some((virt, phys));
|
|
}
|
|
|
|
//log::info!("end");
|
|
|
|
return None;
|
|
}
|
|
}
|