display.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022, 2023 Adrian "asie" Siekierka
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef LIBWS_DISPLAY_H_
#define LIBWS_DISPLAY_H_
 
#ifndef __ASSEMBLER__
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#endif
#include <wonderful.h>
#include "memory.h"
#include "ports.h"


 
#define WS_DISPLAY_WIDTH_TILES   28
#define WS_DISPLAY_HEIGHT_TILES  18
#define WS_DISPLAY_WIDTH_PIXELS  (WS_DISPLAY_WIDTH_TILES  * WS_DISPLAY_TILE_WIDTH)
#define WS_DISPLAY_HEIGHT_PIXELS (WS_DISPLAY_HEIGHT_TILES * WS_DISPLAY_TILE_HEIGHT)
 
#define WS_DISPLAY_TILE_WIDTH     8
#define WS_DISPLAY_TILE_HEIGHT    8
#define WS_DISPLAY_TILE_SIZE      16
#define WS_DISPLAY_TILE_SIZE_4BPP 32
 
#ifndef WS_DISPLAY_VTOTAL
#define WS_DISPLAY_VTOTAL 159
#endif
 
#ifndef __ASSEMBLER__
typedef struct {
    union {
        uint16_t row[WS_DISPLAY_TILE_HEIGHT]; 
        uint8_t plane[WS_DISPLAY_TILE_HEIGHT][2]; 
    };
} ws_display_tile_t;

typedef struct {
    union {
        uint32_t row[WS_DISPLAY_TILE_HEIGHT]; 
        uint8_t plane[WS_DISPLAY_TILE_HEIGHT][4]; 
    };
} ws_display_tile_4bpp_t;
#endif

#define WS_SCREEN_ATTR_TILE(x) (x)
#define WS_SCREEN_ATTR_TILE_MASK (0x1FF)
#define WS_SCREEN_ATTR_PALETTE(x) ((x) << 9)
#define WS_SCREEN_ATTR_PALETTE_MASK (0xF << 9)
#define WS_SCREEN_ATTR_BANK(x) ((x) << 13)
#define WS_SCREEN_ATTR_BANK_MASK (0x2000)
#define WS_SCREEN_ATTR_TILE_EX(x) (((x) & 0x1FF) | (((x) >> 13) << 13))
#define WS_SCREEN_ATTR_TILE_EX_MASK (0x21FF)

#define WS_SCREEN_ATTR_FLIP_H    0x4000
#define WS_SCREEN_ATTR_FLIP_V    0x8000
#define WS_SCREEN_ATTR_FLIP      0xC000
#define WS_SCREEN_ATTR_FLIP_MASK 0xC000
 
#define WS_SCREEN_WIDTH_TILES   32
#define WS_SCREEN_HEIGHT_TILES  32
#define WS_SCREEN_WIDTH_PIXELS  (WS_SCREEN_WIDTH_TILES  * WS_DISPLAY_TILE_WIDTH)
#define WS_SCREEN_HEIGHT_PIXELS (WS_SCREEN_HEIGHT_TILES * WS_DISPLAY_TILE_HEIGHT)

#define WS_SPRITE_ATTR_TILE(x) (x)
#define WS_SPRITE_ATTR_TILE_MASK (0x1FF)
#define WS_SPRITE_ATTR_PALETTE(x) ((x) << 9)
#define WS_SPRITE_ATTR_PALETTE_MASK (0x7 << 9)
#define WS_SPRITE_ATTR_OUTSIDE   0x1000
#define WS_SPRITE_ATTR_PRIORITY  0x2000
#define WS_SPRITE_ATTR_FLIP_H    0x4000
#define WS_SPRITE_ATTR_FLIP_V    0x8000
#define WS_SPRITE_ATTR_FLIP      0xC000
#define WS_SPRITE_ATTR_FLIP_MASK 0xC000
#define WS_SPRITE_MAX_COUNT 128
#define WS_SPRITE_MAX_LINE_COUNT 32
 
#ifndef __ASSEMBLER__
typedef struct {
    union {
        struct {
            uint16_t cell[WS_SCREEN_WIDTH_TILES];
        } row[WS_SCREEN_HEIGHT_TILES];
        uint16_t cell[WS_SCREEN_WIDTH_TILES * WS_SCREEN_HEIGHT_TILES];
    };
} ws_screen_t;
_Static_assert(sizeof(ws_screen_t) == WS_SCREEN_WIDTH_TILES * WS_SCREEN_HEIGHT_TILES * 2, "invalid ws_screen_t size");
 
typedef struct {
    uint16_t attr;
    uint8_t y;
    uint8_t x;
} ws_sprite_t;
_Static_assert(sizeof(ws_sprite_t) == 4, "invalid ws_sprite_t size");
 
typedef struct {
    ws_sprite_t entry[WS_SPRITE_MAX_COUNT];
} ws_sprite_table_t;
_Static_assert(sizeof(ws_sprite_table_t) == WS_SPRITE_MAX_COUNT * 4, "invalid ws_sprite_table_t size");
#endif

#define WS_RGB(r, g, b) (((r) << 8) | ((g) << 4) | (b))

#define WS_DISPLAY_MONO_PALETTE(c0, c1, c2, c3) ((c0) | ((c1) << 4) | ((c2) << 8) | ((c3) << 12))
 
#ifndef __ASSEMBLER__

#define WS_TILE_MEM(i) ((ws_display_tile_t ws_iram *) (0x2000 + ((i) << 4)))

#define WS_TILE_4BPP_MEM(i) ((ws_display_tile_4bpp_t ws_iram *) (0x4000 + ((i) << 5)))

#define WS_TILE_BANKED_MEM(b, i) ((ws_display_tile_t ws_iram *) (0x2000 + (!!(b) << 13) + ((i) << 4)))

#define WS_TILE_4BPP_BANKED_MEM(b, i) ((ws_display_tile_4bpp_t ws_iram *) (0x4000 + (!!(b) << 14) + ((i) << 5)))

#define WS_DISPLAY_COLOR_MEM(i) ((uint16_t ws_iram *) (0xFE00 + ((i) << 5)))

#define WS_SCREEN_COLOR_MEM WS_DISPLAY_COLOR_MEM

#define WS_SPRITE_COLOR_MEM(i) ((uint16_t ws_iram *) (0xFF00 + ((i) << 5)))
 
#define WS_DISPLAY_SHADE_LUT(c0, c1, c2, c3, c4, c5, c6, c7) \
    (((uint32_t)(c0)) | (((uint32_t)(c1)) << 4) | (((uint32_t)(c2)) << 8) | (((uint32_t)(c3)) << 12) | \
    (((uint32_t)(c4)) << 16) | (((uint32_t)(c5)) << 20) | (((uint32_t)(c6)) << 24) | (((uint32_t)(c7)) << 28))
#define WS_DISPLAY_SHADE_LUT_DEFAULT WS_DISPLAY_SHADE_LUT(0, 2, 4, 6, 9, 11, 13, 15)
 
// TODO: Add ws_display_set_backdrop (has to consider mono/color modes have different values)

static inline void ws_display_load_palette_mono(const void __far* data, int first, int count) {
    ws_portcpy(WS_SCR_PAL_PORT(first), data, count * 2);
}

void ws_display_load_palette_color_2bpp(const void __far* data, int first, int count);

static inline void ws_display_load_palette_color_4bpp(const void __far* data, int first, int count) {
    memcpy(WS_DISPLAY_COLOR_MEM(first), data, count * 32);
}
 
#define ws_sprite_load_palette_mono(data, first, count) ws_display_load_palette_mono((data), (first) + 8, (count))
#define ws_sprite_load_palette_color_2bpp(data, first, count) ws_display_load_palette_color_2bpp((data), (first) + 8, (count))
#define ws_sprite_load_palette_color_4bpp(data, first, count) ws_display_load_palette_color_4bpp((data), (first) + 8, (count))

static inline void ws_display_set_control(uint8_t value) {
    outportb(WS_DISPLAY_CTRL_PORT, value);
}

static inline uint8_t ws_display_get_control(void) {
    return inportb(WS_DISPLAY_CTRL_PORT);
}

static inline void ws_display_set_screen_addresses(const void __wf_iram* scr1_addr, const void __wf_iram* scr2_addr) {
    outportb(WS_SCR_BASE_PORT, WS_SCR_BASE_ADDR1(scr1_addr) | WS_SCR_BASE_ADDR2(scr2_addr));
}

static inline void ws_display_set_screen_address(uint8_t screen, const void __wf_iram* address) {
    outportb(WS_SCR_BASE_PORT, (inportb(WS_SCR_BASE_PORT) & (0xF0 >> (screen * 4))) | (WS_SCR_BASE_ADDR1(address) << (screen * 4)));
}

#define ws_display_set_screen1_address(address) ws_display_set_screen_address(0, (address))

#define ws_display_set_screen2_address(address) ws_display_set_screen_address(1, (address))

static inline void ws_display_set_sprite_address(const void __wf_iram* address) {
    outportb(WS_SPR_BASE_PORT, WS_SPR_BASE_ADDR(address));
}

static inline void ws_display_set_screen2_window(uint8_t x, uint8_t y, uint8_t width, uint8_t height) {
    outportw(WS_SCR2_WIN_X1_PORT, x | (y << 8));
    outportw(WS_SCR2_WIN_X2_PORT, ((x + width - 1) & 0xFF) | ((y + height - 1) << 8));
}

static inline void ws_display_set_screen2_window_corners(uint8_t left, uint8_t top, uint8_t right, uint8_t bottom) {
    outportw(WS_SCR2_WIN_X1_PORT, left | (top << 8));
    outportw(WS_SCR2_WIN_X2_PORT, right | (bottom << 8));
}

static inline void ws_display_set_sprite_window(uint8_t x, uint8_t y, uint8_t width, uint8_t height) {
    outportw(WS_SPR_WIN_X1_PORT, x | (y << 8));
    outportw(WS_SPR_WIN_X2_PORT, ((x + width - 1) & 0xFF) | ((y + height - 1) << 8));
}

static inline void ws_display_set_sprite_window_corners(uint8_t left, uint8_t top, uint8_t right, uint8_t bottom) {
    outportw(WS_SPR_WIN_X1_PORT, left | (top << 8));
    outportw(WS_SPR_WIN_X2_PORT, right | (bottom << 8));
}

static inline void ws_display_scroll_screen_to(uint8_t screen, uint8_t x, uint8_t y) {
    outportw(WS_SCR1_SCRL_X_PORT + (screen * 2), x | (y << 8));
}

#define ws_display_scroll_screen1_to(x, y) ws_display_scroll_screen_to(0, (x), (y))

#define ws_display_scroll_screen2_to(x, y) ws_display_scroll_screen_to(1, (x), (y))

void ws_display_scroll_screen_by(uint8_t screen, int16_t x, int16_t y);

static inline uint8_t ws_display_get_current_line(void) {
    return inportb(WS_DISPLAY_LINE_PORT);
}

static inline void ws_display_scroll_screen1_by(uint8_t x, uint8_t y) {
    __asm (
        "in $0x10, %%ax\nadd %0, %%al\nadd %1, %%ah\nout %%ax, $0x10"
        : : "g"(x), "g"(y) : "a", "cc"
    );
}

static inline void ws_display_scroll_screen2_by(uint8_t x, uint8_t y) {
    __asm (
        "in $0x12, %%ax\nadd %0, %%al\nadd %1, %%ah\nout %%ax, $0x12"
        : : "g"(x), "g"(y) : "a", "cc"
    );
}

static inline void ws_display_set_icons(uint8_t mask) {
    outportb(WS_LCD_ICON_PORT, mask);
}

static inline void ws_display_show_icons(uint8_t mask) {
    outportb(WS_LCD_ICON_PORT, inportb(WS_LCD_ICON_PORT) | mask);
}

static inline void ws_display_hide_icons(uint8_t mask) {
    outportb(WS_LCD_ICON_PORT, inportb(WS_LCD_ICON_PORT) & ~mask);
}

static inline void ws_display_toggle_icons(uint8_t mask) {
    outportb(WS_LCD_ICON_PORT, inportb(WS_LCD_ICON_PORT) ^ mask);
}

__attribute__((no_assume_ds_data, no_assume_ss_data, save_all))
void ws_display_set_shade_lut(uint32_t lut);

#define ws_display_set_shade_lut_default() ws_display_set_shade_lut(WS_DISPLAY_SHADE_LUT_DEFAULT)

static inline void ws_lcd_control_enable(void) {
    outportb(WS_LCD_CTRL_PORT, inportb(WS_LCD_CTRL_PORT) | WS_LCD_CTRL_DISPLAY_ENABLE);
}

static inline void ws_lcd_control_disable(void) {
    outportb(WS_LCD_CTRL_PORT, inportb(WS_LCD_CTRL_PORT) & ~WS_LCD_CTRL_DISPLAY_ENABLE);
}

static inline void ws_screen_put_tiles(void ws_iram *dest, const void __far *src, uint16_t x, uint16_t y, uint16_t width, uint16_t height) {
    void __libws_screen_put_tiles(void ws_iram *dest, const void __far *src, uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t pitch);
    __libws_screen_put_tiles(dest, src, x, y, width, height, width);
}

static inline void ws_screen_put_tiles_ex(void ws_iram *dest, const void __far *src, uint16_t sx, uint16_t sy, uint16_t pitch, uint16_t dx, uint16_t dy, uint16_t width, uint16_t height) {
    void __libws_screen_put_tiles(void ws_iram *dest, const void __far *src, uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t pitch);
    __libws_screen_put_tiles(dest, ((const uint16_t __far*) src) + (sy * pitch) + sx, dx, dy, width, height, pitch);
}

void ws_screen_get_tiles(void __far *dest, const void ws_iram *src, uint16_t x, uint16_t y, uint16_t width, uint16_t height);

void ws_screen_fill_tiles(void ws_iram *dest, uint16_t src, uint16_t x, uint16_t y, uint16_t width, uint16_t height);

void ws_screen_modify_tiles(void ws_iram *dest, uint16_t mask, uint16_t value, uint16_t x, uint16_t y, uint16_t width, uint16_t height);

static inline void ws_screen_put_tile(void ws_iram *dest, uint16_t src, uint16_t x, uint16_t y) {
    ((uint16_t ws_iram*) dest)[((y & 0x1F) << 5) | (x & 0x1F)] = src;
}

static inline uint16_t ws_screen_get_tile(void ws_iram *src, uint16_t x, uint16_t y) {
    return ((uint16_t ws_iram*) src)[((y & 0x1F) << 5) | (x & 0x1F)];
}
 
#endif

 
#endif /* LIBWS_DISPLAY_H_ */