///  Run the emulator
extern "C" fn task_func(_arg: Ptr) {    
    //  Create the hardware API for rendering the emulator
    let hardware = Hardware::new();

    //  Create the emulator
    let chip8 = libchip8::Chip8::new(hardware);

    //  Load the emulator ROM
    let rom = include_bytes!("../roms/blinky.ch8");

    //  Run the emulator ROM. This will block until emulator terminates
    chip8.run(rom);

    //  Should not come here
    assert!(false, "CHIP8 should not end");
}

    //  Load the emulator ROM
    let rom = include_bytes!("../roms/blinky.ch8");

impl libchip8::Hardware for Hardware {
    /// Set the color of a pixel in the screen. true for white, and false for black.
    fn vram_set(&mut self, x: usize, y: usize, color: bool) {
        assert!(x < SCREEN_WIDTH,  "x overflow");  //  x must be 0 to 63
        assert!(y < SCREEN_HEIGHT, "y overflow");  //  y must be 0 to 31
        let i = x + y * SCREEN_WIDTH;              //  index into screen buffer
        unsafe { SCREEN_BUFFER[i] =  //  Screen the screen buffer to...
            if color { 255 }         //  White pixel
            else     {   0 }         //  Black pixel
        };
        //  Remember the boundary of the screen region to be updated
        if self.update_left == 0 && self.update_right == 0 &&
            self.update_top == 0 && self.update_bottom == 0 {
            self.update_left = x as u8; self.update_right  = x as u8;
            self.update_top  = y as u8; self.update_bottom = y as u8;
        }
        //  If this pixel is outside the the boundary of the screen region to be updated, extend the boundary
        if (x as u8) < self.update_left   { self.update_left = x as u8;   }
        if (x as u8) > self.update_right  { self.update_right = x as u8;  }
        if (y as u8) < self.update_top    { self.update_top = y as u8;    }
        if (y as u8) > self.update_bottom { self.update_bottom = y as u8; }
    }

/// CHIP8 Virtual Screen size, in Virtual Pixels
const SCREEN_WIDTH:  usize = 64;
const SCREEN_HEIGHT: usize = 32;
/// CHIP8 Virtual Screen Buffer, 8-bit greyscale (from black=0 to white=255) per Virtual Pixel.
/// The greyscale is mapped to 16-bit colour for display.
static mut SCREEN_BUFFER: [u8; SCREEN_WIDTH * SCREEN_HEIGHT] = [0; SCREEN_WIDTH * SCREEN_HEIGHT];  //  2 KB (64 rows of 32 bytes), u8 means unsigned byte

//  color is true when emulator draws a white pixel, black otherwise
unsafe { SCREEN_BUFFER[i] = 
    if color {
        if self.is_interactive { 255 }  //  Brighter colour when emulator is active
        else { 200 }                    //  Darker colour for initial screen
    } 
    else { 
        if self.is_interactive { 127 }  //  Fade to black
        else { 0 }                      //  Black for initial screen                 
    }  
};

impl libchip8::Hardware for Hardware {
    /// Called in every step; return true for shutdown.
    fn sched(&mut self) -> bool {
        //  If no screen update, return
        if self.update_left == 0 && self.update_right == 0 &&
            self.update_top == 0 && self.update_bottom == 0 { return false; }

        //  If emulator is preparing the initial screen, refresh the screen later
        if !self.is_interactive { return false; }

        //  If emulator is not ready to accept input, refresh the screen later
        if !self.is_checking_input { return false; }
        self.is_checking_input = false;

        //  Tickle the watchdog so that the Watchdog Timer doesn't expire. Mynewt assumes the process is hung if we don't tickle the watchdog.
        unsafe { hal_watchdog_tickle() };

        //  Sleep a while to allow other tasks to run, e.g. SPI background task
        unsafe { os::os_time_delay(1) };

        //  Render the updated region
        render_region(
            self.update_left,
            self.update_top,
            self.update_right,
            self.update_bottom
        );

        //  Reset the screen region to be updated
        self.update_left   = 0;
        self.update_top    = 0;
        self.update_right  = 0;
        self.update_bottom = 0;

        //  Return false to indicate no shutdown
        false
    }

//  If emulator is preparing the initial screen, refresh the screen later
if !self.is_interactive { return false; }

//  If emulator is not ready to accept input, refresh the screen later
if !self.is_checking_input { return false; }
self.is_checking_input = false;

/// Render the Virtual Screen region
fn render_region(left: u8, top: u8, right: u8, bottom: u8) {
    //  Get the physical bounding box width and height
    let physical_box    = get_bounding_box(left, top, right, bottom);  //  Returns (left,top,right,bottom)
    let physical_width  = (physical_box.2 - physical_box.0 + 1) as usize;
    let physical_height = (physical_box.3 - physical_box.1 + 1) as usize;
    //  If the update region is small, render with a single block
    if physical_width + physical_height <= (BLOCK_WIDTH * PIXEL_WIDTH) + (BLOCK_HEIGHT * PIXEL_HEIGHT) {  //  Will not overflow SPI buffer
        render_block(left, top, right, bottom);
    } else {
        ...

/// CHIP8 Physical Screen size, in Physical Pixels
const PHYSICAL_WIDTH:  usize = 240;
const PHYSICAL_HEIGHT: usize = 200;

/// CHIP8 Virtual Screen size, in Virtual Pixels
const SCREEN_WIDTH:  usize = 64;
const SCREEN_HEIGHT: usize = 32;

/// CHIP8 Virtual Pixel size, in Physical Pixels
const PIXEL_WIDTH:  usize = 3;  //  One Virtual Pixel = 3 x 5 Physical Pixels
const PIXEL_HEIGHT: usize = 5;

/// CHIP8 Virtual Block size. We render the CHIP8 Virtual Screen in blocks of Virtual Pixels, without overflowing the SPI buffer.
/// PendingDataSize in SPI is 8192. (BLOCK_WIDTH * PIXEL_WIDTH * BLOCK_HEIGHT * PIXEL_HEIGHT) * 2 must be less than PendingDataSize
const BLOCK_WIDTH:  usize = 32;
const BLOCK_HEIGHT: usize = 5;  //  Letter height

/// Render the Virtual Screen region
fn render_region(left: u8, top: u8, right: u8, bottom: u8) {
    ...
    //  If the update region is small, render with a single block
    if physical_width + physical_height <= (BLOCK_WIDTH * PIXEL_WIDTH) + (BLOCK_HEIGHT * PIXEL_HEIGHT) {
        ...
    } else {
        //  If the update region is too big for a single block, break the region into blocks and render
        let mut x = left;
        let mut y = top;
        loop {
            let block_right  = (x + BLOCK_WIDTH as u8 - 1).min(right);
            let block_bottom = (y + BLOCK_HEIGHT as u8 - 1).min(bottom);

            let physical_box    = get_bounding_box(left, top, right, bottom);  //  Returns (left,top,right,bottom)
            let physical_width  = (physical_box.2 - physical_box.0 + 1) as usize;
            let physical_height = (physical_box.3 - physical_box.1 + 1) as usize;
            render_block(x, y,
                block_right,
                block_bottom
            );  //  Will not overflow SPI buffer
            x += BLOCK_WIDTH as u8;
            if x > right {
                x = left;
                y += BLOCK_HEIGHT as u8;
                if y > bottom { break; }
            }
        }
    }
}

/// Render the Virtual Block
fn render_block(left: u8, top: u8, right: u8, bottom: u8) {
    //  Create an iterator for the Physical Pixels to be rendered
    let mut block = PixelIterator::new(
        left, top, 
        right, bottom,
    );
    //  Get the Physical Pixel dimensions of the Virtual Pixels
    let (left_physical, top_physical, right_physical, bottom_physical) = block.get_window();
    //  Render the block via the iterator
    druid::set_display_pixels(left_physical as u16, top_physical as u16, right_physical as u16, bottom_physical as u16,
        &mut block
    ).expect("set pixels failed");    
}

/// Implement the Iterator for Virtual Pixels in a Virtual Block
impl Iterator for PixelIterator {
    /// This Iterator returns Physical Pixel colour words (16-bit)
    type Item = u16;

    /// Return the next Physical Pixel colour
    #[cfg(not(feature = "chip8_curve"))]  //  If we are not rendering CHIP8 Emulator as curved surface...
    fn next(&mut self) -> Option<Self::Item> {
        if self.y > self.block_bottom { return None; }  //  No more Physical Pixels

        //  Get the 16-bit Physical Colour for the Virtual Pixel at (x, y)
        let color = self.get_color();

        //  Update (x, y) to the next pixel left to right, then top to bottom...
        //  Loop over every stretched horizontal Physical Pixel (x_offset) from 0 to PIXEL_WIDTH - 1
        self.x_offset += 1;
        if self.x_offset >= PIXEL_WIDTH as u8 {
            self.x_offset = 0;

            //  Loop over every Virtual Pixel (x) from block_left to block_right
            self.x += 1;
            if self.x > self.block_right {
                self.x = self.block_left;

                //  Loop over every stretched vertical Vertical Pixel (y_offset) from 0 to PIXEL_HEIGHT - 1
                self.y_offset += 1;
                if self.y_offset >= PIXEL_HEIGHT as u8 {
                    self.y_offset = 0;

                    //  Loop over every Virtual Pixel (y) from block_top to block_bottom
                    self.y += 1;
                }
            }
        }
        //  Return the Physical Pixel color
        return Some(color);
    }

impl libchip8::Hardware for Hardware {
    /// Check if the key is pressed.
    fn key(&mut self, key: u8) -> bool {
        //  key is 0-9 for keys "0" to "9", 0xa-0xf to keys "A" to "F"
        if !self.is_interactive {
            self.is_interactive = true;
        }
        self.is_checking_input = true;
        //  Compare the key with the last touch event
        if unsafe { KEY_PRESSED == Some(key) } {
            unsafe { KEY_PRESSED = None };  //  Clear the touch event
            return true;
        }
        false
    }

//  color is true when emulator draws a white pixel, black otherwise
unsafe { SCREEN_BUFFER[i] = 
    if color {                          //  If emulator draws a white pixel...
        if self.is_interactive { 255 }  //  Brighter colour when emulator is active
        else { 200 }                    //  Darker colour for initial screen
    } 
    else {                              //  If emulator draws a black pixel...
        ...

/// Convert the Virtual Colour (8-bit greyscale) to 16-bit Physical Pixel Colour
fn convert_color(grey: u8) -> u16 {
    match grey {
        250..=255 => Rgb565::from(( grey,       grey, grey )).0,        //  White
        128..250  => Rgb565::from(( grey - 100, grey, grey - 100 )).0,  //  Greenish
        0..128    => Rgb565::from(( 0,          0,    grey )).0,        //  Dark Blue
    }
}

impl PixelIterator {
    /// Return the 16-bit colour of the Virtual Pixel
    fn get_color(&mut self) -> u16 {
        //  Get the greyscale colour at Virtual Coordinates (x,y) and convert to 16-bit Physical Colour
        let i = self.x as usize + self.y as usize * SCREEN_WIDTH;
        let color = unsafe { convert_color( SCREEN_BUFFER[i] ) };
        //  Update the greyscale colour at Virtual Coordinates (x,y)
        if self.x_offset == 0 && self.y_offset == 0 {  //  Update colours only once per Virtual Pixel
            unsafe { SCREEN_BUFFER[i] = update_color( SCREEN_BUFFER[i] ); }  //  e.g. fade to black
        }
        color  //  Return the 16-bit Physical Colour
    }    
}

//  color is true when emulator draws a white pixel, black otherwise
unsafe { SCREEN_BUFFER[i] = 
    if color {                          //  If emulator draws a white pixel...
        ...
    } 
    else {                              //  If emulator draws a black pixel...
        if self.is_interactive { 127 }  //  Fade to black
        else { 0 }                      //  Black for initial screen                 
    }  
};

/// Convert the Virtual Colour (8-bit greyscale) to 16-bit Physical Pixel Colour
fn convert_color(grey: u8) -> u16 {
    match grey {
        250..=255 => Rgb565::from(( grey,       grey, grey )).0,        //  White
        128..250  => Rgb565::from(( grey - 100, grey, grey - 100 )).0,  //  Greenish
        0..128    => Rgb565::from(( 0,          0,    grey )).0,        //  Dark Blue
    }
}

/// Fade the Virtual Colour (8-bit greyscale) to black
fn update_color(grey: u8) -> u8 {
    match grey {
        200..=255 => grey - 2,    //  Initial white flash fade to normal white
        128..200  => grey,        //  Normal white stays the same
        0..128    => grey >> 1,   //  Dark fade to black
    }
}

/// Handle touch events to emulate buttons
pub fn handle_touch(x: u16, _y: u16) { 
    //  We only handle 3 keys: 4, 5, 6, which correspond to Left, Centre, Right
    let key =                                                  //  PHYSICAL_WIDTH is 240
        if x < PHYSICAL_WIDTH as u16 / 3 { Some(4) }           //  Left = 4
        else if x < 2 * PHYSICAL_WIDTH as u16 / 3 { Some(5) }  //  Centre = 5
        else { Some(6) };                                      //  Right = 6
    unsafe { KEY_PRESSED = key };
}

/// Represents the key pressed: 0-9 for keys "0" to "9", 0xa-0xf to keys "A" to "F", None for nothing pressed
static mut KEY_PRESSED: Option<u8> = None;

impl libchip8::Hardware for Hardware {
    /// Check if the key is pressed.
    fn key(&mut self, key: u8) -> bool {
        //  key is 0-9 for keys "0" to "9", 0xa-0xf to keys "A" to "F"
        if !self.is_interactive {
            self.is_interactive = true;
        }
        self.is_checking_input = true;
        //  Compare the key with the last touch event
        if unsafe { KEY_PRESSED == Some(key) } {
            unsafe { KEY_PRESSED = None };  //  Clear the touch event
            return true;
        }
        false
    }

/// Erase the PineTime display and start the CHIP-8 Emulator task
pub fn on_start() -> MynewtResult<()> {
    //  Create black background
    let background = Rectangle::<Rgb565>
        ::new( Coord::new( 0, 0 ), Coord::new( 239, 239 ) )   //  Rectangle coordinates
        .fill( Some( Rgb565::from(( 0x00, 0x00, 0x00 )) ) );  //  Black

    //  Render background to display
    druid::draw_to_display(background);

    //  Start the emulator in a background task
    os::task_init(                  //  Create a new task and start it...
        unsafe { &mut CHIP8_TASK }, //  Task object will be saved here
        &init_strn!( "chip8" ),     //  Name of task
        Some( task_func ),    //  Function to execute when task starts
        NULL,  //  Argument to be passed to above function
        20,    //  Task priority: highest is 0, lowest is 255 (main task is 127), SPI is 10
        os::OS_WAIT_FOREVER as u32,       //  Don't do sanity / watchdog checking
        unsafe { &mut CHIP8_TASK_STACK }, //  Stack space for the task
        CHIP8_TASK_STACK_SIZE as u16      //  Size of the stack (in 4-byte units)
    ) ? ;                                 //  `?` means check for error

    //  Return success to the caller
    Ok(())
}

/// CHIP8 Background Task
static mut CHIP8_TASK: os::os_task = fill_zero!(os::os_task);

/// Stack space for CHIP8 Task, initialised to 0.
static mut CHIP8_TASK_STACK: [os::os_stack_t; CHIP8_TASK_STACK_SIZE] = 
    [0; CHIP8_TASK_STACK_SIZE];

/// Size of the stack (in 4-byte units). Previously `OS_STACK_ALIGN(256)`  
const CHIP8_TASK_STACK_SIZE: usize = 4096;  //  Must be 4096 and above because CHIP8 Emulator requires substantial stack space

#[cfg(feature = "interpolate_x")]  //  If interpolating X values...
fn load_data() -> [Point3<f64>; 16] {
    [
        //  Generated by https://docs.google.com/spreadsheets/d/1G9kLS0Es6kwcMA3SC50w5-T-LBYi3NQeY98y7HOAovs/edit#gid=1875321785
        p( 1 as f64,  0 as f64,  0 as f64),  //  Physical ( 1,  0) → Virtual X =  0
        p(45 as f64,  0 as f64, 11 as f64),  //  Physical (45,  0) → Virtual X = 11
        p( 1 as f64, 36 as f64,  0 as f64),  //  Physical ( 1, 36) → Virtual X =  0
        ...

#[cfg(feature = "interpolate_y")]  //  If interpolating Y values...
fn load_data() -> [Point3<f64>; 16] {
    [
        //  Generated by https://docs.google.com/spreadsheets/d/1G9kLS0Es6kwcMA3SC50w5-T-LBYi3NQeY98y7HOAovs/edit#gid=1875321785
        p( 1 as f64,  0 as f64, 0 as f64),  //  Physical ( 1,  0) → Virtual Y = 0
        p(45 as f64,  0 as f64, 0 as f64),  //  Physical (45,  0) → Virtual Y = 0
        p( 1 as f64, 36 as f64, 5 as f64),  //  Physical ( 1, 36) → Virtual Y = 5
        ...

Physical ( 1,  0) -> Virtual X =  0  //  Provided value
Physical ( 2,  0) -> Virtual X =  0  //  Interpolated value
Physical ( 3,  0) -> Virtual X =  1  //  Interpolated value
...
Physical (45,  1) -> Virtual X = 11  //  Provided value
Physical (46,  1) -> Virtual X = 11  //  Interpolated value
Physical (47,  1) -> Virtual X = 11  //  Interpolated value
...
Physical ( 1, 36) -> Virtual X =  0  //  Provided value
Physical ( 2, 36) -> Virtual X =  0  //  Interpolated value
Physical ( 3, 36) -> Virtual X =  1  //  Interpolated value
...

/// Given a grid of Physical (x,y) Coordinates and their interpolated Virtual (x,y) Coordinates, 
/// find all Physical (x,y) Coordinates that interpolate to (x_virtual,y_virtual).
/// Return the (left, top, right, bottom) of the Bounding Box that encloses these found points.
/// x_virtual and y_virtual are truncated to integer during comparison.
/// Function returns `None` if (x_virtual,y_virtual) was not found.
fn get_bounding_box(
    x_virtual_grid: &[[f64; X_PHYSICAL_SUBDIVISIONS + 1]; Y_PHYSICAL_SUBDIVISIONS + 1],
    y_virtual_grid: &[[f64; X_PHYSICAL_SUBDIVISIONS + 1]; Y_PHYSICAL_SUBDIVISIONS + 1],
    x_virtual: f64,
    y_virtual: f64
) -> Option<(f64, f64, f64, f64)> {
    let mut left: f64 = f64::MAX;
    let mut top: f64 = f64::MAX;
    let mut right: f64 = f64::MIN;
    let mut bottom: f64 = f64::MIN;
    //  For all Physical (x,y) Coordinates...
    for y in 0..=Y_PHYSICAL_SUBDIVISIONS {
        for x in 0..=X_PHYSICAL_SUBDIVISIONS {
            //  Get the Physical (x,y) Coordinates
            let pos = transform_physical_point(cg::Point2::new(x as f64, y as f64));

            //  Get the interpolated Virtual (x,y) Coordinates
            let x_interpolated = x_virtual_grid[y][x].floor();
            let y_interpolated = y_virtual_grid[y][x].floor();

            //  Skip if not matching
            if x_interpolated as u8 != x_virtual as u8 || 
                y_interpolated as u8 != y_virtual as u8 { continue; }

            //  Find the Bounding Box of the Physical (x,y) Coordinates
            if pos.x < left   { left   = pos.x; }
            if pos.y < top    { top    = pos.y; }
            if pos.x > right  { right  = pos.x; }
            if pos.y > bottom { bottom = pos.y; }
        }
    };
    if left < f64::MAX && top < f64::MAX &&
        right > f64::MIN && bottom > f64::MIN {  //  (x_virtual,y_virtual) found
            Some((left.floor(), top.floor(), right.floor(), bottom.floor())) 
    } else { None }  //  (x_virtual,y_virtual) not found
}

/// For all Virtual (x,y) Coordinates, compute the Bounding Box that encloses the corresponding Physical (x,y) Coordinates.
/// Used by the CHIP-8 Emulator to decide which Physical Pixels to redraw when a Virtual Pixel is updated.
fn generate_virtual_to_physical_map() {
    println!("VIRTUAL_TO_PHYSICAL_MAP=");
    print!("[");
    for y in 0..Y_VIRTUAL_SUBDIVISIONS {
        print!("[");
        for x in 0..X_VIRTUAL_SUBDIVISIONS {
            //  Convert the normalised (x,y) into Virtual (x,y) Coordinates
            let pos = transform_virtual_point(cg::Point2::new(x as f64, y as f64));
            //  For all Physical (x,y) that interpolate to the Virtual (x,y), find the bounding box
            let bounding_box = get_bounding_box(
                data::X_VIRTUAL_GRID,
                data::Y_VIRTUAL_GRID,
                pos.x,
                pos.y);  //  Returns (left, top, right, bottom) for the Bounding Box
            if let Some((left, top, right, bottom)) = bounding_box {
                print!("({:.0},{:.0},{:.0},{:.0}),", left, top, right, bottom);
                /* if left as u8 == right as u8 && top as u8 == bottom as u8 {
                    print!("****");  //  Flag out Virtual Points that map to a single Physical Point
                } */
            } else {
                print!("(255,255,255,255),");
            }
            //  println!("XVirtual={:.0}, YVirtual={:.0}, BoundBox={:.?}", pos.x, pos.y, bounding_box);
        }
        println!("],");
    }
    println!("]\n");    
}

/// For all Physical (x,y) Coordinates, return the corresponding Virtual (x,y) Coordinates.
/// Used by the CHIP-8 Emulator to decide which Virtual Pixel to fetch the colour value when rendering a Physical Pixel.
fn generate_physical_to_virtual_map() {
    println!("PHYSICAL_TO_VIRTUAL_MAP=");
    print!("[");
    for y in 0..Y_PHYSICAL_SUBDIVISIONS {
        print!("[");
        for x in 0..X_PHYSICAL_SUBDIVISIONS {
            //  Convert the normalised (x,y) into Physical (x,y) Coordinates
            //  let physical_point = transform_physical_point(cg::Point2::new(x as f64, y as f64));
            //  Construct the interpolated Virtual (x,y) Coordinates
            let virtual_point = cg::Point2::new(
                data::X_VIRTUAL_GRID[y][x] as f64, 
                data::Y_VIRTUAL_GRID[y][x] as f64
            );
            print!("({:.0},{:.0}),", virtual_point.x, virtual_point.y);
        }
        println!("],");
    }
    println!("]\n");    
}

/// For Physical (x,y) Coordinates, return the corresponding Virtual (x,y) Coordinates.
/// Used by the CHIP-8 Emulator to decide which Virtual Pixel to fetch the colour value when rendering a Physical Pixel.
/// (x,y) must belong to the X >= 0, Y >= 0 quadrant
fn map_physical_to_virtual_normalised(x: u8, y: u8) -> (u8, u8) {
    let x_index = x.min(PHYSICAL_TO_VIRTUAL_MAP_WIDTH as u8 - 1);
    let y_index = y.min(PHYSICAL_TO_VIRTUAL_MAP_HEIGHT as u8 - 1);
    let virtual_pixel = PHYSICAL_TO_VIRTUAL_MAP[y_index as usize][x_index as usize];  //  Returns (x,y)
    virtual_pixel
}

/// For each Physical (x,y) Coordinate, return the corresponding Virtual (x,y) Coordinates.
/// Used by the CHIP-8 Emulator to decide which Virtual Pixel to fetch the colour value when rendering a Physical Pixel.
/// Since X and Y are symmetric, this grid only covers one quadrant (X >= 0, Y >= 0)
static PHYSICAL_TO_VIRTUAL_MAP: &[[(u8,u8); PHYSICAL_TO_VIRTUAL_MAP_WIDTH]; PHYSICAL_TO_VIRTUAL_MAP_HEIGHT = &  //  Row=Y, Col=X
[               //  Copied from output of https://github.com/lupyuen/interpolate-surface
    [           //  Physical Row 0
        (0,0),  //  Physical Row 0, Col 0   => Virtual Col 0,  Row 0
        (0,0),  //  Physical Row 0, Col 1   => Virtual Col 0,  Row 0
        ...
        (32,0), //  Physical Row 0, Col 239 => Virtual Col 32, Row 0
    ],
    [           //  Physical Row 1
        (0,0),  //  Physical Row 1, Col 0   => Virtual Col 0,  Row 0
        (0,0),  //  Physical Row 1, Col 1   => Virtual Col 0,  Row 0
        ...
        (32,0), //  Physical Row 1, Col 239 => Virtual Col 32, Row 0
    ],
...

/// For Physical (x,y) Coordinates, return the corresponding Virtual (x,y) Coordinates.
/// Used by the CHIP-8 Emulator to decide which Virtual Pixel to fetch the colour value when rendering a Physical Pixel.
fn map_physical_to_virtual(x: u8, y: u8) -> (u8, u8) {
    //  Check which quadrant (x,y) belongs to and flip accordingly
    let flip =  //  (flip for X, flip for Y)
        if x < PHYSICAL_WIDTH as u8 / 2 && y < PHYSICAL_HEIGHT as u8 / 2 {
            (true, true)  //  Top left quadrant: Flip horizontally and vertically
        } else if x >= PHYSICAL_WIDTH as u8 / 2 && y < PHYSICAL_HEIGHT as u8 / 2 {
            (false, true)   //  Top right quadrant: Flip vertically
        } else if x < PHYSICAL_WIDTH as u8 / 2 && y >= PHYSICAL_HEIGHT as u8 / 2 {
            (true, false)   //  Bottom left quadrant: Flip horizontally
        } else {
            (false, false)    //  Bottom right quadrant: Don't flip
        };
    let x_normalised = 
        if flip.0 { PHYSICAL_WIDTH as u8 / 2 - x } 
        else      { x - PHYSICAL_WIDTH as u8 / 2 };
    let y_normalised = 
        if flip.1 { PHYSICAL_HEIGHT as u8 / 2 - y }
        else      { y - PHYSICAL_HEIGHT as u8 / 2 };
    let p = map_physical_to_virtual_normalised(x_normalised, y_normalised);  //  Returns (x,y)
    let p2 = (
        if flip.0 { SCREEN_WIDTH as u8 / 2 - p.0 } 
        else      { p.0 + SCREEN_WIDTH as u8 / 2 }
        ,
        if flip.1 { SCREEN_HEIGHT as u8 / 2 - p.1 } 
        else      { p.1 + SCREEN_HEIGHT as u8 / 2 }
    );
    //  Crop to screen size
    (
        p2.0.min(SCREEN_WIDTH as u8 - 1),
        p2.1.min(SCREEN_HEIGHT as u8 - 1),
    )
}

/// For each Virtual (x,y) Coordinate, return the Bounding Box (left, top, right, bottom) that encloses the corresponding Physical (x,y) Coordinates.
/// Used by the CHIP-8 Emulator to decide which Physical Pixels to redraw when a Virtual Pixel is updated.
/// (x,y) must belong to the X >= 0, Y >= 0 quadrant
fn map_virtual_to_physical_normalised(x: u8, y: u8) -> (u8, u8, u8, u8) {
    let x_index = x.min(VIRTUAL_TO_PHYSICAL_MAP_WIDTH as u8 - 1);
    let y_index = y.min(VIRTUAL_TO_PHYSICAL_MAP_HEIGHT as u8 - 1);
    let physical_box = VIRTUAL_TO_PHYSICAL_MAP[y_index as usize][x_index as usize];  //  Returns (left,top,right,bottom)
    physical_box
}

/// For each Virtual (x,y) Coordinate, return the Bounding Box (left, top, right, bottom) that encloses the corresponding Physical (x,y) Coordinates.
/// Used by the CHIP-8 Emulator to decide which Physical Pixels to redraw when a Virtual Pixel is updated.
/// Since X and Y are symmetric, this grid only covers one quadrant (X >= 0, Y >= 0)
static VIRTUAL_TO_PHYSICAL_MAP: &[[(u8,u8,u8,u8); VIRTUAL_TO_PHYSICAL_MAP_WIDTH]; VIRTUAL_TO_PHYSICAL_MAP_HEIGHT] = &  //  Row=Y, Col=X
[                      //  Copied from output of https://github.com/lupyuen/interpolate-surface
    [                  //  Virtual Row 0
        (0,0,4,6),     //  Virtual Row 0, Col 0    => Physical Left Col 0,   Top Row 0, Right Col 4,  Bottom Row 6
        (5,0,8,6),     //  Virtual Row 0, Col 1    => Physical Left Col 5,   Top Row 0, Right Col 8,  Bottom Row 6
        ...
        (116,0,119,4), //  Virtual Row 0, Col 31   => Physical Left Col 116, Top Row 0, Right Col 119, Bottom Row 4
    ],    
    [                  //  Virtual Row 1
        (0,7,4,12),    //  Virtual Row 1, Col 0    => Physical Left Col 0,   Top Row 7, Right Col 4,  Bottom Row 12
        (5,7,8,12),    //  Virtual Row 1, Col 1    => Physical Left Col 5,   Top Row 7, Right Col 8,  Bottom Row 12
        ...
        (116,5,119,9), //  Virtual Row 1, Col 31   => Physical Left Col 116, Top Row 5, Right Col 119, Bottom Row 9
    ],
...

/// For each Virtual (x,y) Coordinate, return the Bounding Box (left, top, right, bottom) that encloses the corresponding Physical (x,y) Coordinates.
/// Used by the CHIP-8 Emulator to decide which Physical Pixels to redraw when a Virtual Pixel is updated.
#[cfg(feature = "chip8_curve")]  //  If we are rendering CHIP8 Emulator as curved surface...
fn map_virtual_to_physical(x: u8, y: u8) -> (u8, u8, u8, u8) {
    //  Check which quadrant (x,y) belongs to and flip accordingly
    let flip =  //  (flip for X, flip for Y)
        if x < SCREEN_WIDTH as u8 / 2 && y < SCREEN_HEIGHT as u8 / 2 {
            (true, true)  //  Top left quadrant: Flip horizontally and vertically
        } else if x >= SCREEN_WIDTH as u8 / 2 && y < SCREEN_HEIGHT as u8 / 2 {
            (false, true)   //  Top right quadrant: Flip vertically
        } else if x < SCREEN_WIDTH as u8 / 2 && y >= SCREEN_HEIGHT as u8 / 2 {
            (true, false)   //  Bottom left quadrant: Flip horizontally
        } else {
            (false, false)    //  Bottom right quadrant: Don't flip
        };
    let x_normalised = 
        if flip.0 { SCREEN_WIDTH as u8 / 2 - x } 
        else      { x - SCREEN_WIDTH as u8 / 2 };
    let y_normalised = 
        if flip.1 { SCREEN_HEIGHT as u8 / 2 - y }
        else      { y - SCREEN_HEIGHT as u8 / 2 };
    let b = map_virtual_to_physical_normalised(x_normalised, y_normalised);  //  Returns (left,top,right,bottom)
    let b2 = (
        if flip.0 { PHYSICAL_WIDTH as u8 / 2 - b.0 } 
        else      { b.0 + PHYSICAL_WIDTH as u8 / 2 }
        ,
        if flip.1 { PHYSICAL_HEIGHT as u8 / 2 - b.1 } 
        else      { b.1 + PHYSICAL_HEIGHT as u8 / 2 }
        ,
        if flip.0 { PHYSICAL_WIDTH as u8 / 2 - b.2 } 
        else      { b.2 + PHYSICAL_WIDTH as u8 / 2 }
        ,
        if flip.1 { PHYSICAL_HEIGHT as u8 / 2 - b.3 } 
        else      { b.3 + PHYSICAL_HEIGHT as u8 / 2 }
    );
    //  Crop to screen size
    let crop = (
        b2.0.min(PHYSICAL_WIDTH as u8 - 1),   //  Left
        b2.1.min(PHYSICAL_HEIGHT as u8 - 1),  //  Top
        b2.2.min(PHYSICAL_WIDTH as u8 - 1),   //  Right
        b2.3.min(PHYSICAL_HEIGHT as u8 - 1),  //  Bottom
    );
    //  Flip left and right, top and bottom if necessary
    let result = (
        crop.0.min(crop.2),  //  Left
        crop.1.min(crop.3),  //  Top
        crop.0.max(crop.2),  //  Right
        crop.1.max(crop.3),  //  Bottom
    );
    assert!(result.0 <= result.2 && result.1 <= result.3, "flip error");  //  Left <= Right and Top <= Bottom
    result
}

/// Implement the Iterator for Virtual Pixels in a Virtual Block
impl Iterator for PixelIterator {
    /// This Iterator returns Physical Pixel colour words (16-bit)
    type Item = u16;
    ...    
    /// Return the next Physical Pixel colour
    #[cfg(feature = "chip8_curve")]  //  If we are rendering CHIP8 Emulator as curved surface...
    fn next(&mut self) -> Option<Self::Item> {
        if self.y_physical > self.physical_bottom { return None; }  //  No more Physical Pixels
        assert!(self.x_physical < PHYSICAL_WIDTH as u8, "x overflow");
        assert!(self.y_physical < PHYSICAL_HEIGHT as u8, "y overflow");

        //  Map the Physical Pixel to the Virtual Pixel
        let virtual_pixel = map_physical_to_virtual(self.x_physical, self.y_physical);

        if self.x == virtual_pixel.0 && self.y == virtual_pixel.1 {
            //  If rendering the same Virtual Pixel, increment the offset
            self.x_offset += 1;
        } else {
            //  If rendering a different Virtual Pixel, reset the offset
            self.x = virtual_pixel.0;
            self.y = virtual_pixel.1;
            self.x_offset = 0;
            self.y_offset = 0;
        }

        //  Get the colour from the Virtual Screen Buffer
        let color = self.get_color();

        //  Loop over x_physical from physical_left to physical_right
        self.x_physical += 1;
        if self.x_physical > self.physical_right {
            self.x_physical = self.physical_left;
            //  Loop over y_physical from physical_top to physical_bottom
            self.y_physical += 1;
        }
        
        //  Return the Physical Pixel color
        return Some(color);
    }    

/// Return Bounding Box of Physical Pixels (left, top, right, bottom) that correspond to the Virtual Pixels
#[cfg(feature = "chip8_curve")]  //  If we are rendering CHIP8 Emulator as curved surface...
fn get_bounding_box(virtual_left: u8, virtual_top: u8, virtual_right: u8, virtual_bottom: u8) -> (u8, u8, u8, u8) {
    //  One Virtual Pixel may map to multiple Physical Pixels, so we lookup the Physical Bounding Box.
    //  TODO: Handle wide and tall Bounding Boxes
    let physical_left_top = map_virtual_to_physical(virtual_left, virtual_top);  //  Returns (left,top,right,bottom)
    let physical_right_bottom = map_virtual_to_physical(virtual_right, virtual_bottom);

    let left: u8 = physical_left_top.0;
    let top: u8 = physical_left_top.1;
    let right: u8 = physical_right_bottom.2.min(PHYSICAL_WIDTH as u8 - 1);
    let bottom: u8 = physical_right_bottom.3.min(PHYSICAL_HEIGHT as u8 - 1);
    assert!(left < PHYSICAL_WIDTH as u8 && top < PHYSICAL_HEIGHT as u8 && right < PHYSICAL_WIDTH as u8 && bottom < PHYSICAL_HEIGHT as u8, "overflow");
    ( left, top, right, bottom )  //  Return the Physical Bounding Box
}