mirror of
https://github.com/st3fan/ewm.git
synced 2025-04-05 00:29:29 +00:00
Fixes #120 Implement a software renderer
This commit is contained in:
Stefan Arentz
parent
f6beef7e34
commit
1adf2aa852
14
src/Makefile
14
src/Makefile
@ -21,7 +21,7 @@
|
||||
# SOFTWARE.
|
||||
|
||||
CC?=cc
|
||||
CFLAGS=-std=gnu11 -O3 -Wall -Wextra -Werror -Wno-unused-parameter
|
||||
CFLAGS=-std=gnu11 -O1 -g -Wall -Wextra -Werror -Wno-unused-parameter
|
||||
LDFLAGS=-g -L/usr/local/lib
|
||||
|
||||
EWM_EXECUTABLE=ewm
|
||||
@ -39,10 +39,15 @@ SCR_TEST_SOURCES=cpu.c ins.c mem.c fmt.c two.c scr.c dsk.c chr.c alc.c utl.c scr
|
||||
SCR_TEST_OBJECTS=$(SCR_TEST_SOURCES:.c=.o)
|
||||
SCR_TEST_LIBS=-lSDL2
|
||||
|
||||
all: $(EWM_SOURCES) $(EWM_EXECUTABLE) $(CPU_TEST_SOURCES) $(CPU_TEST_EXECUTABLE) $(SCR_TEST_EXECUTABLE)
|
||||
CHR_TEST=chr_test
|
||||
CHR_TEST_SOURCES=chr.c chr_test.c
|
||||
CHR_TEST_OBJECTS=$(CHR_TEST_SOURCES:.c=.o)
|
||||
CHR_TEST_LIBS=-lSDL2
|
||||
|
||||
all: $(EWM_EXECUTABLE) $(CPU_TEST_SOURCES) $(CPU_TEST_EXECUTABLE) $(SCR_TEST_EXECUTABLE) $(CHR_TEST)
|
||||
|
||||
clean:
|
||||
rm -f $(EWM_OBJECTS) $(EWM_EXECUTABLE) $(CPU_TEST_OBJECTS) $(CPU_TEST_EXECUTABLE) $(SCR_TEST_OBJECTS) $(SCR_TEST_EXECUTABLE)
|
||||
rm -f $(EWM_OBJECTS) $(EWM_EXECUTABLE) $(CPU_TEST_OBJECTS) $(CPU_TEST_EXECUTABLE) $(SCR_TEST_OBJECTS) $(SCR_TEST_EXECUTABLE) $(CHR_TEST) $(CHR_TEST_OBJECTS)
|
||||
|
||||
$(EWM_EXECUTABLE): $(EWM_OBJECTS)
|
||||
$(CC) $(LDFLAGS) $(EWM_OBJECTS) $(EWM_LIBS) -o $@
|
||||
@ -53,5 +58,8 @@ $(CPU_TEST_EXECUTABLE): $(CPU_TEST_OBJECTS)
|
||||
$(SCR_TEST_EXECUTABLE): $(SCR_TEST_OBJECTS)
|
||||
$(CC) $(LDFLAGS) $(SCR_TEST_OBJECTS) $(SCR_TEST_LIBS) -o $@
|
||||
|
||||
$(CHR_TEST): $(CHR_TEST_OBJECTS)
|
||||
$(CC) $(LDFLAGS) $(CHR_TEST_OBJECTS) $(CHR_TEST_LIBS) -o $@
|
||||
|
||||
.c.o:
|
||||
$(CC) $(CFLAGS) $< -c -o $@
|
||||
|
||||
85
src/chr.c
85
src/chr.c
@ -75,8 +75,14 @@ static void _set_pixel(SDL_Surface * surface, int x, int y, Uint32 color) {
|
||||
*pixel = color;
|
||||
}
|
||||
|
||||
static SDL_Texture *_generate_texture(SDL_Renderer *renderer, uint8_t rom_data[2048], int c, bool inverse) {
|
||||
SDL_Texture *texture = NULL;
|
||||
static SDL_Surface *_generate_surface(SDL_Renderer *renderer, uint8_t rom_data[2048], int c, bool inverse) {
|
||||
//SDL_Surface *surface = SDL_CreateRGBSurface(0, 7*3, 8*3, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
|
||||
|
||||
SDL_Surface *surface = SDL_CreateRGBSurfaceWithFormat(0, 7*3, 8*3, 32, SDL_PIXELFORMAT_ARGB8888);
|
||||
if (surface == NULL) {
|
||||
fprintf(stderr, "[CHR] Cannot create RGBSurface: %s\n", SDL_GetError());
|
||||
return NULL;
|
||||
}
|
||||
|
||||
uint8_t character_data[8];
|
||||
for (int i = 0; i < 8; i++) {
|
||||
@ -86,23 +92,35 @@ static SDL_Texture *_generate_texture(SDL_Renderer *renderer, uint8_t rom_data[2
|
||||
}
|
||||
}
|
||||
|
||||
SDL_Surface *surface = SDL_CreateRGBSurface(0, 7, 8, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
|
||||
if (surface != NULL) {
|
||||
for (int y = 0; y < 8; y++) {
|
||||
for (int x = 0; x < 7; x++) {
|
||||
if (character_data[y] & (1 << x)) {
|
||||
_set_pixel(surface, (6-x), y, 0xffffffff);
|
||||
}
|
||||
for (int y = 0; y < 8; y++) {
|
||||
for (int x = 0; x < 7; x++) {
|
||||
if (character_data[y] & (1 << x)) {
|
||||
int px = (6-x) * 3, py = y * 3;
|
||||
|
||||
_set_pixel(surface, px+0, py+0, 0xffffffff);
|
||||
_set_pixel(surface, px+1, py+0, 0xffffffff);
|
||||
_set_pixel(surface, px+2, py+0, 0xffffffff);
|
||||
|
||||
_set_pixel(surface, px+0, py+1, 0xffffffff);
|
||||
_set_pixel(surface, px+1, py+1, 0xffffffff);
|
||||
_set_pixel(surface, px+2, py+1, 0xffffffff);
|
||||
|
||||
_set_pixel(surface, px+0, py+2, 0xffffffff);
|
||||
_set_pixel(surface, px+1, py+2, 0xffffffff);
|
||||
_set_pixel(surface, px+2, py+2, 0xffffffff);
|
||||
}
|
||||
}
|
||||
texture = SDL_CreateTextureFromSurface(renderer, surface);
|
||||
if (texture == NULL) {
|
||||
fprintf(stderr, "Cannot generate RGBSurface: %s\n", SDL_GetError());
|
||||
}
|
||||
} else {
|
||||
fprintf(stderr, "Cannot generate Texture: %s\n", SDL_GetError());
|
||||
}
|
||||
|
||||
return surface;
|
||||
}
|
||||
|
||||
static SDL_Texture *_generate_texture(SDL_Renderer *renderer, SDL_Surface *surface) {
|
||||
SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surface);
|
||||
if (texture == NULL) {
|
||||
fprintf(stderr, "[CHR] Cannot generate Texture from Surface: %s\n", SDL_GetError());
|
||||
return NULL;
|
||||
}
|
||||
return texture;
|
||||
}
|
||||
|
||||
@ -117,40 +135,43 @@ int ewm_chr_init(struct ewm_chr_t *chr, char *rom_path, int rom_type, SDL_Render
|
||||
return -1;
|
||||
}
|
||||
|
||||
// This is not great. I think what should happen is that this
|
||||
// module just creates normal and inverse surfaces and textures in
|
||||
// exact ROM order and then scr.c and tty.c can map an ASCII value
|
||||
// to a specific ROM character. That keeps this module simple and
|
||||
// moves more logic into the machine specific modules. That also
|
||||
// solves the problem that you can currently print inverse
|
||||
// characters on the Apple 1.
|
||||
|
||||
// Normal Text
|
||||
for (int c = 0; c < 32; c++) {
|
||||
chr->characters[0xc0 + c] = _generate_texture(renderer, rom_data, c, false);
|
||||
chr->surfaces[0xc0 + c] = _generate_surface(renderer, rom_data, c, false);
|
||||
chr->textures[0xc0 + c] = _generate_texture(renderer, chr->surfaces[0xc0 + c]);
|
||||
}
|
||||
for (int c = 32; c < 64; c++) {
|
||||
chr->characters[0xa0 + (c-32)] = _generate_texture(renderer, rom_data, c, false);
|
||||
chr->surfaces[0xa0 + (c-32)] = _generate_surface(renderer, rom_data, c, false);
|
||||
chr->textures[0xa0 + (c-32)] = _generate_texture(renderer, chr->surfaces[0xa0 + (c-32)]);
|
||||
}
|
||||
|
||||
// Inverse Text
|
||||
for (int c = 0; c < 32; c++) {
|
||||
chr->characters[0x00 + c] = _generate_texture(renderer, rom_data, c, true);
|
||||
chr->surfaces[0x00 + c] = _generate_surface(renderer, rom_data, c, true);
|
||||
chr->textures[0x00 + c] = _generate_texture(renderer, chr->surfaces[0x00 + c]);
|
||||
}
|
||||
for (int c = 32; c < 64; c++) {
|
||||
chr->characters[0x20 + (c-32)] = _generate_texture(renderer, rom_data, c, true);
|
||||
chr->surfaces[0x20 + (c-32)] = _generate_surface(renderer, rom_data, c, true);
|
||||
chr->textures[0x20 + (c-32)] = _generate_texture(renderer, chr->surfaces[0x20 + (c-32)]);
|
||||
}
|
||||
|
||||
// TODO Flashing - Currently simply rendered as inverse
|
||||
for (int c = 0; c < 32; c++) {
|
||||
chr->characters[0x40 + c] = _generate_texture(renderer, rom_data, c, true);
|
||||
chr->surfaces[0x40 + c] = _generate_surface(renderer, rom_data, c, true);
|
||||
chr->textures[0x40 + c] = _generate_texture(renderer, chr->surfaces[0x40 + c]);
|
||||
}
|
||||
for (int c = 32; c < 64; c++) {
|
||||
chr->characters[0x60 + (c-32)] = _generate_texture(renderer, rom_data, c, true);
|
||||
chr->surfaces[0x60 + (c-32)] = _generate_surface(renderer, rom_data, c, true);
|
||||
chr->textures[0x60 + (c-32)] = _generate_texture(renderer, chr->surfaces[0x60 + (c-32)]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
int main() {
|
||||
struct ewm_chr_t *chr = ewm_chr_create("rom/3410036.bin", EWM_CHR_ROM_TYPE_2716);
|
||||
if (chr == NULL) {
|
||||
printf("Failed to load character ROM %s\n", "rom/3410036.bin");
|
||||
exit(1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -28,7 +28,8 @@
|
||||
#define EWM_CHR_ROM_TYPE_2716 (2716)
|
||||
|
||||
struct ewm_chr_t {
|
||||
SDL_Texture* characters[256];
|
||||
SDL_Surface* surfaces[256];
|
||||
SDL_Texture* textures[256];
|
||||
};
|
||||
|
||||
struct ewm_chr_t* ewm_chr_create(char *rom_path, int rom_type, SDL_Renderer *renderer);
|
||||
|
||||
57
src/chr_test.c
Normal file
57
src/chr_test.c
Normal file
@ -0,0 +1,57 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2015 Stefan Arentz - http://github.com/st3fan/ewm
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "chr.h"
|
||||
|
||||
int main() {
|
||||
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
|
||||
fprintf(stderr, "[CHR] Failed to initialize SDL: %s\n", SDL_GetError());
|
||||
exit(1);
|
||||
}
|
||||
|
||||
SDL_Window *window = SDL_CreateWindow("chr_test", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 280*3, 192*3, SDL_WINDOW_SHOWN);
|
||||
if (window == NULL) {
|
||||
fprintf(stderr, "[CHR] Failed create window: %s\n", SDL_GetError());
|
||||
exit(1);
|
||||
}
|
||||
|
||||
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
|
||||
|
||||
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
|
||||
if (renderer == NULL) {
|
||||
fprintf(stderr, "[CHR] Failed to create renderer: %s\n", SDL_GetError());
|
||||
exit(1);
|
||||
}
|
||||
|
||||
struct ewm_chr_t *chr = ewm_chr_create("rom/3410036.bin", EWM_CHR_ROM_TYPE_2716, renderer);
|
||||
if (chr == NULL) {
|
||||
fprintf(stderr, "[CHR] Failed to load Character ROM %s\n", "rom/3410036.bin");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// TODO Blit the whole character rom as textures and then as surfaces
|
||||
|
||||
return 0;
|
||||
}
|
||||
16
src/one.c
16
src/one.c
@ -32,9 +32,9 @@
|
||||
#include "tty.h"
|
||||
#include "one.h"
|
||||
|
||||
struct ewm_one_t *ewm_one_create(int model, SDL_Renderer *renderer) {
|
||||
struct ewm_one_t *ewm_one_create(int model, SDL_Window *window, SDL_Renderer *renderer) {
|
||||
struct ewm_one_t *one = (struct ewm_one_t*) malloc(sizeof(struct ewm_one_t));
|
||||
if (ewm_one_init(one, model, renderer) != 0) {
|
||||
if (ewm_one_init(one, model, window, renderer) != 0) {
|
||||
free(one);
|
||||
one = NULL;
|
||||
}
|
||||
@ -49,7 +49,7 @@ static void ewm_one_pia_callback(struct ewm_pia_t *pia, void *obj, uint8_t ddr,
|
||||
ewm_tty_write(one->tty, v);
|
||||
}
|
||||
|
||||
int ewm_one_init(struct ewm_one_t *one, int model, SDL_Renderer *renderer) {
|
||||
int ewm_one_init(struct ewm_one_t *one, int model, SDL_Window *window, SDL_Renderer *renderer) {
|
||||
memset(one, 0, sizeof(struct ewm_one_t));
|
||||
one->model = model;
|
||||
switch (model) {
|
||||
@ -57,7 +57,7 @@ int ewm_one_init(struct ewm_one_t *one, int model, SDL_Renderer *renderer) {
|
||||
one->cpu = cpu_create(EWM_CPU_MODEL_6502);
|
||||
cpu_add_ram(one->cpu, 0x0000, 8 * 1024 - 1);
|
||||
cpu_add_rom_file(one->cpu, 0xff00, "rom/apple1.rom");
|
||||
one->tty = ewm_tty_create(renderer);
|
||||
one->tty = ewm_tty_create(window, renderer);
|
||||
one->pia = ewm_pia_create(one->cpu);
|
||||
one->pia->callback = ewm_one_pia_callback;
|
||||
one->pia->callback_obj = one;
|
||||
@ -66,7 +66,7 @@ int ewm_one_init(struct ewm_one_t *one, int model, SDL_Renderer *renderer) {
|
||||
one->cpu = cpu_create(EWM_CPU_MODEL_65C02);
|
||||
cpu_add_ram(one->cpu, 0x0000, 32 * 1024 - 1);
|
||||
cpu_add_rom_file(one->cpu, 0xe000, "rom/krusader.rom");
|
||||
one->tty = ewm_tty_create(renderer);
|
||||
one->tty = ewm_tty_create(window, renderer);
|
||||
one->pia = ewm_pia_create(one->cpu);
|
||||
one->pia->callback = ewm_one_pia_callback;
|
||||
one->pia->callback_obj = one;
|
||||
@ -246,17 +246,19 @@ int ewm_one_main(int argc, char **argv) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
|
||||
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
|
||||
if (renderer == NULL) {
|
||||
fprintf(stderr, "Failed to create renderer: %s\n", SDL_GetError());
|
||||
return 1;
|
||||
}
|
||||
|
||||
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
|
||||
|
||||
SDL_RenderSetLogicalSize(renderer, 280*3, 192*3);
|
||||
|
||||
// Create the machine
|
||||
|
||||
struct ewm_one_t *one = ewm_one_create(model, renderer);
|
||||
struct ewm_one_t *one = ewm_one_create(model, window, renderer);
|
||||
if (one == NULL) {
|
||||
fprintf(stderr, "Failed to create ewm_one_t\n");
|
||||
return 1;
|
||||
|
||||
@ -40,8 +40,8 @@ struct ewm_one_t {
|
||||
struct ewm_pia_t *pia;
|
||||
};
|
||||
|
||||
struct ewm_one_t *ewm_one_create(int type, SDL_Renderer *renderer);
|
||||
int ewm_one_init(struct ewm_one_t *one, int type, SDL_Renderer *renderer);
|
||||
struct ewm_one_t *ewm_one_create(int type, SDL_Window *window, SDL_Renderer *renderer);
|
||||
int ewm_one_init(struct ewm_one_t *one, int type, SDL_Window *window, SDL_Renderer *renderer);
|
||||
void ewm_one_destroy(struct ewm_one_t *one);
|
||||
|
||||
int ewm_one_main(int argc, char **argv);
|
||||
|
||||
96
src/scr.c
96
src/scr.c
@ -41,7 +41,13 @@ static int txt_line_offsets[24] = {
|
||||
static inline void scr_render_character(struct scr_t *scr, int row, int column, bool flash) {
|
||||
uint16_t base = (scr->two->screen_page == EWM_A2P_SCREEN_PAGE1) ? 0x0400 : 0x0800;
|
||||
uint8_t c = scr->two->screen_txt_data[((txt_line_offsets[row] + base) + column) - 0x0400];
|
||||
if (scr->chr->characters[c] != NULL) {
|
||||
if (scr->chr->textures[c] != NULL) {
|
||||
SDL_Rect src;
|
||||
src.x = 0;
|
||||
src.y = 0;
|
||||
src.w = 21;
|
||||
src.h = 24;
|
||||
|
||||
SDL_Rect dst;
|
||||
dst.x = column * 21;
|
||||
dst.y = row * 24;
|
||||
@ -61,12 +67,12 @@ static inline void scr_render_character(struct scr_t *scr, int row, int column,
|
||||
}
|
||||
|
||||
if (scr->color_scheme == EWM_SCR_COLOR_SCHEME_MONOCHROME) {
|
||||
SDL_SetTextureColorMod(scr->chr->characters[c], 0, 255, 0);
|
||||
SDL_SetSurfaceColorMod(scr->chr->surfaces[c], 47, 249, 64);
|
||||
} else {
|
||||
SDL_SetTextureColorMod(scr->chr->characters[c], 255, 255, 255);
|
||||
SDL_SetSurfaceColorMod(scr->chr->surfaces[c], 255, 255, 255);
|
||||
}
|
||||
|
||||
SDL_RenderCopy(scr->renderer, scr->chr->characters[c], NULL, &dst);
|
||||
SDL_BlitSurface(scr->chr->surfaces[c], &src, SDL_GetWindowSurface(scr->window), &dst);
|
||||
}
|
||||
}
|
||||
|
||||
@ -80,7 +86,7 @@ static inline void scr_render_txt_screen(struct scr_t *scr, bool flash) {
|
||||
|
||||
// Lores Rendering
|
||||
|
||||
static SDL_Color lores_colors[16] = {
|
||||
static SDL_Color lores_colors_color[16] = {
|
||||
{ 0, 0, 0, 0 }, // 0 Black
|
||||
{ 255, 0, 255, 0 }, // 1 Magenta
|
||||
{ 0, 0, 204, 0 }, // 2 Dark Blue
|
||||
@ -99,8 +105,28 @@ static SDL_Color lores_colors[16] = {
|
||||
{ 255, 255, 255, 0 }, // 15 White
|
||||
};
|
||||
|
||||
static inline void scr_render_lores_block(struct scr_t *scr, int row, int column) {
|
||||
static SDL_Color lores_colors_green[16] = {
|
||||
{ 0, 0, 0, 0 }, // 0 Black
|
||||
{ 9, 87, 17, 0 }, // 1 Magenta
|
||||
{ 2, 22, 3, 0 }, // 2 Dark Blue
|
||||
{ 19, 126, 29, 0 }, // 3 Purple
|
||||
{ 11, 90, 18, 0 }, // 4 Dark Green
|
||||
{ 13, 101, 21, 0 }, // 5 Grey 1
|
||||
{ 8, 74, 14, 0 }, // 6 Medium Blue
|
||||
{ 28, 170, 40, 0 }, // 7 Light Blue
|
||||
{ 15, 109, 22, 0 }, // 8 Brown
|
||||
{ 24, 152, 35, 0 }, // 9 Orange
|
||||
{ 33, 181, 45, 0 }, // 10 Grey 2
|
||||
{ 34, 190, 47, 0 }, // 11 Pink
|
||||
{ 23, 149, 34, 0 }, // 12 Light Green
|
||||
{ 43, 227, 58, 0 }, // 13 Yellow
|
||||
{ 34, 197, 49, 0 }, // 14 Aquamarine
|
||||
{ 47, 249, 64, 0 }, // 15 White
|
||||
};
|
||||
|
||||
static inline void scr_render_lores_block(struct scr_t *scr, int row, int column, SDL_Color *colors) {
|
||||
uint16_t base = (scr->two->screen_page == EWM_A2P_SCREEN_PAGE1) ? 0x0400 : 0x0800;
|
||||
SDL_Surface *surface = SDL_GetWindowSurface(scr->window);
|
||||
uint8_t block = scr->two->screen_txt_data[((txt_line_offsets[row] + base) + column) - 0x0400];
|
||||
if (block != 0) {
|
||||
SDL_Rect dst;
|
||||
@ -111,15 +137,13 @@ static inline void scr_render_lores_block(struct scr_t *scr, int row, int column
|
||||
|
||||
uint8_t c = block & 0x0f;
|
||||
if (c != 0) {
|
||||
SDL_SetRenderDrawColor(scr->renderer, lores_colors[c].r, lores_colors[c].g, lores_colors[c].b, lores_colors[c].a);
|
||||
SDL_RenderFillRect(scr->renderer, &dst);
|
||||
SDL_FillRect(surface, &dst, SDL_MapRGB(surface->format, colors[c].r, colors[c].g, colors[c].b));
|
||||
}
|
||||
|
||||
c = (block & 0xf0) >> 4;
|
||||
if (c != 0) {
|
||||
dst.y += 12;
|
||||
SDL_SetRenderDrawColor(scr->renderer, lores_colors[c].r, lores_colors[c].g, lores_colors[c].b, lores_colors[c].a);
|
||||
SDL_RenderFillRect(scr->renderer, &dst);
|
||||
SDL_FillRect(surface, &dst, SDL_MapRGB(surface->format, colors[c].r, colors[c].g, colors[c].b));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -131,7 +155,8 @@ static inline void scr_render_lgr_screen(struct scr_t *scr, bool flash) {
|
||||
int rows = mixed ? 20 : 24;
|
||||
for (int row = 0; row < rows; row++) {
|
||||
for (int column = 0; column < 40; column++) {
|
||||
scr_render_lores_block(scr, row, column);
|
||||
scr_render_lores_block(scr, row, column,
|
||||
scr->color_scheme == EWM_SCR_COLOR_SCHEME_COLOR ? lores_colors_color : lores_colors_green);
|
||||
}
|
||||
}
|
||||
// Render bottom 4 lines
|
||||
@ -189,22 +214,34 @@ static SDL_Color hgr_colors[16] = {
|
||||
{ 255, 255, 255, 0 } // 5 White
|
||||
};
|
||||
|
||||
inline static void _set_pixel(SDL_Surface * surface, int x, int y, Uint32 color) {
|
||||
uint32_t *pixel = (uint32_t*) ((uint8_t*) surface->pixels + (y * surface->pitch) + (x * sizeof(uint32_t)));
|
||||
*pixel = color;
|
||||
}
|
||||
|
||||
inline static void scr_render_hgr_line_green(struct scr_t *scr, int line, uint16_t line_base) {
|
||||
SDL_Surface *surface = SDL_GetWindowSurface(scr->window);
|
||||
uint32_t green = SDL_MapRGB(surface->format, 47, 249, 64); // TODO Constant for this color please
|
||||
int x = 0;
|
||||
for (int i = 0; i < 40; i++) {
|
||||
uint8_t c = scr->two->screen_hgr_data[line_base + i];
|
||||
for (int j = 0; j < 7; j++) {
|
||||
SDL_Rect dst;
|
||||
dst.x = x * 3;
|
||||
dst.y = line * 3;
|
||||
dst.w = 3;
|
||||
dst.h = 3;
|
||||
if (c & (1 << j)) {
|
||||
SDL_SetRenderDrawColor(scr->renderer, 0, 255, 0, 0);
|
||||
} else {
|
||||
SDL_SetRenderDrawColor(scr->renderer, 0, 0, 0, 0);
|
||||
}
|
||||
SDL_RenderFillRect(scr->renderer, &dst);
|
||||
uint32_t color = (c & (1 << j)) ? green : 0;
|
||||
|
||||
int px = x * 3, py = line * 3;
|
||||
|
||||
_set_pixel(surface, px+0, py+0, color);
|
||||
_set_pixel(surface, px+1, py+0, color);
|
||||
_set_pixel(surface, px+2, py+0, color);
|
||||
|
||||
_set_pixel(surface, px+0, py+1, color);
|
||||
_set_pixel(surface, px+1, py+1, color);
|
||||
_set_pixel(surface, px+2, py+1, color);
|
||||
|
||||
_set_pixel(surface, px+0, py+2, color);
|
||||
_set_pixel(surface, px+1, py+2, color);
|
||||
_set_pixel(surface, px+2, py+2, color);
|
||||
|
||||
x++;
|
||||
}
|
||||
}
|
||||
@ -249,6 +286,8 @@ inline static void scr_render_hgr_line_color(struct scr_t *scr, int line, uint16
|
||||
|
||||
// Now draw them
|
||||
|
||||
SDL_Surface *surface = SDL_GetWindowSurface(scr->window);
|
||||
|
||||
for (x = 0; x < 280; x++) {
|
||||
SDL_Rect dst;
|
||||
dst.x = x * 3;
|
||||
@ -257,8 +296,7 @@ inline static void scr_render_hgr_line_color(struct scr_t *scr, int line, uint16
|
||||
dst.h = 3;
|
||||
|
||||
int c = pixels[x];
|
||||
SDL_SetRenderDrawColor(scr->renderer, hgr_colors[c].r, hgr_colors[c].g, hgr_colors[c].b, hgr_colors[c].a);
|
||||
SDL_RenderFillRect(scr->renderer, &dst);
|
||||
SDL_FillRect(surface, &dst, SDL_MapRGB(surface->format, hgr_colors[c].r, hgr_colors[c].g, hgr_colors[c].b));
|
||||
}
|
||||
}
|
||||
|
||||
@ -287,9 +325,10 @@ inline static void scr_render_hgr_screen(struct scr_t *scr, bool flash) {
|
||||
|
||||
// TODO This is the only actual API exposed
|
||||
|
||||
int ewm_scr_init(struct scr_t *scr, struct ewm_two_t *two, SDL_Renderer *renderer) {
|
||||
int ewm_scr_init(struct scr_t *scr, struct ewm_two_t *two, SDL_Window *window, SDL_Renderer *renderer) {
|
||||
memset(scr, 0x00, sizeof(struct scr_t));
|
||||
scr->two = two;
|
||||
scr->window = window;
|
||||
scr->renderer = renderer;
|
||||
scr->chr = ewm_chr_create("rom/3410036.bin", EWM_CHR_ROM_TYPE_2716, renderer);
|
||||
if (scr->chr == NULL) {
|
||||
@ -299,9 +338,9 @@ int ewm_scr_init(struct scr_t *scr, struct ewm_two_t *two, SDL_Renderer *rendere
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct scr_t *ewm_scr_create(struct ewm_two_t *two, SDL_Renderer *renderer) {
|
||||
struct scr_t *ewm_scr_create(struct ewm_two_t *two, SDL_Window *window, SDL_Renderer *renderer) {
|
||||
struct scr_t *scr = malloc(sizeof(struct scr_t));
|
||||
if (ewm_scr_init(scr, two, renderer) != 0) {
|
||||
if (ewm_scr_init(scr, two, window, renderer) != 0) {
|
||||
free(scr);
|
||||
scr = NULL;
|
||||
}
|
||||
@ -313,8 +352,7 @@ void ewm_scr_destroy(struct scr_t *scr) {
|
||||
}
|
||||
|
||||
void ewm_scr_update(struct scr_t *scr, int phase, int fps) {
|
||||
SDL_SetRenderDrawColor(scr->renderer, 0, 0, 0, 255);
|
||||
SDL_RenderClear(scr->renderer);
|
||||
SDL_FillRect(SDL_GetWindowSurface(scr->window), NULL, 0);
|
||||
|
||||
switch (scr->two->screen_mode) {
|
||||
case EWM_A2P_SCREEN_MODE_TEXT:
|
||||
|
||||
@ -37,13 +37,14 @@ struct ewm_chr_t;
|
||||
|
||||
struct scr_t {
|
||||
struct ewm_two_t *two;
|
||||
SDL_Window *window;
|
||||
SDL_Renderer *renderer;
|
||||
struct ewm_chr_t *chr;
|
||||
int color_scheme;
|
||||
};
|
||||
|
||||
struct scr_t *ewm_scr_create(struct ewm_two_t *two, SDL_Renderer *renderer);
|
||||
int ewm_scr_init(struct scr_t *scr, struct ewm_two_t *two, SDL_Renderer *renderer);
|
||||
struct scr_t *ewm_scr_create(struct ewm_two_t *two, SDL_Window *window, SDL_Renderer *renderer);
|
||||
int ewm_scr_init(struct scr_t *scr, struct ewm_two_t *two, SDL_Window* window, SDL_Renderer *renderer);
|
||||
void ewm_scr_destroy(struct scr_t *scr);
|
||||
void ewm_scr_update(struct scr_t *scr, int phase, int fps);
|
||||
void ewm_scr_set_color_scheme(struct scr_t *scr, int color_scheme);
|
||||
|
||||
@ -77,7 +77,8 @@ void hgr_full_refresh_test(struct scr_t *scr) {
|
||||
ewm_scr_update(scr, 0, 0);
|
||||
}
|
||||
|
||||
void test(struct scr_t *scr, char *name, test_setup_t test_setup, test_run_t test_run) {
|
||||
void _test(struct scr_t *scr, char *name, test_setup_t test_setup, test_run_t test_run, int color_scheme) {
|
||||
scr->color_scheme = color_scheme;
|
||||
test_setup(scr);
|
||||
|
||||
Uint64 start = SDL_GetPerformanceCounter();
|
||||
@ -89,7 +90,15 @@ void test(struct scr_t *scr, char *name, test_setup_t test_setup, test_run_t tes
|
||||
double total = (double)((now - start)*1000) / SDL_GetPerformanceFrequency();
|
||||
double per_screen = total / 1000.0;
|
||||
|
||||
printf("%-20s %.3f/refresh\n", name, per_screen);
|
||||
printf("%-40s %-10s %.3f/refresh\n", name,
|
||||
color_scheme == EWM_SCR_COLOR_SCHEME_MONOCHROME ? "green" : "color", per_screen);
|
||||
}
|
||||
|
||||
void test(struct scr_t *scr, char *name, test_setup_t test_setup, test_run_t test_run) {
|
||||
sleep(1);
|
||||
_test(scr, name, test_setup, test_run, EWM_SCR_COLOR_SCHEME_MONOCHROME);
|
||||
sleep(1);
|
||||
_test(scr, name, test_setup, test_run, EWM_SCR_COLOR_SCHEME_COLOR);
|
||||
}
|
||||
|
||||
int main() {
|
||||
@ -104,7 +113,9 @@ int main() {
|
||||
return 1;
|
||||
}
|
||||
|
||||
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
|
||||
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
|
||||
|
||||
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
|
||||
if (renderer == NULL) {
|
||||
fprintf(stderr, "Failed to create renderer: %s\n", SDL_GetError());
|
||||
return 1;
|
||||
@ -112,11 +123,9 @@ int main() {
|
||||
|
||||
SDL_RenderSetLogicalSize(renderer, 280*3, 192*3);
|
||||
|
||||
sleep(3); // Is this ok? Seems to be needed to get the window on the screen
|
||||
|
||||
// Setup the CPU, Apple ][+ and it's screen.
|
||||
|
||||
struct ewm_two_t *two = ewm_two_create(EWM_TWO_TYPE_APPLE2PLUS, renderer, NULL);
|
||||
struct ewm_two_t *two = ewm_two_create(EWM_TWO_TYPE_APPLE2PLUS, window, renderer, NULL);
|
||||
|
||||
test(two->scr, "txt_full_refresh", txt_full_refresh_setup, txt_full_refresh_test);
|
||||
test(two->scr, "lgr_full_refresh", lgr_full_refresh_setup, lgr_full_refresh_test);
|
||||
|
||||
19
src/tty.c
19
src/tty.c
@ -23,9 +23,10 @@
|
||||
#include "chr.h"
|
||||
#include "tty.h"
|
||||
|
||||
struct ewm_tty_t *ewm_tty_create(SDL_Renderer *renderer) {
|
||||
struct ewm_tty_t *ewm_tty_create(SDL_Window *window, SDL_Renderer *renderer) {
|
||||
struct ewm_tty_t *tty = malloc(sizeof(struct ewm_tty_t));
|
||||
memset(tty, 0, sizeof(struct ewm_tty_t));
|
||||
tty->window = window;
|
||||
tty->renderer = renderer;
|
||||
tty->chr = ewm_chr_create("rom/3410036.bin", EWM_CHR_ROM_TYPE_2716, renderer);
|
||||
ewm_tty_reset(tty);
|
||||
@ -37,16 +38,22 @@ void ewm_tty_destroy(struct ewm_tty_t *tty) {
|
||||
}
|
||||
|
||||
static inline void ewm_tty_render_character(struct ewm_tty_t *tty, int row, int column, uint8_t c) {
|
||||
// TODO Should we learn chr.c about the Apple1 character set instead of mapping it to the Apple ][+ one?
|
||||
c += 0x80;
|
||||
if (tty->chr->characters[c] != NULL) {
|
||||
c += 0x80; // TODO Should we learn chr.c about the Apple1 character set instead of mapping it to the Apple ][+ one?
|
||||
if (tty->chr->surfaces[c] != NULL) {
|
||||
SDL_Rect src;
|
||||
src.x = 0;
|
||||
src.y = 0;
|
||||
src.w = 21;
|
||||
src.h = 24;
|
||||
|
||||
SDL_Rect dst;
|
||||
dst.x = column * 21;
|
||||
dst.y = row * 24;
|
||||
dst.w = 21;
|
||||
dst.h = 24;
|
||||
SDL_SetTextureColorMod(tty->chr->characters[c], 0, 255, 0);
|
||||
SDL_RenderCopy(tty->renderer, tty->chr->characters[c], NULL, &dst);
|
||||
|
||||
SDL_SetSurfaceColorMod(tty->chr->surfaces[c], 47, 249, 64);
|
||||
SDL_BlitSurface(tty->chr->surfaces[c], &src, SDL_GetWindowSurface(tty->window), &dst);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -35,6 +35,7 @@
|
||||
struct ewm_chr_t;
|
||||
|
||||
struct ewm_tty_t {
|
||||
SDL_Window *window;
|
||||
SDL_Renderer *renderer;
|
||||
struct ewm_chr_t *chr;
|
||||
bool screen_dirty;
|
||||
@ -43,7 +44,7 @@ struct ewm_tty_t {
|
||||
int screen_cursor_column;
|
||||
};
|
||||
|
||||
struct ewm_tty_t *ewm_tty_create(SDL_Renderer *renderer);
|
||||
struct ewm_tty_t *ewm_tty_create(SDL_Window *window, SDL_Renderer *renderer);
|
||||
void ewm_tty_destroy(struct ewm_tty_t *tty);
|
||||
void ewm_tty_write(struct ewm_tty_t *tty, uint8_t v);
|
||||
void ewm_tty_reset(struct ewm_tty_t *tty);
|
||||
|
||||
38
src/two.c
38
src/two.c
@ -273,7 +273,7 @@ static void ewm_two_screen_hgr_write(struct cpu_t *cpu, struct mem_t *mem, uint1
|
||||
two->screen_dirty = true;
|
||||
}
|
||||
|
||||
static int ewm_two_init(struct ewm_two_t *two, int type, SDL_Renderer *renderer, SDL_Joystick *joystick) {
|
||||
static int ewm_two_init(struct ewm_two_t *two, int type, SDL_Window *window, SDL_Renderer *renderer, SDL_Joystick *joystick) {
|
||||
memset(two, 0, sizeof(struct ewm_two_t));
|
||||
|
||||
two->type = type;
|
||||
@ -309,7 +309,7 @@ static int ewm_two_init(struct ewm_two_t *two, int type, SDL_Renderer *renderer,
|
||||
return -1;
|
||||
}
|
||||
|
||||
two->scr = ewm_scr_create(two, renderer);
|
||||
two->scr = ewm_scr_create(two, window, renderer);
|
||||
if (two->scr == NULL) {
|
||||
fprintf(stderr, "[TWO] Could not create Screen\n");
|
||||
return -1;
|
||||
@ -337,9 +337,9 @@ static int ewm_two_init(struct ewm_two_t *two, int type, SDL_Renderer *renderer,
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct ewm_two_t *ewm_two_create(int type, SDL_Renderer *renderer, SDL_Joystick *joystick) {
|
||||
struct ewm_two_t *ewm_two_create(int type, SDL_Window *window, SDL_Renderer *renderer, SDL_Joystick *joystick) {
|
||||
struct ewm_two_t *two = malloc(sizeof(struct ewm_two_t));
|
||||
if (ewm_two_init(two, type, renderer, joystick) != 0) {
|
||||
if (ewm_two_init(two, type, window, renderer, joystick) != 0) {
|
||||
free(two);
|
||||
two = NULL;
|
||||
}
|
||||
@ -501,18 +501,17 @@ static bool ewm_two_step_cpu(struct ewm_two_t *two, int cycles) {
|
||||
}
|
||||
|
||||
static void ewm_two_update_status_bar(struct ewm_two_t *two, double mhz) {
|
||||
|
||||
SDL_Rect rect = { .x = 0, .y = (24*8*3), .w = (40*7*3), .h = (9*3) };
|
||||
SDL_SetRenderDrawColor(two->scr->renderer, 39, 39, 39, 0);
|
||||
SDL_RenderFillRect(two->scr->renderer, &rect);
|
||||
|
||||
char s[41];
|
||||
snprintf(s, 41, "%1.3f MHZ [1][2]", mhz);
|
||||
// 1234567890123456789012345678901234567890
|
||||
|
||||
for (int i = 0; i < 40; i++) {
|
||||
int c = s[i] + 0x80;
|
||||
if (two->scr->chr->characters[c] != NULL) {
|
||||
if (two->scr->chr->textures[c] != NULL) {
|
||||
SDL_Rect src;
|
||||
src.x = 0;
|
||||
src.y = 0;
|
||||
src.w = 21;
|
||||
src.h = 24;
|
||||
|
||||
SDL_Rect dst;
|
||||
dst.x = i * 21;
|
||||
dst.y = 24 * 24 + 3;
|
||||
@ -520,12 +519,13 @@ static void ewm_two_update_status_bar(struct ewm_two_t *two, double mhz) {
|
||||
dst.h = 24;
|
||||
|
||||
if (two->dsk->on && ((i == 35 && two->dsk->drive == EWM_DSK_DRIVE1) || (i == 38 && two->dsk->drive == EWM_DSK_DRIVE2))) {
|
||||
SDL_SetTextureColorMod(two->scr->chr->characters[c], 145, 193, 75);
|
||||
SDL_SetSurfaceColorMod(two->scr->chr->surfaces[c], 145, 193, 75);
|
||||
|
||||
} else {
|
||||
SDL_SetTextureColorMod(two->scr->chr->characters[c], 255, 0, 0);
|
||||
SDL_SetSurfaceColorMod(two->scr->chr->surfaces[c], 255, 0, 0);
|
||||
}
|
||||
|
||||
SDL_RenderCopy(two->scr->renderer, two->scr->chr->characters[c], NULL, &dst);
|
||||
SDL_BlitSurface(two->scr->chr->surfaces[c], &src, SDL_GetWindowSurface(two->scr->window), &dst);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -612,14 +612,14 @@ int ewm_two_main(int argc, char **argv) {
|
||||
exit(1);
|
||||
}
|
||||
|
||||
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
|
||||
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
|
||||
|
||||
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
|
||||
if (renderer == NULL) {
|
||||
fprintf(stderr, "Failed to create renderer: %s\n", SDL_GetError());
|
||||
exit(1);
|
||||
}
|
||||
|
||||
SDL_RenderSetLogicalSize(renderer, 280*3, 192*3);
|
||||
|
||||
// Print what renderer we got
|
||||
|
||||
if (debug) {
|
||||
@ -667,7 +667,7 @@ int ewm_two_main(int argc, char **argv) {
|
||||
|
||||
// Create and configure the Apple II
|
||||
|
||||
struct ewm_two_t *two = ewm_two_create(EWM_TWO_TYPE_APPLE2PLUS, renderer, joystick);
|
||||
struct ewm_two_t *two = ewm_two_create(EWM_TWO_TYPE_APPLE2PLUS, window, renderer, joystick);
|
||||
two->debug = debug;
|
||||
|
||||
if (color) {
|
||||
|
||||
@ -101,7 +101,7 @@ struct ewm_two_t {
|
||||
bool debug;
|
||||
};
|
||||
|
||||
struct ewm_two_t *ewm_two_create(int type, SDL_Renderer *renderer, SDL_Joystick *joystick);
|
||||
struct ewm_two_t *ewm_two_create(int type, SDL_Window *window, SDL_Renderer *renderer, SDL_Joystick *joystick);
|
||||
void ewm_two_destroy(struct ewm_two_t *two);
|
||||
|
||||
int ewm_two_load_disk(struct ewm_two_t *two, int drive, char *path);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user