Subversion Repositories s80186

// Copyright Jamie Iles, 2017
//
// This file is part of s80x86.
//
// s80x86 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.
//
// s80x86 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 s80x86.  If not, see <http://www.gnu.org/licenses/>.
 
#include "Display.h"
 
#include <cassert>
#include <cctype>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <map>
#include <stdexcept>
 
#include <SDL.h>
 
#include "Window.h"
 
Display::Display(unsigned num_rows, unsigned num_cols)
    : num_rows(num_rows), num_cols(num_cols), row(0), col(0)
{
    if (SDL_Init(SDL_INIT_VIDEO) != 0)
        throw std::runtime_error("Failed to initialize SDL " +
                                 std::string(SDL_GetError()));
 
    characters = std::make_unique<uint16_t[]>(num_rows * (num_cols + 1));
    window = std::make_unique<Window>("8086sim", 8 * num_cols, 8 * num_rows);
 
    load_font();
}
 
Display::~Display()
{
    SDL_Quit();
}
 
void Display::load_font()
{
    std::ifstream font_file;
    font_file.open(FONT_FILE, std::ios::binary | std::ios::in);
    font_file.read(font_bitmap, sizeof(font_bitmap));
    font_file.close();
}
 
void Display::set_cursor(unsigned row, unsigned col)
{
    this->row = row;
    this->col = col;
}
 
void Display::write_char(uint16_t c)
{
    uint16_t v = c;
 
    characters[this->row * (num_cols + 1) + this->col] = v;
    this->col++;
 
    if (this->col == num_cols) {
        this->col = 0;
        this->row++;
    }
    if (this->row == num_rows)
        this->row = num_rows - 1;
}
 
struct color {
    unsigned char r, g, b;
};
 
const struct color get_color(unsigned char idx)
{
    assert(idx < 16);
 
    struct color lut[] = {
        {0, 0, 0},          // black
        {0, 0, 0xaa},       // blue
        {0x00, 0xaa, 0x00}, // green
        {0x00, 0xaa, 0xaa}, // cyan
        {0xaa, 0x00, 0x00}, // red
        {0xaa, 0x00, 0xaa}, // magenta
        {0xaa, 0x55, 0x00}, // brown
        {0xaa, 0xaa, 0xaa}, // white
        {0x55, 0x55, 0x55}, // gray
        {0x55, 0x55, 0xff}, // bright blue
        {0x55, 0xff, 0x55}, // bright green
        {0x55, 0xff, 0xff}, // bright cyan
        {0xff, 0x55, 0x55}, // bright red
        {0xff, 0x55, 0xff}, // bright magenta
        {0xff, 0xff, 0x55}, // yellow
        {0xff, 0xff, 0xff}, // bright white
    };
 
    return lut[idx];
}
 
void Display::refresh(Cursor cursor)
{
    window->clear();
    for (unsigned y = 0; y < num_rows; ++y) {
        for (unsigned x = 0; x < num_cols; ++x) {
            uint16_t font_index = characters.get()[(y * (num_cols + 1)) + x];
            char *font_data = &font_bitmap[(font_index & 0xff) * 8];
 
            for (int i = 0; i < 8; ++i)
                for (int j = 0; j < 8; ++j) {
                    auto fg = get_color((font_index >> 8) & 0xf);
                    auto bg = get_color((font_index >> 12) & 0xf);
 
                    auto render_cursor =
                        cursor.is_active_at(y * 8 + i, x * 8 + j);
                    bool pixel_set = (font_data[i] & (1 << (8 - j)));
                    auto color = (pixel_set && !render_cursor) ||
                                         (!pixel_set && render_cursor)
                                     ? fg
                                     : bg;
                    window->set_pixel(x * 8 + j, y * 8 + i, color.r, color.g,
                                      color.b);
                }
        }
    }
 
    window->redraw();
 
    SDL_UpdateWindowSurface(window->get());
}