git.sesse.net Git - pistorm/blob - platforms/amiga/rtg/rtg.h

   1 // SPDX-License-Identifier: MIT
   2
   3 #define PIGFX_RTG_BASE     0x70000000
   4 #define PIGFX_REG_SIZE     0x00010000
   5 #define PIGFX_RTG_SIZE     0x02000000
   6 #define PIGFX_SCRATCH_SIZE 0x00800000
   7 #define PIGFX_SCRATCH_AREA 0x72010000
   8 #define PIGFX_UPPER        0x72810000
   9
  10 #define CARD_OFFSET 0
  11
  12 #include "rtg_enums.h"
  13
  14 void rtg_write(uint32_t address, uint32_t value, uint8_t mode);
  15 unsigned int rtg_read(uint32_t address, uint8_t mode);
  16 void rtg_set_clut_entry(uint8_t index, uint32_t xrgb);
  17 void rtg_init_display();
  18 void rtg_shutdown_display();
  19 void rtg_enable_mouse_cursor();
  20
  21 unsigned int rtg_get_fb();
  22 void rtg_set_mouse_cursor_pos(int16_t x, int16_t y);
  23 void rtg_set_cursor_clut_entry(uint8_t r, uint8_t g, uint8_t b, uint8_t idx);
  24 void rtg_set_mouse_cursor_image(uint8_t *src, uint8_t w, uint8_t h);
  25
  26 void rtg_show_fps(uint8_t enable);
  27 void rtg_palette_debug(uint8_t enable);
  28
  29 int init_rtg_data(struct emulator_config *cfg);
  30 void shutdown_rtg();
  31
  32 void rtg_fillrect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t color, uint16_t pitch, uint16_t format, uint8_t mask);
  33 void rtg_fillrect_solid(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t color, uint16_t pitch, uint16_t format);
  34 void rtg_invertrect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t pitch, uint16_t format, uint8_t mask);
  35 void rtg_blitrect(uint16_t x, uint16_t y, uint16_t dx, uint16_t dy, uint16_t w, uint16_t h, uint16_t pitch, uint16_t format, uint8_t mask);
  36 void rtg_blitrect_solid(uint16_t x, uint16_t y, uint16_t dx, uint16_t dy, uint16_t w, uint16_t h, uint16_t pitch, uint16_t format);
  37 void rtg_blitrect_nomask_complete(uint16_t sx, uint16_t sy, uint16_t dx, uint16_t dy, uint16_t w, uint16_t h, uint16_t srcpitch, uint16_t dstpitch, uint32_t src_addr, uint32_t dst_addr, uint16_t format, uint8_t minterm);
  38 void rtg_blittemplate(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t src_addr, uint32_t fgcol, uint32_t bgcol, uint16_t pitch, uint16_t t_pitch, uint16_t format, uint16_t offset_x, uint8_t mask, uint8_t draw_mode);
  39 void rtg_blitpattern(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t src_addr, uint32_t fgcol, uint32_t bgcol, uint16_t pitch, uint16_t format, uint16_t offset_x, uint16_t offset_y, uint8_t mask, uint8_t draw_mode, uint8_t loop_rows);
  40 void rtg_drawline_solid(int16_t x1_, int16_t y1_, int16_t x2_, int16_t y2_, uint16_t len, uint32_t fgcol, uint16_t pitch, uint16_t format);
  41 void rtg_drawline (int16_t x1_, int16_t y1_, int16_t x2_, int16_t y2_, uint16_t len, uint16_t pattern, uint16_t pattern_offset, uint32_t fgcol, uint32_t bgcol, uint16_t pitch, uint16_t format, uint8_t mask, uint8_t draw_mode);
  42
  43 void rtg_p2c (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t h, uint8_t draw_mode, uint8_t planes, uint8_t mask, uint8_t layer_mask, uint16_t src_line_pitch, uint8_t *bmp_data_src);
  44 void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t h, uint8_t draw_mode, uint8_t planes, uint8_t mask, uint8_t layer_mask, uint16_t src_line_pitch, uint8_t *bmp_data_src);
  45
  46 #define PATTERN_LOOPX \
  47     if (sptr)   { cur_byte = sptr[tmpl_x]; } \
  48     else        { cur_byte = m68k_read_memory_8(src_addr + tmpl_x); } \
  49     if (invert) { cur_byte ^= 0xFF; } \
  50     tmpl_x ^= 0x01;
  51
  52 #define PATTERN_LOOPY \
  53         sptr += 2 ; \
  54     src_addr += 2; \
  55         if ((ys + offset_y + 1) % loop_rows == 0) { \
  56                 if (sptr) sptr = sptr_base; \
  57         src_addr = src_addr_base; \
  58     } \
  59         tmpl_x = (offset_x / 8) % 2; \
  60         cur_bit = base_bit; \
  61         dptr += pitch;
  62
  63 #define TEMPLATE_LOOPX \
  64     if (sptr)   { cur_byte = sptr[tmpl_x]; } \
  65     else        { cur_byte = m68k_read_memory_8(src_addr + tmpl_x); } \
  66     if (invert) { cur_byte ^= 0xFF; } \
  67     tmpl_x++;
  68
  69 #define TEMPLATE_LOOPY \
  70     if (sptr) sptr += t_pitch; \
  71     src_addr += t_pitch; \
  72     dptr += pitch; \
  73     tmpl_x = offset_x / 8; \
  74     cur_bit = base_bit;
  75
  76 #define INVERT_RTG_PIXELS(dest, format) \
  77     switch (format) { \
  78         case RTGFMT_8BIT: \
  79             if (cur_byte & 0x80) (dest)[0] ^= mask; \
  80             if (cur_byte & 0x40) (dest)[1] ^= mask; \
  81             if (cur_byte & 0x20) (dest)[2] ^= mask; \
  82             if (cur_byte & 0x10) (dest)[3] ^= mask; \
  83             if (cur_byte & 0x08) (dest)[4] ^= mask; \
  84             if (cur_byte & 0x04) (dest)[5] ^= mask; \
  85             if (cur_byte & 0x02) (dest)[6] ^= mask; \
  86             if (cur_byte & 0x01) (dest)[7] ^= mask; \
  87             break; \
  88         case RTGFMT_RBG565: \
  89             if (cur_byte & 0x80) ((uint16_t *)dest)[0] = ~((uint16_t *)dest)[0]; \
  90             if (cur_byte & 0x40) ((uint16_t *)dest)[1] = ~((uint16_t *)dest)[1]; \
  91             if (cur_byte & 0x20) ((uint16_t *)dest)[2] = ~((uint16_t *)dest)[2]; \
  92             if (cur_byte & 0x10) ((uint16_t *)dest)[3] = ~((uint16_t *)dest)[3]; \
  93             if (cur_byte & 0x08) ((uint16_t *)dest)[4] = ~((uint16_t *)dest)[4]; \
  94             if (cur_byte & 0x04) ((uint16_t *)dest)[5] = ~((uint16_t *)dest)[5]; \
  95             if (cur_byte & 0x02) ((uint16_t *)dest)[6] = ~((uint16_t *)dest)[6]; \
  96             if (cur_byte & 0x01) ((uint16_t *)dest)[7] = ~((uint16_t *)dest)[7]; \
  97             break; \
  98         case RTGFMT_RGB32: \
  99             if (cur_byte & 0x80) ((uint32_t *)dest)[0] = ~((uint32_t *)dest)[0]; \
 100             if (cur_byte & 0x40) ((uint32_t *)dest)[1] = ~((uint32_t *)dest)[1]; \
 101             if (cur_byte & 0x20) ((uint32_t *)dest)[2] = ~((uint32_t *)dest)[2]; \
 102             if (cur_byte & 0x10) ((uint32_t *)dest)[3] = ~((uint32_t *)dest)[3]; \
 103             if (cur_byte & 0x08) ((uint32_t *)dest)[4] = ~((uint32_t *)dest)[4]; \
 104             if (cur_byte & 0x04) ((uint32_t *)dest)[5] = ~((uint32_t *)dest)[5]; \
 105             if (cur_byte & 0x02) ((uint32_t *)dest)[6] = ~((uint32_t *)dest)[6]; \
 106             if (cur_byte & 0x01) ((uint32_t *)dest)[7] = ~((uint32_t *)dest)[7]; \
 107             break; \
 108     }
 109
 110 #define SET_RTG_PIXELS_MASK(dest, src, format) \
 111     if (cur_byte & 0x80) (dest)[0] = src ^ ((dest)[0] & ~mask); \
 112     if (cur_byte & 0x40) (dest)[1] = src ^ ((dest)[1] & ~mask); \
 113     if (cur_byte & 0x20) (dest)[2] = src ^ ((dest)[2] & ~mask); \
 114     if (cur_byte & 0x10) (dest)[3] = src ^ ((dest)[3] & ~mask); \
 115     if (cur_byte & 0x08) (dest)[4] = src ^ ((dest)[4] & ~mask); \
 116     if (cur_byte & 0x04) (dest)[5] = src ^ ((dest)[5] & ~mask); \
 117     if (cur_byte & 0x02) (dest)[6] = src ^ ((dest)[6] & ~mask); \
 118     if (cur_byte & 0x01) (dest)[7] = src ^ ((dest)[7] & ~mask); \
 119
 120 #define SET_RTG_PIXELS2_COND_MASK(dest, src, src2, format) \
 121     (dest)[0] = (cur_byte & 0x80) ? src : src2 ^ ((dest)[0] & ~mask); \
 122     (dest)[1] = (cur_byte & 0x40) ? src : src2 ^ ((dest)[1] & ~mask); \
 123     (dest)[2] = (cur_byte & 0x20) ? src : src2 ^ ((dest)[2] & ~mask); \
 124     (dest)[3] = (cur_byte & 0x10) ? src : src2 ^ ((dest)[3] & ~mask); \
 125     (dest)[4] = (cur_byte & 0x08) ? src : src2 ^ ((dest)[4] & ~mask); \
 126     (dest)[5] = (cur_byte & 0x04) ? src : src2 ^ ((dest)[5] & ~mask); \
 127     (dest)[6] = (cur_byte & 0x02) ? src : src2 ^ ((dest)[6] & ~mask); \
 128     (dest)[7] = (cur_byte & 0x01) ? src : src2 ^ ((dest)[7] & ~mask); \
 129
 130
 131 #define SET_RTG_PIXELS(dest, src, format) \
 132     switch (format) { \
 133         case RTGFMT_8BIT: \
 134             if (cur_byte & 0x80) (dest)[0] = src; \
 135             if (cur_byte & 0x40) (dest)[1] = src; \
 136             if (cur_byte & 0x20) (dest)[2] = src; \
 137             if (cur_byte & 0x10) (dest)[3] = src; \
 138             if (cur_byte & 0x08) (dest)[4] = src; \
 139             if (cur_byte & 0x04) (dest)[5] = src; \
 140             if (cur_byte & 0x02) (dest)[6] = src; \
 141             if (cur_byte & 0x01) (dest)[7] = src; \
 142             break; \
 143         case RTGFMT_RBG565: \
 144             if (cur_byte & 0x80) ((uint16_t *)dest)[0] = src; \
 145             if (cur_byte & 0x40) ((uint16_t *)dest)[1] = src; \
 146             if (cur_byte & 0x20) ((uint16_t *)dest)[2] = src; \
 147             if (cur_byte & 0x10) ((uint16_t *)dest)[3] = src; \
 148             if (cur_byte & 0x08) ((uint16_t *)dest)[4] = src; \
 149             if (cur_byte & 0x04) ((uint16_t *)dest)[5] = src; \
 150             if (cur_byte & 0x02) ((uint16_t *)dest)[6] = src; \
 151             if (cur_byte & 0x01) ((uint16_t *)dest)[7] = src; \
 152             break; \
 153         case RTGFMT_RGB32: \
 154             if (cur_byte & 0x80) ((uint32_t *)dest)[0] = src; \
 155             if (cur_byte & 0x40) ((uint32_t *)dest)[1] = src; \
 156             if (cur_byte & 0x20) ((uint32_t *)dest)[2] = src; \
 157             if (cur_byte & 0x10) ((uint32_t *)dest)[3] = src; \
 158             if (cur_byte & 0x08) ((uint32_t *)dest)[4] = src; \
 159             if (cur_byte & 0x04) ((uint32_t *)dest)[5] = src; \
 160             if (cur_byte & 0x02) ((uint32_t *)dest)[6] = src; \
 161             if (cur_byte & 0x01) ((uint32_t *)dest)[7] = src; \
 162             break; \
 163     }
 164
 165 #define SET_RTG_PIXELS2_COND(dest, src, src2, format) \
 166     switch (format) { \
 167         case RTGFMT_8BIT: \
 168             (dest)[0] = (cur_byte & 0x80) ? src : src2; \
 169             (dest)[1] = (cur_byte & 0x40) ? src : src2; \
 170             (dest)[2] = (cur_byte & 0x20) ? src : src2; \
 171             (dest)[3] = (cur_byte & 0x10) ? src : src2; \
 172             (dest)[4] = (cur_byte & 0x08) ? src : src2; \
 173             (dest)[5] = (cur_byte & 0x04) ? src : src2; \
 174             (dest)[6] = (cur_byte & 0x02) ? src : src2; \
 175             (dest)[7] = (cur_byte & 0x01) ? src : src2; \
 176             break; \
 177         case RTGFMT_RBG565: \
 178             ((uint16_t *)dest)[0] = (cur_byte & 0x80) ? src : src2; \
 179             ((uint16_t *)dest)[1] = (cur_byte & 0x40) ? src : src2; \
 180             ((uint16_t *)dest)[2] = (cur_byte & 0x20) ? src : src2; \
 181             ((uint16_t *)dest)[3] = (cur_byte & 0x10) ? src : src2; \
 182             ((uint16_t *)dest)[4] = (cur_byte & 0x08) ? src : src2; \
 183             ((uint16_t *)dest)[5] = (cur_byte & 0x04) ? src : src2; \
 184             ((uint16_t *)dest)[6] = (cur_byte & 0x02) ? src : src2; \
 185             ((uint16_t *)dest)[7] = (cur_byte & 0x01) ? src : src2; \
 186             break; \
 187         case RTGFMT_RGB32: \
 188             ((uint32_t *)dest)[0] = (cur_byte & 0x80) ? src : src2; \
 189             ((uint32_t *)dest)[1] = (cur_byte & 0x40) ? src : src2; \
 190             ((uint32_t *)dest)[2] = (cur_byte & 0x20) ? src : src2; \
 191             ((uint32_t *)dest)[3] = (cur_byte & 0x10) ? src : src2; \
 192             ((uint32_t *)dest)[4] = (cur_byte & 0x08) ? src : src2; \
 193             ((uint32_t *)dest)[5] = (cur_byte & 0x04) ? src : src2; \
 194             ((uint32_t *)dest)[6] = (cur_byte & 0x02) ? src : src2; \
 195             ((uint32_t *)dest)[7] = (cur_byte & 0x01) ? src : src2; \
 196             break; \
 197     }
 198
 199
 200
 201 #define SET_RTG_PIXEL(dest, src, format) \
 202     switch (format) { \
 203         case RTGFMT_8BIT: \
 204             *(dest) = src; \
 205             break; \
 206         case RTGFMT_RBG565: \
 207             *((uint16_t *)dest) = src; \
 208             break; \
 209         case RTGFMT_RGB32: \
 210             *((uint32_t *)dest) = src; \
 211             break; \
 212     }
 213
 214 #define SET_RTG_PIXEL_MASK(dest, src, format) \
 215     switch (format) { \
 216         case RTGFMT_8BIT: \
 217             *(dest) = src ^ (*(dest) & ~mask); \
 218             break; \
 219         case RTGFMT_RBG565: \
 220             *((uint16_t *)dest) = src; \
 221             break; \
 222         case RTGFMT_RGB32: \
 223             *((uint32_t *)dest) = src; \
 224             break; \
 225     }
 226
 227 #define INVERT_RTG_PIXEL(dest, format) \
 228     switch (format) { \
 229         case RTGFMT_8BIT: \
 230             *(dest) ^= mask; \
 231             break; \
 232         case RTGFMT_RBG565: \
 233             *((uint16_t *)dest) = ~*((uint16_t *)dest); \
 234             break; \
 235         case RTGFMT_RGB32: \
 236             *((uint32_t *)dest) = ~*((uint32_t *)dest); \
 237             break; \
 238     }
 239
 240 #define HANDLE_MINTERM_PIXEL(s, d, f) \
 241       switch(draw_mode) {\
 242             case MINTERM_NOR: \
 243                   s &= ~(d); \
 244             SET_RTG_PIXEL_MASK(&d, s, f); break; \
 245             case MINTERM_ONLYDST: \
 246                   d = d & ~(s); break; \
 247             case MINTERM_NOTSRC: \
 248             SET_RTG_PIXEL_MASK(&d, s, f); break; \
 249             case MINTERM_ONLYSRC: \
 250                   s &= (d ^ 0xFF); \
 251             SET_RTG_PIXEL_MASK(&d, s, f); break; \
 252             case MINTERM_INVERT: \
 253                   d ^= 0xFF; break; \
 254             case MINTERM_EOR: \
 255                   d ^= s; break; \
 256             case MINTERM_NAND: \
 257                   s = ~(d & ~(s)) & mask; \
 258             SET_RTG_PIXEL_MASK(&d, s, f); break; \
 259             case MINTERM_AND: \
 260                   s &= d; \
 261             SET_RTG_PIXEL_MASK(&d, s, f); break; \
 262             case MINTERM_NEOR: \
 263                   d ^= (s & mask); break; \
 264             case MINTERM_DST: /* This one does nothing. */ \
 265                   return; break; \
 266             case MINTERM_NOTONLYSRC: \
 267                   d |= (s & mask); break; \
 268             case MINTERM_SRC: \
 269             SET_RTG_PIXEL_MASK(&d, s, f); break; \
 270             case MINTERM_NOTONLYDST: \
 271                   s = ~(d & s) & mask; \
 272             SET_RTG_PIXEL_MASK(&d, s, f); break; \
 273             case MINTERM_OR: \
 274                   d |= (s & mask); break; \
 275       }
 276
 277
 278 #define DECODE_PLANAR_PIXEL(a) \
 279         switch (planes) { \
 280                 case 8: if (layer_mask & 0x80 && bmp_data[(plane_size * 7) + cur_byte] & cur_bit) a |= 0x80; \
 281         /* Fallthrough */ \
 282                 case 7: if (layer_mask & 0x40 && bmp_data[(plane_size * 6) + cur_byte] & cur_bit) a |= 0x40; \
 283         /* Fallthrough */ \
 284                 case 6: if (layer_mask & 0x20 && bmp_data[(plane_size * 5) + cur_byte] & cur_bit) a |= 0x20; \
 285         /* Fallthrough */ \
 286                 case 5: if (layer_mask & 0x10 && bmp_data[(plane_size * 4) + cur_byte] & cur_bit) a |= 0x10; \
 287         /* Fallthrough */ \
 288                 case 4: if (layer_mask & 0x08 && bmp_data[(plane_size * 3) + cur_byte] & cur_bit) a |= 0x08; \
 289         /* Fallthrough */ \
 290                 case 3: if (layer_mask & 0x04 && bmp_data[(plane_size * 2) + cur_byte] & cur_bit) a |= 0x04; \
 291         /* Fallthrough */ \
 292                 case 2: if (layer_mask & 0x02 && bmp_data[plane_size + cur_byte] & cur_bit) a |= 0x02; \
 293         /* Fallthrough */ \
 294                 case 1: if (layer_mask & 0x01 && bmp_data[cur_byte] & cur_bit) a |= 0x01; \
 295                         break; \
 296         }
 297
 298 #define DECODE_INVERTED_PLANAR_PIXEL(a) \
 299         switch (planes) { \
 300                 case 8: if (layer_mask & 0x80 && (bmp_data[(plane_size * 7) + cur_byte] ^ 0xFF) & cur_bit) a |= 0x80; \
 301         /* Fallthrough */ \
 302                 case 7: if (layer_mask & 0x40 && (bmp_data[(plane_size * 6) + cur_byte] ^ 0xFF) & cur_bit) a |= 0x40; \
 303         /* Fallthrough */ \
 304                 case 6: if (layer_mask & 0x20 && (bmp_data[(plane_size * 5) + cur_byte] ^ 0xFF) & cur_bit) a |= 0x20; \
 305         /* Fallthrough */ \
 306                 case 5: if (layer_mask & 0x10 && (bmp_data[(plane_size * 4) + cur_byte] ^ 0xFF) & cur_bit) a |= 0x10; \
 307         /* Fallthrough */ \
 308                 case 4: if (layer_mask & 0x08 && (bmp_data[(plane_size * 3) + cur_byte] ^ 0xFF) & cur_bit) a |= 0x08; \
 309         /* Fallthrough */ \
 310                 case 3: if (layer_mask & 0x04 && (bmp_data[(plane_size * 2) + cur_byte] ^ 0xFF) & cur_bit) a |= 0x04; \
 311         /* Fallthrough */ \
 312                 case 2: if (layer_mask & 0x02 && (bmp_data[plane_size + cur_byte] ^ 0xFF) & cur_bit) a |= 0x02; \
 313         /* Fallthrough */ \
 314                 case 1: if (layer_mask & 0x01 && (bmp_data[cur_byte] ^ 0xFF) & cur_bit) a |= 0x01; \
 315                         break; \
 316         }