emulator/ppucore/vram.c

   1 #include <stddef.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include "tools.h"
   7 #include "ppucore.h"
   8 #include "vram.h"
   9
  10 void palette_index_to_rgb15(int bank, unsigned char index, struct rgb15* rgb);
  11 void dump_mem(const char* msg, unsigned short base,
  12         unsigned short offset, unsigned char* buf, int size);
  13
  14 #define PATTERN_TBL_SIZE    0x1000
  15 #define NAME_TBL_SIZE       V_SCREEN_TILE_SIZE * H_SCREEN_TILE_SIZE
  16 #define ATTR_TBL_SIZE       (VIRT_SCREEN_TILE_SIZE * VIRT_SCREEN_TILE_SIZE \
  17                             / ATTR_GROUP_UNIT / ATTR_UNIT_PER_BYTE)
  18 #define PALETTE_TBL_SIZE    16
  19 #define SPRITE_RAM_SIZE     0xff
  20
  21 #define PATTERN_ADDR_MASK       (PATTERN_TBL_SIZE - 1)
  22 #define NAME_TBL_ADDR_MASK      (NAME_TBL_SIZE - 1)
  23 #define ATTR_TBL_ADDR_MASK      (ATTR_TBL_SIZE - 1)
  24 #define PALETTE_TBL_ADDR_MASK   (PALETTE_TBL_SIZE - 1)
  25 #define SPR_RAM_ADDR_MASK       (SPRITE_RAM_SIZE - 1)
  26
  27 /*vram definition*/
  28 static unsigned char * sprite_ram;
  29
  30 static unsigned char * bg_palette_tbl;
  31 static unsigned char * spr_palette_tbl;
  32
  33 static unsigned char * name_tbl0;
  34 static unsigned char * name_tbl1;
  35 static unsigned char * name_tbl2;
  36 static unsigned char * name_tbl3;
  37
  38 static unsigned char * attr_tbl0;
  39 static unsigned char * attr_tbl1;
  40 static unsigned char * attr_tbl2;
  41 static unsigned char * attr_tbl3;
  42
  43 static unsigned char * pattern_tbl0;
  44 static unsigned char * pattern_tbl1;
  45
  46 /*
  47  * VRAM get/set functions....
  48  *
  49  * */
  50
  51 unsigned char pattern_tbl_get(unsigned char bank, unsigned short addr) {
  52     addr = addr & PATTERN_ADDR_MASK;
  53     if (bank == 0)
  54         return pattern_tbl0[addr];
  55     else
  56         return pattern_tbl1[addr];
  57 }
  58
  59 unsigned char name_tbl_get(unsigned char bank, unsigned short addr) {
  60     addr = addr & NAME_TBL_ADDR_MASK;
  61     if (bank == 0)
  62         return name_tbl0[addr];
  63     else if (bank == 1)
  64         return name_tbl1[addr];
  65     else if (bank == 2)
  66         return name_tbl2[addr];
  67     else
  68         return name_tbl3[addr];
  69 }
  70
  71 void name_tbl_set(unsigned char bank, unsigned short addr, unsigned char data) {
  72     addr = addr & NAME_TBL_ADDR_MASK;
  73     if (bank == 0)
  74         name_tbl0[addr] = data;
  75     else if (bank == 1)
  76         name_tbl1[addr] = data;
  77     else if (bank == 2)
  78         name_tbl2[addr] = data;
  79     else
  80         name_tbl3[addr] = data;
  81 }
  82
  83
  84 unsigned char attr_tbl_get(unsigned char bank, unsigned short addr) {
  85     addr = addr & ATTR_TBL_ADDR_MASK;
  86     if (bank == 0)
  87         return attr_tbl0[addr];
  88     else if (bank == 1)
  89         return attr_tbl1[addr];
  90     else if (bank == 2)
  91         return attr_tbl2[addr];
  92     else
  93         return attr_tbl3[addr];
  94 }
  95
  96 void attr_tbl_set(unsigned char bank, unsigned short addr, unsigned char data) {
  97     addr = addr & ATTR_TBL_ADDR_MASK;
  98     if (bank == 0)
  99         attr_tbl0[addr] = data;
 100     else if (bank == 1)
 101         attr_tbl1[addr] = data;
 102     else if (bank == 2)
 103         attr_tbl2[addr] = data;
 104     else
 105         attr_tbl3[addr] = data;
 106 }
 107
 108
 109 unsigned char spr_palette_tbl_get(unsigned short addr) {
 110     addr = addr & PALETTE_TBL_ADDR_MASK;
 111     return spr_palette_tbl[addr];
 112 }
 113
 114 void spr_palette_tbl_set(unsigned short addr, unsigned char data) {
 115     addr = addr & PALETTE_TBL_ADDR_MASK;
 116     spr_palette_tbl[addr] = data;
 117 }
 118
 119 unsigned char bg_palette_tbl_get(unsigned short addr) {
 120     addr = addr & PALETTE_TBL_ADDR_MASK;
 121     return bg_palette_tbl[addr];
 122 }
 123
 124 void bg_palette_tbl_set(unsigned short addr, unsigned char data) {
 125     addr = addr & PALETTE_TBL_ADDR_MASK;
 126     bg_palette_tbl[addr] = data;
 127 }
 128
 129
 130 unsigned char spr_ram_tbl_get(unsigned short addr) {
 131     addr = addr & SPR_RAM_ADDR_MASK;
 132     return sprite_ram[addr];
 133 }
 134
 135 void spr_ram_tbl_set(unsigned short addr, unsigned char data) {
 136     addr = addr & SPR_RAM_ADDR_MASK;
 137     sprite_ram[addr] = data;
 138 }
 139
 140 /* VRAM manipulation... */
 141
 142 void load_attribute(unsigned char bank, int tile_index, struct palette *plt) {
 143     int gp_index;
 144     int unit_index;
 145     unsigned char data;
 146     struct palette_unit pu;
 147     int palette_group;
 148     unsigned short palette_addr;
 149     unsigned char pi;
 150
 151     gp_index = tile_index / ATTR_GROUP_UNIT / ATTR_UNIT_PER_BYTE;
 152     unit_index = tile_index / ATTR_GROUP_UNIT;
 153     data = attr_tbl_get(bank, gp_index);
 154     pu = *(struct palette_unit*)&data;
 155     memcpy(&pu, &data, sizeof(pu));
 156     //dprint("attr data:%1x, pu size:%d\n", data, sizeof(pu));
 157
 158     switch(unit_index) {
 159         case 0:
 160             palette_group = pu.bit01;
 161             break;
 162         case 1:
 163             palette_group = pu.bit23;
 164             break;
 165         case 2:
 166             palette_group = pu.bit45;
 167             break;
 168         default:
 169             palette_group = pu.bit67;
 170             break;
 171     }
 172
 173     /*load bg rgb palette color*/
 174     palette_addr = palette_group * 4;
 175     pi = bg_palette_tbl_get(palette_addr++);
 176     palette_index_to_rgb15(0, pi, &plt->col[0]);
 177     pi = bg_palette_tbl_get(palette_addr++);
 178     palette_index_to_rgb15(0, pi, &plt->col[1]);
 179     pi = bg_palette_tbl_get(palette_addr++);
 180     palette_index_to_rgb15(0, pi, &plt->col[2]);
 181     pi = bg_palette_tbl_get(palette_addr);
 182     palette_index_to_rgb15(0, pi, &plt->col[3]);
 183
 184 }
 185
 186 /*
 187  * pattern index: 0 - 255
 188  * */
 189 void load_pattern(unsigned char bank, unsigned char ptn_index, struct tile_2* pattern) {
 190     int i;
 191     unsigned char data;
 192     unsigned char *p;
 193     unsigned short addr;
 194
 195     //load character pattern
 196     p = (unsigned char*)pattern;
 197     addr = ptn_index * sizeof(struct tile_2);
 198     for (i = 0; i < sizeof(struct tile_2); i++) {
 199         data = pattern_tbl_get(bank, addr);
 200         *p = data;
 201         p++;
 202     }
 203 }
 204
 205 /*
 206  * type
 207  * 0: pattern table
 208  * 1: name table
 209  * 2: attribute table
 210  * 3: palette table (bank=0: bg, bank=1: sprite)
 211  * 4: sprite ram
 212  * */
 213 void dump_vram(int type, int bank, unsigned short addr, int size) {
 214     char buf[100];
 215     unsigned short base;
 216     unsigned char *mem;
 217
 218     switch(type) {
 219         case 0:
 220             sprintf(buf, "pattern table %d:\n", bank);
 221             base = (bank == 0 ? 0 : 0x1000);
 222             mem = (bank == 0 ? pattern_tbl0 : pattern_tbl1);
 223             break;
 224
 225         case 1:
 226             sprintf(buf, "name table %d:\n", bank);
 227             base = 0x2000 + bank * 0x400;
 228             switch (bank) {
 229                 case 0:
 230                     mem = name_tbl0;
 231                     break;
 232                 case 1:
 233                     mem = name_tbl1;
 234                     break;
 235                 case 2:
 236                     mem = name_tbl2;
 237                     break;
 238                 case 3:
 239                 default:
 240                     mem = name_tbl3;
 241                     break;
 242             }
 243             break;
 244
 245         case 2:
 246             sprintf(buf, "attribute table %d:\n", bank);
 247             base = 0x23c0 + bank * 0x400;
 248             switch (bank) {
 249                 case 0:
 250                     mem = attr_tbl0;
 251                     break;
 252                 case 1:
 253                     mem = attr_tbl1;
 254                     break;
 255                 case 2:
 256                     mem = attr_tbl2;
 257                     break;
 258                 case 3:
 259                 default:
 260                     mem = attr_tbl3;
 261                     break;
 262             }
 263             break;
 264
 265         case 3:
 266             switch (bank) {
 267                 case 0:
 268                     base = 0x3f00;
 269                     sprintf(buf, "bg palette table %d:\n", bank);
 270                     mem = bg_palette_tbl;
 271                     break;
 272                 case 1:
 273                 default:
 274                     base = 0x3f10;
 275                     sprintf(buf, "sprite palette table %d:\n", bank);
 276                     mem = spr_palette_tbl;
 277                     break;
 278             }
 279             break;
 280
 281         case 4:
 282         default:
 283             sprintf(buf, "sprite ram:\n");
 284             base = 0;
 285             mem = sprite_ram;
 286             break;
 287
 288     }
 289     dump_mem(buf, base, addr, mem, size);
 290 }
 291
 292
 293 int load_chr_rom(FILE* cartridge, int num_rom_bank) {
 294     int len;
 295
 296     len = fread(pattern_tbl0, 1, PATTERN_TBL_SIZE, cartridge);
 297     if (len != PATTERN_TBL_SIZE)
 298         return FALSE;
 299
 300     len = fread(pattern_tbl1, 1, PATTERN_TBL_SIZE, cartridge);
 301     if (len != PATTERN_TBL_SIZE)
 302         return FALSE;
 303
 304     return TRUE;
 305 }
 306
 307 int vram_init(void) {
 308     name_tbl2 = NULL;
 309     name_tbl3 = NULL;
 310
 311     attr_tbl2 = NULL;
 312     attr_tbl3 = NULL;
 313
 314
 315     pattern_tbl0 = malloc(PATTERN_TBL_SIZE);
 316     if (pattern_tbl0 == NULL)
 317         return FALSE;
 318
 319     pattern_tbl1 = malloc(PATTERN_TBL_SIZE);
 320     if (pattern_tbl1 == NULL)
 321         return FALSE;
 322
 323     sprite_ram = malloc(SPRITE_RAM_SIZE);
 324     if (sprite_ram == NULL)
 325         return FALSE;
 326
 327     name_tbl0 = malloc(NAME_TBL_SIZE);
 328     if (name_tbl0 == NULL)
 329         return FALSE;
 330
 331     name_tbl1 = malloc(NAME_TBL_SIZE);
 332     if (name_tbl1 == NULL)
 333         return FALSE;
 334
 335     attr_tbl0 = malloc(ATTR_TBL_SIZE);
 336     if (attr_tbl0 == NULL)
 337         return FALSE;
 338
 339     attr_tbl1 = malloc(ATTR_TBL_SIZE);
 340     if (attr_tbl1 == NULL)
 341         return FALSE;
 342
 343     bg_palette_tbl = malloc(PALETTE_TBL_SIZE);
 344     if (bg_palette_tbl == NULL)
 345         return FALSE;
 346
 347     spr_palette_tbl = malloc(PALETTE_TBL_SIZE);
 348     if (spr_palette_tbl == NULL)
 349         return FALSE;
 350
 351     return TRUE;
 352 }
 353
 354 void clean_vram(void) {
 355
 356     free(pattern_tbl0);
 357     free(pattern_tbl1);
 358
 359     free(sprite_ram);
 360
 361     free(name_tbl0);
 362     free(name_tbl1);
 363
 364     free(attr_tbl0);
 365     free(attr_tbl1);
 366
 367     free(bg_palette_tbl);
 368     free(spr_palette_tbl);
 369
 370 }
 371
 372