Screen.jack

// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/12/Screen.jack
/**
 * A library of functions for displaying graphics on the screen.
 * The Hack physical screen consists of 512 rows (indexed 0..511, top to bottom)
 * of 256 pixels each (indexed 0..255, left to right). The top left pixel on 
 * the screen is indexed (0,0).
 */
class Screen {
    static boolean currentColor;
    static Array twoToThe;
    /** Initializes the Screen. */
    function void init() {
        let currentColor = true;

        let twoToThe = Array.new(16);
		let twoToThe[0] = 1;
		let twoToThe[1] = 2;
		let twoToThe[2] = 4;
		let twoToThe[3] = 8;
		let twoToThe[4] = 16;
		let twoToThe[5] = 32;
		let twoToThe[6] = 64;
		let twoToThe[7] = 128;
		let twoToThe[8] = 256;
		let twoToThe[9] = 512;
		let twoToThe[10] = 1024;
		let twoToThe[11] = 2048;
		let twoToThe[12] = 4096;
		let twoToThe[13] = 8192;
		let twoToThe[14] = 16384;
		let twoToThe[15] = 16384 + 16384;
		return;
    }

    /** Erases the entire screen. */
    function void clearScreen() {
        var int address;
        let address = 16384;

        while (address < 24576) {
            do Memory.poke(address, 0);
            let address = address + 1;
        }
        return;
    }

    /** Sets the current color, to be used for all subsequent drawXXX commands.
     *  Black is represented by true, white by false. */
    function void setColor(boolean b) {
        let currentColor = b;
        return;
    }

    /** Draws the (x,y) pixel, using the current color. */
    function void drawPixel(int x, int y) {
        var int pixelAddress, currentValue, targetPixel, modifiedValue;
        let pixelAddress = 16384 + (y * 32) + (x / 16);

        let currentValue = Memory.peek(pixelAddress);
        let targetPixel = twoToThe[(x & 15)];

        if (currentColor) {
            let modifiedValue = currentValue | targetPixel;
        }
        else {
            let modifiedValue = currentValue & -targetPixel;
        }
        do Memory.poke(pixelAddress, modifiedValue);
        return;
    }

    /** Draws a line from pixel (x1,y1) to pixel (x2,y2), using the current color. */
    function void drawLine(int x1, int y1, int x2, int y2) {
        var int a, b, diff, dx, dy;
		
		let dx = x2 - x1;
		let dy = y2 - y1;
		let a = 0;
		let b = 0;
		let diff = a * dy - b * dx;
		
		if ((dx > 0) & (dy > 0)){
			while(~(a > dx) & ~(b > dy)){
				do Screen.drawPixel(x1 + a,y1 + b);
				if (diff < 0) {
                    let a = a + 1; 
                    let diff = diff + dy;
                }
				else {
                    let b = b + 1; 
                    let diff = diff - dx;
                }
			}
			return;
		}
		
		if ((dx = 0) & (dy > 0)){
			while(~(b > dy)){
				do Screen.drawPixel(x1, y1 + b);
				let b = b + 1;			
			}
			return;
		}
		
		if ((dx = 0) & (dy < 0)){
			while(~(b > Math.abs(dy))){
				do Screen.drawPixel(x2, y2 + b);
				let b = b + 1;
			}
			return;
		}

		if ((dx < 0) & (dy = 0)){
			while(~(a > Math.abs(dx))){
				do Screen.drawPixel(x2 + a, y2);
				let a = a + 1;
			}
			return;
		}

		if ((dx > 0) & (dy = 0)){
			while(~(a > dx)){
				do Screen.drawPixel(x1 + a, y1);
				let a = a + 1;
			}
			return;
		}

		if((dx > 0) & (dy < 0)){
			while(~(a > dx) & ~(b > Math.abs(dy))){
				do Screen.drawPixel(x1 + a, y1 - b);
				if (diff < 0) {
                    let a = a + 1; 
                    let diff = diff + Math.abs(dy);
                }
				else {
                    let b = b + 1; 
                    let diff = diff - dx;
                }
			}
			return;
		}

		if((dx < 0) & (dy > 0)){
			while(~(a > Math.abs(dx)) & ~(b > dy)){
				do Screen.drawPixel(x1 - a, y1 + b);
				if (diff < 0) {
                    let a = a + 1; 
                    let diff = diff + dy;
                }
				else {
                    let b = b + 1; 
                    let diff = diff - Math.abs(dx);
                }
			}
			return;
		}

		if((dx < 0) & (dy < 0)){
			while(~(a > Math.abs(dx)) & ~(b > Math.abs(dy))){
				do Screen.drawPixel(x1 - a,y1 - b);
				if (diff < 0) {
                    let a = a + 1; 
                    let diff = diff + Math.abs(dy);
                }
				else {
                    let b = b + 1; 
                    let diff = diff - Math.abs(dx);
                }
			}
			return;
		}

		if((dx = 0) & (dy = 0)){
			do Screen.drawPixel(x1, y1);
			return;
		}
		return;
    }

    /** Draws a filled rectangle whose top left corner is (x1, y1)
     *  and bottom right corner is (x2,y2), using the current color. */
    function void drawRectangle(int x1, int y1, int x2, int y2) {
        while (~(x1>x2)) {
            do Screen.drawLine(x1, y1, x1, y2);
            let x1 = x1 + 1;
        }
        return;
    }

    /** Draws a filled circle of radius r<=181 around (x,y), using the current color. */
    function void drawCircle(int x, int y, int r) {
        var int x1, y1And2, x2, dy;
        let dy = -r;

        while (dy < r) {
            let x1 = x - Math.sqrt((r * r) - (dy * dy));
            let y1And2 = y + dy;
            let x2 = x + Math.sqrt((r * r) - (dy * dy));
            do Screen.drawLine(x1, y1And2, x2, y1And2);
            let dy = dy + 1;
        }
        return;
    }
}