vga.c

Go to the documentation of this file.

//vga.c - vga based out and inp stuff
#include "../lib/types.h"
#include "vga.h"
#include "kb.h"
#include "cm.h"
#include "../lib/err.h"
#include "../lib/utils.h"
 
/**
 * @brief the vga framebuffer pointer
 *
 * vga points to the vga text-mode framebuffer at physical address
 * 0xB8000, each cell is a uint16_t with the lower byte as the
 * character and the upper byte as the color attribute
 *
 * @see prt(), clscr(), scrl()
 */
uint16_t* vga = (uint16_t*)0xB8000;
 
/**
 * @brief scrl scrolls the vga text screen up by one row
 *
 * scrl is a function that shifts all rows up by one and clears
 * the bottom row, used for when text output fills the screen
 *
 * scrl is called automatically by prt when y goes past 24
 *
 * @see prt(), clscr()
 */
void __scrl(void) {
    for (int rw = 1; rw < 25; rw++) { //main row loop
        for (int cl = 0; cl < 80; cl++) { //main collum loop
            int src = rw * 80 + cl; //define source dest
            int dst = (rw - 1) * 80 + cl; //define dest dest
            vga[dst] = vga[src]; //define vga loc
        }
    }
    for (int cl = 0; cl < 80; cl++) { //actual scroll loop
        int btm = 24 * 80 + cl; //bottom def
        vga[btm] = (0x0F << 8) | ' '; //clear bottom row
    }
}
 
/**
 * @brief prt prints a string to the vga screen at a given position
 *
 * prt is a function that writes a null-terminated string to the vga
 * text framebuffer handling newlines, line wrapping, and scrolling
 * @param x, the column to start printing at (0-79)
 * @param y, the row to start printing at (0-24)
 * @param txt, the null-terminated string to print
 * @param col, the vga color attribute byte (0x00-0xFF)
 *
 * using prt is done with
 * @code{.c}
 * #include "../io/vga.h" //or just vga.h
 * prt(0, 0, "hello, kernel!", 0x0F); //white text on black bg
 * @endcode
 *
 * @see scrl(), pchr(), prtd(), prth()
 */
void __prt(int x, int y, const char* txt, uint8_t col) {
    assert(txt != NULL, "prt: NULL string"); //err checking
    if (x >= 80) { x = 79; }; //cases
    if (x < 0) { x = 0; };
    if (y >= 25 && x == 0) {
        scrl(); //scroll
        y = 24; //reset
    } else if (y >= 25 && x > 0) { y = 24; }
    if (y < 0) { y = 0; };
 
 
 
    int ofst = y * 80 + x; //ofst calculation
 
    while (*txt != 0) { //main loop
        assert(ofst >= 0 && ofst < 2000, "prt: vga buffer overflow"); //err handle AFTER calc, do not move
    
        if (*txt == '\n') { //newline handle
            y++; //inc y for the new line
            x = 0; //reset x
            ofst = y * 80 + x; //recalc
        } else {
            vga[ofst] = (col << 8) | *txt; //print txt
            //format is 0x<bg><txtcolor>, ignoring first letter of code, so 0xED is light purple text on a yellow bg
            //0 is black
            //1 is blue
            //2 is green
            //3 is cyan
            //4 is red
            //5 is purple
            //6 is orange
            //7 is light grey
            //8 is dark grey
            //9 is light blue
            //A is light green
            //B is light cyan
            //C is light red
            //D is light purple
            //E is yellow
            //F is white
            ofst++; //increment ofst char loc
            x++; //increment x for check
            if (x >= 80) { //line wrapping check
                x = 0; //reset x
                y++; //inc y for the line wrap
                ofst = y * 80 + x; //recalc
            }
        }
        txt++; //now increment txt++ outside of loops to make sure we dont inc under only one condition
        
        if (y >= 25) {
            scrl(); //scroll stuff and handle
            y = 24; //make y clamp
            ofst = y * 80 + x;
        }
    }    
}
 
/**
 * @brief prtd prints a decimal integer to the vga screen
 *
 * prtd is a function that converts an integer to a decimal string
 * using itoa and prints it at the given position
 * @param x, the column to start printing at
 * @param y, the row to start printing at
 * @param num, the signed integer to print
 * @param col, the vga color attribute byte
 *
 * using prtd is done with
 * @code{.c}
 * #include "../io/vga.h" //or just vga.h
 * prtd(0, 5, 42, 0x0F);
 * @endcode
 *
 * @see prt(), prth(), itoa()
 */
void __prtd(int x, int y, int num, uint8_t col) {
    char buff[12] = {0}; //12 bytes is safe for 32 bit int
    itoa(num, buff); //convert with itoa
    prt(x, y, buff, col); //print
}
 
/**
 * @brief prth prints a 32 bit hex value to the vga screen
 *
 * prth is a function that converts a uint32_t to an 8 character
 * hexadecimal string and prints it at the given position
 * @param x, the column to start printing at
 * @param y, the row to start printing at
 * @param hex, the 32 bit unsigned integer to print in hex
 * @param col, the vga color attribute byte
 *
 * using prth is done with
 * @code{.c}
 * #include "../io/vga.h" //or just vga.h
 * prth(0, 0, 0x00007C00, 0x0F);
 * @endcode
 *
 * @see prt(), prtd()
 */
void __prth(int x, int y, uint32_t hex, uint8_t col) {
    static const char chars[] = "0123456789ABCDEF";
    char output[9]; //make array
    
    output[0] = chars[(hex >> 28) & 0xF]; //output table
    output[1] = chars[(hex >> 24) & 0xF];
    output[2] = chars[(hex >> 20) & 0xF];
    output[3] = chars[(hex >> 16) & 0xF];
    output[4] = chars[(hex >> 12) & 0xF];
    output[5] = chars[(hex >> 8) & 0xF];
    output[6] = chars[(hex >> 4) & 0xF];
    output[7] = chars[hex & 0xF];
    output[8] = '\0';
    //this is crude but works
    prt(x, y, output, col); //prt
}
 
/**
 * @brief clscr clears the entire vga text screen
 *
 * clscr is a function that fills all 2000 vga cells with spaces
 * using the default white-on-black color attribute
 *
 * using clscr is done with
 * @code{.c}
 * #include "../io/vga.h" //or just vga.h
 * clscr();
 * @endcode
 *
 * @see scrl(), prt()
 */
void __clscr(void) {
    for (int ctr = 0; ctr < 2000; ctr++) { //main loop, we do this for all vga cells, aka 2000
            vga[ctr] = (0x0F << 8) | ' '; //set to space aka blank
    }    
}
 
/**
 * @brief rdln reads a line of text input from the keyboard
 *
 * rdln is a function that reads keyboard input into a buffer,
 * handling backspace, echoing characters, and returning on enter
 * @param buffer, the buffer to store the input string in
 * @param maxlen, the maximum length of the input including null
 *
 * using rdln is done with
 * @code{.c}
 * #include "../io/vga.h" //or just vga.h
 * char input[100];
 * rdln(input, 100);
 * @endcode
 *
 * @see gtchr(), prt(), cob()
 */
void __rdln(char *buffer, int maxlen) {
    assert(buffer != NULL, "rdln: NULL buffer"); //err handle
    assert(maxlen > 0, "rdln: maxlen zero");
    
    int pos = 0; //pos counter and nchr setup
    uint8_t nchr; //make not-char
    int cx; //cursor vals
    int cy;
    cnb(&cx, &cy); //read current
    
    while (1) {
        nchr = gtchr(); //set nchr to gtchr
        
        if (nchr == '\n') {
        cnb(&cx, &cy);
        buffer[pos] = 0; //buffer pos ctr
        cy++; //inc cursor y
            if (cy >= 25) { //scrl handle
                scrl();
                cy = 24; //decrement cy
            }
            cx = 0; //cx handle
            cob(cx, cy); //export
            return; //break
        }
        else if (nchr == '\b' && pos > 0) { //backspace handle
            pos--; //decrement pos for counting
            prt(cx - 1, cy, " ", 0x0F); //clear chr
            cnb(&cx, &cy);
            cx--; //decrement cursor x
            cob(cx, cy); //export new csr vals
        }
        else if (nchr >= ' ' && pos < maxlen - 1) { //actual handle for maxlen check and other stuff
            buffer[pos] = (char)nchr; //change buffer
            pos++; //inc pos
            char chr[2] = {(char)nchr, 0}; //convert it
            prt(cx, cy, chr, 0x0F); //echo char
            cnb(&cx, &cy);
            cx++; //inc
            cob(cx, cy); //export
        }
    }
}
 
/**
 * @brief drw draws a line on the vga screen using '#' characters
 *
 * drw is a function that draws horizontal, vertical, or diagonal
 * lines on the vga screen using bresenhams line algorithm for the
 * diagonal case
 * @param x1, the starting column (0-79)
 * @param y1, the starting row (0-24)
 * @param x2, the ending column (0-79)
 * @param y2, the ending row (0-24)
 * @param col, the vga color attribute byte
 *
 * using drw is done with
 * @code{.c}
 * #include "../io/vga.h" //or just vga.h
 * drw(10, 5, 50, 5, 0x0A); //horizontal green line
 * @endcode
 *
 * @see prt(), pchr()
 */
void __drw(int x1, int y1, int x2, int y2, uint8_t col) {
    //err handle
    assert(x1 >= 0 && x1 < 80, "drw: invalid x1");
    assert(y1 >= 0 && y1 < 25, "drw: invalid y1");
    assert(x2 >= 0 && x2 < 80, "drw: invalid x2");
    assert(y2 >= 0 && y2 < 25, "drw: invalid y2");
    
    int tx = x1;
    int ty = y1;
    
    //horizontal line
    if (y1 == y2) {
        int start = (x1 < x2) ? x1 : x2;
        int end = (x1 > x2) ? x1 : x2;
        for (tx = start; tx <= end; tx++) {
            prt(tx, y1, "#", col); //enumerate
        }
    }
    //vertical line
    else if (x1 == x2) {
        int start = (y1 < y2) ? y1 : y2;
        int end = (y1 > y2) ? y1 : y2;
        for (ty = start; ty <= end; ty++) { //enum for v
            prt(x1, ty, "#", col);
        }
    }
    //diagonal line using bresenhams algorithm
    else {
        int dx = abs(x2 - x1);
        int dy = abs(y2 - y1);
        int sx = (x1 < x2) ? 1 : -1;
        int sy = (y1 < y2) ? 1 : -1;
        int err = dx - dy;
        
        tx = x1;
        ty = y1;
        
        while (1) {
            prt(tx, ty, "#", col); //main prt loop
            if (tx == x2 && ty == y2) break;
            
            int err2 = 2 * err; //err is for diagonal not err handling lol
            if (err2 > -dy) {
                err -= dy;
                tx += sx;
            }
            if (err2 < dx) {
                err += dx;
                ty += sy;
            }
        }
    }
}
 
/**
 * @brief pchr prints a single raw character to the vga screen
 *
 * pchr is a function that prints a single character at a given
 * screen position, useful for printing extended ascii characters
 * @param x, the column to print at
 * @param y, the row to print at
 * @param chr, the raw character to print (e.g. a char literal)
 * @param col, the vga color attribute byte
 *
 * using pchr is done with
 * @code{.c}
 * #include "../io/vga.h" //or just vga.h
 * pchr(40, 12, 0xDB, 0x0F); //solid block char
 * @endcode
 *
 * @see prt(), drw()
 */
void __pchr(int x, int y, char chr, uint8_t col) {
    char str[2] = {chr, 0}; //0 is null  term
    prt(x, y, str, col); //prt
}