vdp.h

Go to the documentation of this file.

// -*- coding: utf-8-unix -*-
/*
 * Copyright (c) 2021-2024 Daishi Mori (mori0091)
 *
 * This software is released under the MIT License.\n
 * See https://github.com/mori0091/libmsx/blob/main/LICENSE
 *
 * GitHub libmsx project\n
 * https://github.com/mori0091/libmsx
 */
#pragma once
 
#ifndef VDP_H
#define VDP_H
 
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
 
#include "io.h"
#include "vmem.h"
#include "vdp_unsafe.h"
 
#include "bios.h"
#include "workarea.h"
 
// ---- VDP status register
uint8_t vdp_get_status(uint8_t reg);
 
// ---- VDP control registers
void vdp_set_control(uint8_t reg, uint8_t x);
 
void vdp_write_control(uint8_t reg, void* src, uint8_t len);
 
// ---- VDP color register
void vdp_set_color(uint8_t c);  // set color register R#7
 
// ---- VDP palette registers
typedef uint16_t palette_t;
 
#define RGB(r, g, b)                                              \
  ((palette_t)((((g) & 7) << 8) | (((r) & 7) << 4) | ((b) & 7)))
 
void vdp_set_palette(uint8_t idx, const palette_t palette);
 
void vdp_write_palette(const palette_t palettes[16]);
 
// ---- VDP display setting
enum vdp_screen_mode {
  VDP_SCREEN_MODE_GRAPHIC_1   = 0, // SCREEN 1
  VDP_SCREEN_MODE_TEXT_1      = 1, // SCREEN 0: WIDTH 40
  VDP_SCREEN_MODE_MULTI_COLOR = 2, // SCREEN 3
  VDP_SCREEN_MODE_GRAPHIC_2   = 3, // SCREEN 2
  VDP_SCREEN_MODE_GRAPHIC_3   = 4, // SCREEN 4
  VDP_SCREEN_MODE_TEXT_2      = 5, // SCREEN 0: WIDTH 80
  VDP_SCREEN_MODE_GRAPHIC_4   = 6, // SCREEN 5
  VDP_SCREEN_MODE_GRAPHIC_5   = 7, // SCREEN 6
  VDP_SCREEN_MODE_GRAPHIC_6   = 8, // SCREEN 7
  VDP_SCREEN_MODE_GRAPHIC_7   = 9, // SCREEN 8
};
 
enum vdp_screen_lines {
  VDP_SCREEN_LINES_192 = 0x00,
  VDP_SCREEN_LINES_212 = 0x80,
};
 
enum vdp_sprite_size {
  VDP_SPRITE_SIZE_8x8 = 0,
  VDP_SPRITE_SIZE_8x8_MAGNIFIED = 1,
  VDP_SPRITE_SIZE_16x16 = 2,
  VDP_SPRITE_SIZE_16x16_MAGNIFIED = 3,
};
 
void vdp_set_screen_mode(enum vdp_screen_mode mode);
 
void vdp_set_screen_lines(enum vdp_screen_lines lines);
 
void vdp_set_visible(bool visible);
 
uint8_t vdp_get_sprite_mode(void);
 
void vdp_set_sprite_size(enum vdp_sprite_size size);
 
void vdp_set_sprite_visible(bool visible);
 
void vdp_set_image_table(vmemptr_t table);
 
void vdp_set_pattern_table(vmemptr_t table);
 
void vdp_set_color_table(vmemptr_t table);
 
void vdp_set_sprite_pattern_table(vmemptr_t table);
 
void vdp_set_sprite_attribute_table(vmemptr_t table);
 
void vdp_set_adjust(int8_t x, int8_t y);
 
void vdp_set_vscroll(uint8_t y);
 
void vdp_set_hscroll(uint16_t x);
 
void vdp_set_hscroll_mask(bool enable);
 
void vdp_set_hscroll_dual_page(bool enable);
 
enum vdp_yjk_mode {
  VDP_RGB     = 0x00,
  VDP_YJK     = 0x08,
  VDP_YJK_RGB = 0x18,
};
 
void vdp_set_yjk_mode(enum vdp_yjk_mode yjk);
 
// ---- VDP COMMANDs
inline bool vdp_cmd_is_running(void) {
  return (vdp_get_status(2) & 1);
}
 
inline void vdp_cmd_await(void) {
  while (vdp_cmd_is_running())
    ;
}
 
void vdp_cmd_set_unrestricted(bool enable);
 
enum vdp_cmd_logop {
  VDP_CMD_IMP  = 0x00,
  VDP_CMD_AND  = 0x01,
  VDP_CMD_OR   = 0x02,
  VDP_CMD_EOR  = 0x03,
  VDP_CMD_XOR  = VDP_CMD_EOR,
  VDP_CMD_NOT  = 0x04,
  VDP_CMD_TIMP = 0x08,
  VDP_CMD_TAND = 0x09,
  VDP_CMD_TOR  = 0x0a,
  VDP_CMD_TEOR = 0x0b,
  VDP_CMD_TXOR = VDP_CMD_TEOR,
  VDP_CMD_TNOT = 0x0c,
};
enum vdp_cmd_dir {
  VDP_CMD_LRTB = (0 << 2),      
  VDP_CMD_RLTB = (1 << 2),      
  VDP_CMD_LRBT = (2 << 2),      
  VDP_CMD_RLBT = (3 << 2),      
};
 
inline void vdp_cmd_stop(void) {
  vdp_set_control(46, 0);
}
 
uint8_t vdp_cmd_execute_POINT(uint16_t sx, uint16_t sy);
 
void vdp_cmd_execute_PSET(uint16_t dx, uint16_t dy,
                          uint8_t color,
                          enum vdp_cmd_logop logop);
 
bool vdp_cmd_execute_SRCH(uint16_t * ret,
                          uint16_t sx, uint16_t sy,
                          uint8_t color,
                          uint8_t arg);
 
void vdp_cmd_execute_LINE(uint16_t x1, uint16_t y1,
                          uint16_t x2, uint16_t y2,
                          uint8_t color,
                          enum vdp_cmd_logop logop);
 
 
bool vdp_cmd_read(uint8_t * ret);
 
void vdp_cmd_execute_LMCM(uint16_t x, uint16_t y,
                          uint16_t w, uint16_t h,
                          enum vdp_cmd_dir dir);
 
bool vdp_cmd_write(const uint8_t val);
 
void vdp_cmd_execute_LMMC(uint16_t x, uint16_t y,
                          uint16_t w, uint16_t h,
                          enum vdp_cmd_dir dir,
                          enum vdp_cmd_logop logop);
 
void vdp_cmd_execute_HMMC(uint16_t x, uint16_t y,
                          uint16_t w, uint16_t h,
                          enum vdp_cmd_dir dir);
 
void vdp_cmd_execute_LMMV(uint16_t x, uint16_t y, uint16_t w, uint16_t h,
                          uint8_t color, enum vdp_cmd_logop logop);
 
void vdp_cmd_execute_LMMM(uint16_t x, uint16_t y, uint16_t w, uint16_t h,
                          uint16_t x2, uint16_t y2, enum vdp_cmd_logop logop);
 
void vdp_cmd_execute_HMMV(uint16_t x, uint16_t y, uint16_t w, uint16_t h,
                          uint8_t color);
 
void vdp_cmd_execute_HMMM(uint16_t x, uint16_t y, uint16_t w, uint16_t h,
                          uint16_t x2, uint16_t y2);
 
void vdp_cmd_execute_YMMM(uint16_t x, uint16_t y, uint16_t h, uint16_t y2, uint8_t dir);
 
enum vdp_cmd_op {
  VDP_CMD_STOP = 0x00,
  VDP_CMD_POINT = 0x40,
  VDP_CMD_PSET = 0x50,
  VDP_CMD_SRCH = 0x60,
  VDP_CMD_LINE = 0x70,
  VDP_CMD_LMMV = 0x80,
  VDP_CMD_LMMM = 0x90,
  VDP_CMD_LMCM = 0xa0,
  VDP_CMD_LMMC = 0xb0,
  VDP_CMD_HMMV = 0xc0,
  VDP_CMD_HMMM = 0xd0,
  VDP_CMD_YMMM = 0xe0,
  VDP_CMD_HMMC = 0xf0,
};
 
struct vdp_cmd {
  uint8_t r32;            
  uint8_t r33;            
  uint8_t r34;            
  uint8_t r35;            
  uint8_t r36;            
  uint8_t r37;            
  uint8_t r38;            
  uint8_t r39;            
  uint8_t r40;            
  uint8_t r41;            
  uint8_t r42;            
  uint8_t r43;            
  uint8_t r44;            
  uint8_t r45;            
  uint8_t r46;            
};
 
inline void vdp_cmd_set_SX(struct vdp_cmd * c, uint16_t sx) {
  c->r32 = (sx & 0xff);
  c->r33 = (sx >> 8) & 0x01;
}
 
inline void vdp_cmd_set_SY(struct vdp_cmd * c, uint16_t sy) {
  c->r34 = (sy & 0xff);
  c->r35 = (sy >> 8) & 0x03;
}
 
inline void vdp_cmd_set_DX(struct vdp_cmd * c, uint16_t dx) {
  c->r36 = (dx & 0xff);
  c->r37 = (dx >> 8) & 0x01;
}
 
inline void vdp_cmd_set_DY(struct vdp_cmd * c, uint16_t dy) {
  c->r38 = (dy & 0xff);
  c->r39 = (dy >> 8) & 0x03;
}
 
inline void vdp_cmd_set_NX(struct vdp_cmd * c, uint16_t nx) {
  c->r40 = (nx & 0xff);
  c->r41 = (nx >> 8) & 0x01;
}
 
inline void vdp_cmd_set_NY(struct vdp_cmd * c, uint16_t ny) {
  c->r42 = (ny & 0xff);
  c->r43 = (ny >> 8) & 0x03;
}
 
inline void vdp_cmd_set_CLR(struct vdp_cmd * c, uint8_t clr) {
  c->r44 = clr;
}
 
inline void vdp_cmd_set_ARG(struct vdp_cmd * c, uint8_t arg) {
  c->r45 = arg;
}
 
inline void vdp_cmd_set_logop(struct vdp_cmd * c, enum vdp_cmd_logop logop) {
  c->r46 = logop;
}
 
void vdp_cmd_execute(const struct vdp_cmd * c, enum vdp_cmd_op opcode);
 
#endif