Steve2/A2Mac/HiRes.swift

//
//  HiRes.swift
//  Steve ][
//
//  Created by Tamas Rudnai on 9/19/19.
//  Copyright © 2019, 2020 Tamas Rudnai. All rights reserved.
//
// This file is part of Steve ][ -- The Apple ][ Emulator.
//
// Steve ][ is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Steve ][ is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Steve ][.  If not, see <https://www.gnu.org/licenses/>.
//

//import Foundation
import AppKit

class HiRes: NSView {

    static let PageSize  = 0x2000
    static let Page1Addr = 0x2000
    static let Page2Addr = 0x4000
    
    static let PixelWidth  = 280
    static let PixelMixedHeight = 160
    static let PixelHeight = 192
    static let MixedTextHeight = 4
    static let MixedHeight = 160
    static let blockRows = 24
    static let blockCols = 40
    static let blockWidth = PixelWidth / blockCols
    static let blockHeight = PixelHeight / blockRows

    let HiResBuffer1 = UnsafeRawBufferPointer(start: MEM + Page1Addr, count: PageSize * 2)
    let HiResBuffer2 = UnsafeRawBufferPointer(start: MEM + Page2Addr, count: PageSize * 2)
    var HiResBufferPointer = UnsafeRawBufferPointer(start: MEM + Page1Addr, count: PageSize * 2)
    
    let HiResRawPointer = UnsafeRawPointer(RAM + Page1Addr)

    // holds the starting addresses for each lines minus the screen page starting address
    var HiResLineAddrTbl = [Int](repeating: 0, count: PixelHeight)

    func initHiResLineAddresses() {
        var i = 0
        for x in stride(from: 0, through: 0x50, by: 0x28) {
            for y in stride(from: 0, through: 0x380, by: 0x80) {
                for z in stride(from: 0, through: 0x1C00, by: 0x400) {
                    HiResLineAddrTbl[i] = x + y + z
                    i += 1
                }
            }
        }
    }
    
    
    var HiResSubView = [[NSView]]()

    func createHiRes() {
        for y in 0 ..< HiRes.blockRows {
            HiResSubView.append([NSView]())
            for x in 0 ..< HiRes.blockCols {
                let blockView = NSView(frame: NSRect(x: x * HiRes.blockWidth, y: y * 8, width: HiRes.blockWidth, height: 8))
                HiResSubView[y].append(blockView)
                self.addSubview(blockView)
            }
        }
    }
    
    
    func clearScreen() {
        HiRes.context?.clear( CGRect(x: 0, y: 0, width: frame.width, height: frame.height) )
        needsDisplay = true
    }


    required init?(coder aDecoder: NSCoder) {
        pixelsSRGB = HiRes.context?.data?.bindMemory(to: UInt32.self, capacity: HiRes.ScreenBitmapSize)

        super.init(coder: aDecoder)
        initHiResLineAddresses()
        clearScreen()

//        currentContext?.setShouldAntialias(false)
//        currentContext?.interpolationQuality = CGInterpolationQuality.none
        
//        let scaleSizeW = Double((frame.size).width) / Double(HiRes.PixelWidth)
//        let scaleSizeH = Double((frame.size).height) / Double(HiRes.PixelHeight)

//        let scaleSizeW = 4
//        let scaleSizeH = 4
//        scaleUnitSquare(to: NSSize(width: scaleSizeW, height: scaleSizeH))
        
        // create smaller box views for draw optimization
        createHiRes()
        
    }
    
    override init(frame: CGRect) {
        super.init(frame: frame)
    }
    
        
    static func createBitmapContext(pixelsWide: Int, _ pixelsHigh: Int) -> CGContext? {
        let bytesPerPixel = 4
        let bytesPerRow = bytesPerPixel * pixelsWide
        
        let byteCount = (bytesPerRow * pixelsHigh)
        
//        guard let colorSpace = CGColorSpace(name: CGColorSpace.linearSRGB) else { return nil }
//        guard let colorSpace = CGColorSpace(name: CGColorSpace.genericRGBLinear) else { return nil }
        guard let colorSpace = CGColorSpace(name: CGColorSpace.sRGB) else { return nil }

        let pixels = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: byteCount)

        let bitmapInfo = CGImageAlphaInfo.premultipliedFirst.rawValue | CGBitmapInfo.byteOrder32Little.rawValue
        
        let context = CGContext(
            data: pixels,
            width: pixelsWide,
            height: pixelsHigh,
            bitsPerComponent: 8,
            bytesPerRow: bytesPerRow,
            space: colorSpace,
            bitmapInfo: bitmapInfo)
        
        return context
    }
    

    private var currentContext : CGContext? {
        get {
            if #available(OSX 10.10, *) {
                return NSGraphicsContext.current?.cgContext
            } else if let contextPointer = NSGraphicsContext.current?.graphicsPort {
                let context: CGContext = Unmanaged.fromOpaque(contextPointer).takeUnretainedValue()
                return context
            }
            
            return nil
        }
    }

    static let ScreenBitmapSize = (PixelWidth * 2 * PixelHeight * 4)
    static let context = createBitmapContext(pixelsWide: PixelWidth * 2, PixelHeight)
    static let pixels = UnsafeMutableRawBufferPointer(start: context?.data, count: ScreenBitmapSize)
//    static var pixelsSRGB = pixels.bindMemory(to: UInt32.self)
    
    let R = 2
    let G = 1
    let B = 0
    let A = 3
    
//    var blockChanged = [Bool](repeating: false, count: HiRes.blockRows * HiRes.blockCols)
    var shadowScreen = [Int](repeating: 0, count: PageSize)

    var was = 0;
    
    
    //    let color_black     : UInt32 = 0x00000000;
    //    let color_white     : UInt32 = 0xEEEEEEEE;
    //    let color_purple    : UInt32 = 0xFFBB11EE;
    //    let color_green     : UInt32 = 0xFF0BBB11;
    //    let color_blue      : UInt32 = 0xFF1155FF;
    //    let color_orange    : UInt32 = 0xFFEE2211;
    
    // HiRes Colors for the SRGB color space
    let color_black     : UInt32 = 0x00000000
    let color_white     : UInt32 = 0xFFEEEEEE
    let color_purple    : UInt32 = 0xFFDD55FF
    let color_green     : UInt32 = 0xFF2BD84A
    let color_blue      : UInt32 = 0xFF5599FF
    let color_orange    : UInt32 = 0xFFFF6302
    
    // for debugging only:
    let color_turquis   : UInt32 = 0xFF11BBBB
    let color_yellow    : UInt32 = 0xFFBBBB11
    
    // default is green
    var monoColor       : UInt32 = 0xFF2BD84A
    
    static let refreshUnderscan: CGFloat = 1;
    static let refreshOverscan : CGFloat = refreshUnderscan * 2;
    
    func refreshChanged( blockSize : Int ) {
        // refresh changed block only
        
        let screenBlockMargin = 16 / blockSize
        
        let blockScreenWidth = CGFloat(frame.width) / CGFloat(HiRes.blockCols) * CGFloat(blockSize)
        let blockScreenHeigth = CGFloat(frame.height) / CGFloat(HiRes.blockRows)
        
        for blockVertIdx in 0 ..< HiRes.blockRows {
            for blockHorIdx in 0 ..< HiRes.blockCols / blockSize {
                if blockChanged[ blockVertIdx * HiRes.blockCols / blockSize + blockHorIdx ] != 0 {
                    // refresh the entire screen
                    let x = CGFloat(blockHorIdx) * blockScreenWidth - CGFloat(screenBlockMargin)
                    let y = frame.height - CGFloat(blockVertIdx) * blockScreenHeigth - blockScreenHeigth - CGFloat(screenBlockMargin)
                    let w = blockScreenWidth + CGFloat(screenBlockMargin) * CGFloat(blockSize)
                    let h = blockScreenHeigth + CGFloat(screenBlockMargin) * CGFloat(blockSize)
                    
                    let boundingBox = CGRect(
                        x: x - HiRes.refreshUnderscan,
                        y: y - HiRes.refreshUnderscan,
                        width: w + HiRes.refreshOverscan,
                        height: h + HiRes.refreshOverscan
                    )
                    self.setNeedsDisplay( boundingBox )
                }
            }
        }
    }


    let usePixelTrail = true
    
//    let pixelTrail = 2 // maybe too fast?
//    let pixelTrail = 1.5
//    let pixelTrail = 1.4 // maybe a bit slow?
//    let pixelTrail = 1.35 // maybe too slow?
//    let pixelTrail = 1.25 // maybe too slow?
    
    func RenderMono() {
        var height = HiRes.PixelHeight

        // do not even render it...
        if videoMode.text == 1 {
            return
        }
        else {
            if videoMode.mixed == 1 {
                height = HiRes.MixedHeight
            }
            if MEMcfg.txt_page_2 == 1 {
                HiResBufferPointer = HiResBuffer2
            }
            else {
                HiResBufferPointer = HiResBuffer1
            }
        }

        var pixelAddr = 0

        var y = 0

//        blockChanged = [Bool](repeating: false, count: HiRes.blockRows * HiRes.blockCols)

        if ( ViewController.shared?.CRTMonitor ?? false ) {
            // do not clear the changes table
        }
        else {
            hires_clearChanges()
        }

        for lineAddr in HiResLineAddrTbl {
            if ( height <= 0 ) {
                break
            }
            height -= 1

            let blockVertIdx = y / HiRes.blockHeight * HiRes.blockCols
            var prevColor = color_black

            for blockHorIdx in 0..<HiRes.blockCols {
                let block = Int(HiResBufferPointer[ Int(lineAddr + blockHorIdx) ])
                let screenIdx = y * HiRes.blockCols + blockHorIdx

                // get all changed blocks
                if shadowScreen[ screenIdx ] != block {
                    blockChanged[ blockVertIdx + blockHorIdx ] = 0xFF
                }
                else if usePixelTrail && ( ViewController.shared?.CRTMonitor ?? false ) {
                    // slow CRT fade out effect
                    if (y % HiRes.blockHeight == 0) && (blockChanged[ blockVertIdx + blockHorIdx ] > 0) {
                        blockChanged[ blockVertIdx + blockHorIdx ] = UInt8( Double(blockChanged[ blockVertIdx + blockHorIdx ]) / pixelTrail )
                    }
                }
                else {
                    blockChanged[ blockVertIdx + blockHorIdx ] = 0
                }
                
                shadowScreen[ screenIdx ] = block

                let highBit = (block >> 7) & 1

                for bit in stride(from: 0, through: 6, by: 1) {
                    let bitMask = 1 << bit
                    if (block & bitMask) != 0 {
                        pixelsSRGB[pixelAddr + highBit]     = monoColor
                        pixelsSRGB[pixelAddr + highBit + 1] = monoColor
                        if highBit == 1 && prevColor == monoColor {
                            pixelsSRGB[pixelAddr] = monoColor
                        }
                        prevColor = monoColor
                    }
                    else if usePixelTrail && ( ViewController.shared?.CRTMonitor ?? false ) {
                        var srgb = pixelsSRGB[pixelAddr + highBit]

                        let s = srgb >> 24 & 0xFF
                        let r = srgb >> 16 & 0xFF
                        let g = srgb >>  8 & 0xFF
                        let b = srgb >>  0 & 0xFF

                        srgb = UInt32(Double(s) / pixelTrail) << 24
                             | UInt32(Double(r) / pixelTrail) << 16
                             | UInt32(Double(g) / pixelTrail) << 8
                             | UInt32(Double(b) / pixelTrail)

                        pixelsSRGB[pixelAddr + highBit]     = srgb;
                        pixelsSRGB[pixelAddr + highBit + 1] = srgb;
                    }
                    else {
                        pixelsSRGB[pixelAddr + highBit]     = color_black
                        pixelsSRGB[pixelAddr + highBit + 1] = color_black
                        prevColor = color_black
                    }

                    pixelAddr += 2 // two physical pixels per logical pixel
                }
            }

            y += 1
        }

//        hires_renderMono()
        
        refreshChanged(blockSize: 1)
    }
        
    
    func colorPixel ( pixelAddr : Int, pixel : Int, prev : Int ) {
        let colorAddr = pixelAddr / 4
        
        switch ( pixel ) {
        case 1: // purple (bits are in reverse!)
            pixelsSRGB[colorAddr]     = color_purple
            pixelsSRGB[colorAddr + 1] = color_purple
            pixelsSRGB[colorAddr + 2] = color_purple
            if  (colorAddr >= 2) && (prev != 0x03) && (prev != 0x07) && (prev != 0x00) && (prev != 0x04) {
                pixelsSRGB[colorAddr - 1] = color_purple
                pixelsSRGB[colorAddr - 2] = color_purple
            }
            
        case 2: // green
            // reducing color bleeding
            if (colorAddr > 1) && (pixelsSRGB[colorAddr - 2] != color_black) {
                pixelsSRGB[colorAddr + 0] = color_green
            }
            pixelsSRGB[colorAddr]     = color_green
            pixelsSRGB[colorAddr + 1] = color_green
            pixelsSRGB[colorAddr + 2] = color_green
            pixelsSRGB[colorAddr + 3] = color_green

        case 3: // white 1
//            if ( colorAddr >= 2 ) && ( pixelsSRGB[colorAddr - 2] != color_black ) {
//                pixelsSRGB[colorAddr - 2] = color_white // HiRes.pixelsSRGB[colorAddr - 2]
//            }
//            if (colorAddr >= 1) {
//                HiRes.pixelsSRGB[colorAddr - 1] = color_yellow
//            }
            pixelsSRGB[colorAddr - 1] = color_white
            pixelsSRGB[colorAddr + 0] = color_white
            pixelsSRGB[colorAddr + 1] = color_white
            pixelsSRGB[colorAddr + 2] = color_white
            pixelsSRGB[colorAddr + 3] = color_white
            pixelsSRGB[colorAddr + 4] = color_white

        case 5: // blue
            pixelsSRGB[colorAddr + 1] = color_blue
            pixelsSRGB[colorAddr + 2] = color_blue
            pixelsSRGB[colorAddr]     = color_blue
            pixelsSRGB[colorAddr - 1] = color_blue
            if  (colorAddr >= 2) && (prev != 0x00) && (prev != 0x04) {
                pixelsSRGB[colorAddr - 2] = color_blue
            }

        case 6: // orange
            // reducing color bleeding
            if (colorAddr > 0) && (pixelsSRGB[colorAddr - 2] != color_black) {
                pixelsSRGB[colorAddr + 0] = color_orange // important for color bleeding and color contiunity
                pixelsSRGB[colorAddr + 1] = color_orange
            }
            pixelsSRGB[colorAddr + 2] = color_orange
            pixelsSRGB[colorAddr + 3] = color_orange
            pixelsSRGB[colorAddr + 4] = color_orange

        case 7: // white 2
            if ( colorAddr >= 2 ) && ( pixelsSRGB[colorAddr - 2] != color_black ) {
//                pixelsSRGB[colorAddr - 2] = color_white // HiRes.pixelsSRGB[colorAddr - 2]
                pixelsSRGB[colorAddr - 1] = color_white
            }
            pixelsSRGB[colorAddr + 0] = color_white // Donkey Kong would be perfect but problem in Sneakers
            pixelsSRGB[colorAddr + 1] = color_white
            pixelsSRGB[colorAddr + 2] = color_white
            pixelsSRGB[colorAddr + 3] = color_white
            pixelsSRGB[colorAddr + 4] = color_white

        case 0: // 0x00 (black 1), 0x04 (black 2)
//            pixelsSRGB[colorAddr + 0] = color_black
            pixelsSRGB[colorAddr + 1] = color_black
            pixelsSRGB[colorAddr + 2] = color_black
            pixelsSRGB[colorAddr + 3] = color_black

            // white adjustment
//            if (colorAddr >= 2) && ((prev == 3) || (prev == 7)) {
            if (colorAddr >= 2) && (prev == 7) {
                pixelsSRGB[colorAddr - 1] = color_black
                pixelsSRGB[colorAddr - 0] = color_black
            }
            // blue adjustment
            if (colorAddr >= 2) && (prev == 5) {
                pixelsSRGB[colorAddr - 1] = color_black
            }

        case 4: // 0x00 (black 1), 0x04 (black 2)
            pixelsSRGB[colorAddr + 1] = color_black
            pixelsSRGB[colorAddr + 2] = color_black
            pixelsSRGB[colorAddr + 3] = color_black
            pixelsSRGB[colorAddr + 4] = color_black

            // white adjustment
//            if (colorAddr >= 2) && ((prev == 3) || (prev == 7)) {
            if (colorAddr >= 2) && (prev == 7) {
                pixelsSRGB[colorAddr - 0] = color_black
            }
            // blue adjustment
            if (colorAddr >= 2) && (prev == 5) {
                pixelsSRGB[colorAddr - 0] = color_black
                pixelsSRGB[colorAddr - 1] = color_black
//                pixelsSRGB[colorAddr - 2] = color_black // if i put that in there is ladder on Donkey Kong is too thin
            }


//            let pp = pixelAddr - 1 // HiRes.pixelAddrBlockIncrement
//            let cp = pixelsSRGB[pp / 4]
//
//            let pa = pixelAddr - HiRes.pixelAddrBlockIncrement * 7 * 20
//            let ca = pixelsSRGB[pa / 4]
//
//            if cp == ca {
//                switch cp {
//                case color_blue, color_white, color_green, color_purple, color_orange, color_yellow:
////                    pixelsSRGB[pp/4] = color_turquis
////                    pixelsSRGB[pa/4] = color_yellow
//
//                    let c1 = ca & 0x00FFFFFF
//                    let a = ca >> 24
//                    let a1 = (a / 6) << 24
//                    let a2 = a1 * 2
//                    let a3 = a1 * 3
//                    let a4 = a1 * 4
//
////                    pixelsSRGB[colorAddr + 0] = a4 | c1
////                    pixelsSRGB[colorAddr + 1] = a3 | c1
////                    pixelsSRGB[colorAddr + 2] = a2 | c1
////                    pixelsSRGB[colorAddr + 3] = a1 | c1
//
//                    pixelsSRGB[colorAddr + 0] = a4 | c1
//                    pixelsSRGB[colorAddr + 1] = a2 | c1
//
//                //            let pb = pixelAddr + HiRes.pixelAddrBlockIncrement * 7 * 20
//                //            let cb = pb / 4
//                //            pixelsSRGB[cb] = pixelsSRGB[colorAddr]
//                default:
//                    break
//                }
//
//            }

        default:
            break
        }

        // white adjustment
        if ( (prev & 2) == 2 ) && ( (pixel & 1) == 1 ) {
            pixelsSRGB[colorAddr]     = color_white
            pixelsSRGB[colorAddr + 1] = color_white
            if colorAddr >= 2 {
                pixelsSRGB[colorAddr - 1] = color_white
                pixelsSRGB[colorAddr - 2] = color_white
                pixelsSRGB[colorAddr - 3] = color_white
            }
            // blue expansion
            if pixel == 5 {
                pixelsSRGB[colorAddr + 2] = color_black
                pixelsSRGB[colorAddr + 3] = color_black
                pixelsSRGB[colorAddr + 4] = color_black
            }
            
            // TODO: Need better check if extra green was created
            if (colorAddr >= 4) && (pixelsSRGB[colorAddr - 4] == color_green ) {
                if (colorAddr < 6) || (pixelsSRGB[colorAddr - 6] != color_green) {
                    pixelsSRGB[colorAddr - 3] = color_black
                    pixelsSRGB[colorAddr - 4] = color_black
                }
            }
        }

//        // green adjustment -- followed by white
//        if (colorAddr >= 1) && (prev == 0x03) && (HiRes.pixelsSRGB[colorAddr - 1] = color_green) {
//            HiRes.pixelsSRGB[colorAddr - 1] = color_green
//        }

        // purple adjustment -- followed by white
        if (prev == 0x01) && (
            (pixel == 0x01) ||
            (pixel == 0x03) || (pixel == 0x07)  // white
        ) {
            // was the previous purple pixel promoted to white or is it still purple?
            if (colorAddr >= 4) && ( pixelsSRGB[colorAddr - 4] == color_purple ) {
                pixelsSRGB[colorAddr - 1] = color_purple
                pixelsSRGB[colorAddr - 2] = color_purple
            }
        }

        // blue adjustment -- followed by white
        else if (prev == 0x05) && (
            (pixel == 0x05)
         || (pixel == 0x03)
         || (pixel == 0x07)  // white
        ) {
//            pixelsSRGB[colorAddr - 0] = color_blue
//            pixelsSRGB[colorAddr - 1] = color_blue
            pixelsSRGB[colorAddr - 2] = color_blue // blue color  bleed
        }

    }


    static let logicalPixels = 8
    static let physicalPixels = 2
    static let pixelAddrBlockIncrement = logicalPixels * physicalPixels // 2 display pixels per logical pixel

    func RenderColor() {
        var height = HiRes.PixelHeight
        
        // do not even render it...
        if videoMode.text == 1 {
            return
        }
        else {
            if videoMode.mixed == 1 {
                height = HiRes.MixedHeight
            }
            if MEMcfg.txt_page_2 == 1 {
                HiResBufferPointer = HiResBuffer2
            }
            else {
                HiResBufferPointer = HiResBuffer1
            }
        }
        
        var pixelAddr = 0
        
        var y = 0
        
//        blockChanged = [Bool](repeating: false, count: HiRes.blockRows * HiRes.blockCols / 2)
        
        hires_clearChanges()
        
        HiRes.context?.clear( CGRect(x: 0, y: 0, width: frame.width, height: frame.height) )
        
        for lineAddr in HiResLineAddrTbl {
            
            if ( height <= 0 ) {
                break
            }
            height -= 1
            
            let blockVertIdx = y / HiRes.blockHeight * HiRes.blockCols / 2
            var prev = 0

            for blockHorIdx in 0 ..< HiRes.blockCols / 2 {
//                print("blockVertIdx:", blockVertIdx, "   blockHorIdx:", blockHorIdx)
                
                let blockH = Int(HiResBufferPointer[ Int(lineAddr + blockHorIdx * 2) ])
                let blockH7 = ( blockH >> 5 ) & 0x04
                let blockL = Int(HiResBufferPointer[ Int(lineAddr + blockHorIdx * 2) + 1 ])
                let blockL7 = ( blockL >> 5 ) & 0x04
                
                let block = ( ( blockL & 0x7F ) << 7 ) | ( blockH & 0x7F )
                let block14 = ( blockL << 8 ) | blockH

                let screenIdx = y * HiRes.blockCols + blockHorIdx
                
                // get all changed blocks
                blockChanged[ blockVertIdx + blockHorIdx ] = ((blockChanged[ blockVertIdx + blockHorIdx ] != 0) || (shadowScreen[ screenIdx ] != block14)) ? 1 : 0
                shadowScreen[ screenIdx ] = block14
                
                for px in 0 ... 2  {
                    //                        let bitMask = 3 << ( px * 2 )
                    let pixel = blockH7 | ( (block >> (px * 2)) & 3 )
                    colorPixel(pixelAddr: pixelAddr, pixel: pixel, prev: prev )
                    pixelAddr += HiRes.pixelAddrBlockIncrement
                    prev = pixel
                }
                
                let pixel = (blockL7 | blockH7) | ( (block >> (3 * 2)) & 3 )
                colorPixel(pixelAddr: pixelAddr, pixel: pixel, prev: prev )
                pixelAddr += HiRes.pixelAddrBlockIncrement
                prev = pixel
                
                for px in 4 ... 6  {
                    //                        let bitMask = 3 << ( px * 2 )
                    let pixel = blockL7 | ( (block >> (px * 2)) & 3 )
                    colorPixel(pixelAddr: pixelAddr, pixel: pixel, prev: prev )
                    pixelAddr += HiRes.pixelAddrBlockIncrement
                    prev = pixel
                }
            }
            y += 1
        }

        
        // refresh changed block only
        refreshChanged(blockSize: 2)
//        needsDisplay = true // refresh the entire screen

    }


    func Render() {
        if ( ViewController.shared?.ColorMonitor ?? true ) {
            RenderColor()
        }
        else {
            RenderMono()
        }
    }

    func RenderFullScreen() {
        needsDisplay = true
        Render()
    }
    
    
    override func draw(_ rect: CGRect) {
        guard let image = HiRes.context?.makeImage() else { return }

        // refresh the entire screen
        let boundingBox = CGRect(x: 0, y: 0, width: frame.width, height: frame.height)
        
        if ( ViewController.shared?.CRTMonitor ?? false ) {
            currentContext?.interpolationQuality = .high // TODO: Make a switch that lets you turn on and off "old monitor effects"
        }
        else {
            currentContext?.interpolationQuality = .high // .none
        }
        currentContext?.draw(image, in: boundingBox)
    }


    
}