source/src/vm/pc6001/memory_draw.cpp

   1 /** iP6: PC-6000/6600 series emualtor ************************/
   2 /**                                                         **/
   3 /**                         Refresh.c                       **/
   4 /**                                                         **/
   5 /** modified by Windy 2002-2004                             **/
   6 /** by ISHIOKA Hiroshi 1998,1999                            **/
   7 /** This code is based on fMSX written by Marat Fayzullin   **/
   8 /** and Adaptions for any X-terminal by Arnold Metselaar    **/
   9 /*************************************************************/
  10
  11 /*
  12         NEC PC-6001 Emulator 'yaPC-6001'
  13         NEC PC-6001mkII Emulator 'yaPC-6201'
  14         NEC PC-6001mkIISR Emulator 'yaPC-6401'
  15         NEC PC-6601 Emulator 'yaPC-6601'
  16         NEC PC-6601SR Emulator 'yaPC-6801'
  17
  18         Author : tanam
  19         Date   : 2013.07.15-
  20
  21         [ draw ]
  22 */
  23
  24 #include "memory.h"
  25
  26 #define CGROM1          (MEMORY_BASE + CGROM1_BASE)
  27 #define CGROM5          (MEMORY_BASE + CGROM5_BASE)
  28 #define CGROM6          (MEMORY_BASE + CGROM6_BASE)
  29
  30 #define SETSCRVARM1(y1) dest = &screen[y1][0];W=0;
  31 #define SETSCRVARM5(y1) dest = &screen[y1][0];W=0;
  32 #define M1HEIGHT 192
  33 #define M5HEIGHT 200
  34 #define M6HEIGHT 204
  35 #define SeqPix21(c) dest[X*8+W]=c;W++;
  36 #define SeqPix41(c) dest[X*8+W]=c;W++;dest[X*8+W]=c;W++;
  37
  38 namespace PC6001 {
  39
  40 void MEMORY::draw_screen()
  41 {
  42         if (CRTKILL) {
  43                 for(int y = 0; y < 400; y++) {
  44                         scrntype_t* dest = emu->get_screen_buffer(y);
  45                         memset(dest, 0, 640 * sizeof(scrntype_t));
  46                 }
  47 #if defined(_PC6601SR) || defined(_PC6001MK2SR)
  48         } else if (static_cast<VM *>(vm)->sr_mode) {
  49                 if (CRTMode2) {
  50                         if (CRTMode3) RefreshScr63();
  51                         else RefreshScr62();
  52                 } else RefreshScr61();
  53                 // copy to screen
  54                 emu->set_vm_screen_lines(200);
  55                 if (bitmap) {
  56                         for(int y = 0; y < 200; y++) {
  57                                 scrntype_t* dest = emu->get_screen_buffer(y*2);
  58                                 scrntype_t* dest1 = emu->get_screen_buffer(y*2+1);
  59                                 for(int x = 0; x < 320; x++) {
  60                                         dest[x*2] = dest[x*2+1] = palette_pc[screen[y][x*2]];
  61                                 }
  62                                 if(config.scan_line) {
  63                                         memset(dest1, 0, 640 * sizeof(scrntype_t));
  64                                 } else {
  65                                         my_memcpy(dest1, dest, 640 * sizeof(scrntype_t));
  66                                 }
  67                         }
  68                 } else if (cols==40) {
  69                         for(int y = 0; y < 200; y++) {
  70                                 scrntype_t* dest = emu->get_screen_buffer(y*2);
  71                                 scrntype_t* dest1 = emu->get_screen_buffer(y*2+1);
  72                                 for(int x = 0; x < 320; x++) {
  73                                         dest[x*2] = dest[x*2+1] = palette_pc[screen[y][x]];
  74                                 }
  75                                 if(config.scan_line) {
  76                                         memset(dest1, 0, 640 * sizeof(scrntype_t));
  77                                 } else {
  78                                         my_memcpy(dest1, dest, 640 * sizeof(scrntype_t));
  79                                 }
  80                         }
  81                 } else {
  82                         for(int y = 0; y < 200; y++) {
  83                                 scrntype_t* dest = emu->get_screen_buffer(y*2);
  84                                 scrntype_t* dest1 = emu->get_screen_buffer(y*2+1);
  85                                 for(int x = 0; x < 640; x++) {
  86                                         dest[x] = palette_pc[screen[y][x]];
  87                                 }
  88                                 if(config.scan_line) {
  89                                         memset(dest1, 0, 640 * sizeof(scrntype_t));
  90                                 } else {
  91                                         my_memcpy(dest1, dest, 640 * sizeof(scrntype_t));
  92                                 }
  93                         }
  94                 }
  95 #endif
  96         } else {
  97                 if (CRTMode1) {
  98                         if (CRTMode2)
  99                                 if (CRTMode3) RefreshScr54();
 100                                 else RefreshScr53();
 101                         else RefreshScr51();
 102                         // copy to screen
 103                         emu->set_vm_screen_lines(200);
 104                         for(int y = 0; y < 200; y++) {
 105                                 scrntype_t* dest = emu->get_screen_buffer(y*2);
 106                                 scrntype_t* dest1 = emu->get_screen_buffer(y*2+1);
 107                                 for(int x = 0; x < 320; x++) {
 108                                         dest[x*2] = dest[x*2+1] = palette_pc[screen[y][x]];
 109                                 }
 110                                 if(config.scan_line) {
 111                                         memset(dest1, 0, 640 * sizeof(scrntype_t));
 112                                 } else {
 113                                         my_memcpy(dest1, dest, 640 * sizeof(scrntype_t));
 114                                 }
 115                         }
 116                 } else {
 117                         RefreshScr10();
 118                         // copy to screen
 119                         emu->set_vm_screen_lines(200);
 120                         for(int y = 0; y < 200; y++) {
 121                                 scrntype_t* dest = emu->get_screen_buffer(y*2);
 122                                 scrntype_t* dest1 = emu->get_screen_buffer(y*2+1);
 123                                 for(int x = 0; x < 320; x++) {
 124                                         if (x >= 32 && x < 288 && y >=4 && y < 196) {
 125                                                 dest[x*2] = dest[x*2+1] = palette_pc[screen[y-4][x-32]];
 126                                         } else {
 127                                                 dest[x*2] = dest[x*2+1] = palette_pc[8];
 128                                         }
 129                                 }
 130                                 if(config.scan_line) {
 131                                         memset(dest1, 0, 640 * sizeof(scrntype_t));
 132                                 } else {
 133                                         my_memcpy(dest1, dest, 640 * sizeof(scrntype_t));
 134                                 }
 135                         }
 136                 }
 137         }
 138         emu->screen_skip_line(true);
 139 }
 140
 141 // RefreshScr10: N60-BASIC select function
 142 void MEMORY::RefreshScr10()
 143 {
 144         if ((*VRAM&0x80) == 0x00)
 145                 RefreshScr11();
 146         else
 147                 switch (*(VRAM)&0x1C) {
 148                 case 0x00: case 0x10: //  64x 64 color / 128x 64
 149                         RefreshScr13a(); break;
 150                 case 0x08: // 128x 64 color
 151                         RefreshScr13b(); break;
 152                 case 0x18: // 128x 96
 153                         RefreshScr13c(); break;
 154                 case 0x04: // 128x 96 color
 155                         RefreshScr13d(); break;
 156                 case 0x14: // 128x192
 157                         RefreshScr13e(); break;
 158                 default: // 128x192 color / 256x192
 159                         RefreshScr13(); break;
 160                 }
 161 }
 162
 163 // RefreshScr11: N60-BASIC screen 1,2
 164 void MEMORY::RefreshScr11()
 165 {
 166         uint8_t X,Y,K;
 167         int FC,BC;
 168         uint8_t *S,*T1,*T2;
 169         uint8_t *G;
 170
 171         G = CGROM;              /* CGROM */
 172         T1 = VRAM;              /* attribute data */
 173         T2 = VRAM+0x0200;       /* ascii/semi-graphic data */
 174         for(Y=0; Y<M1HEIGHT; Y++) {
 175                 SETSCRVARM1(Y); /* Drawing area */
 176                 for(X=0; X<32; X++, T1++, T2++) {
 177                         /* get CGROM address and color */
 178                         if (*T1&0x40) { /* if semi-graphic */
 179                                 if (*T1&0x20) {         /* semi-graphic 6 */
 180                                         S = G+((*T2&0x3f)<<4)+0x1000;
 181                                         FC = BPal12[(*T1&0x02)<<1|(*T2)>>6]; BC = BPal[8];
 182                                 } else {                /* semi-graphic 4 */
 183                                         S = G+((*T2&0x0f)<<4)+0x2000;
 184                                         FC = BPal12[(*T2&0x70)>>4]; BC = BPal[8];
 185                                 }
 186                         } else {                /* if normal character */
 187                                 S = G+((*T2)<<4);
 188                                 FC = BPal11[(*T1&0x03)]; BC = BPal11[(*T1&0x03)^0x01];
 189                         }
 190                         K=*(S+Y%12);
 191 W=0;
 192                         SeqPix21(K&0x80? FC:BC); SeqPix21(K&0x40? FC:BC);
 193                         SeqPix21(K&0x20? FC:BC); SeqPix21(K&0x10? FC:BC);
 194                         SeqPix21(K&0x08? FC:BC); SeqPix21(K&0x04? FC:BC);
 195                         SeqPix21(K&0x02? FC:BC); SeqPix21(K&0x01? FC:BC);
 196                 }
 197                 if (Y%12!=11) { T1-=32; T2-=32; }
 198         }
 199 }
 200
 201 // RefreshScr13: N60-BASIC screen 3,4
 202 void MEMORY::RefreshScr13()
 203 {
 204         uint8_t X,Y;
 205         uint8_t *T1,*T2;
 206         uint8_t attr;
 207
 208         T1 = VRAM;              /* attribute data */
 209         T2 = VRAM+0x0200;       /* graphic data */
 210         for (Y=0; Y<M1HEIGHT; Y++) {
 211                 SETSCRVARM1(Y); /* Drawing area */
 212                 for (X=0; X<32; X++,T1++,T2++) {
 213                         if (*T1&0x10) { /* 256x192 (SCREEN 4) */
 214                                 attr = *T1&0x02;
 215 W=0;
 216                                 SeqPix21(BPal14[attr|(*T2&0x80)>>7]);
 217                                 SeqPix21(BPal14[attr|(*T2&0x40)>>6]);
 218                                 SeqPix21(BPal14[attr|(*T2&0x20)>>5]);
 219                                 SeqPix21(BPal14[attr|(*T2&0x10)>>4]);
 220                                 SeqPix21(BPal14[attr|(*T2&0x08)>>3]);
 221                                 SeqPix21(BPal14[attr|(*T2&0x04)>>2]);
 222                                 SeqPix21(BPal14[attr|(*T2&0x02)>>1]);
 223                                 SeqPix21(BPal14[attr|(*T2&0x01)   ]);
 224                         } else { /* 128x192 color (SCREEN 3) */
 225                                 attr = (*T1&0x02)<<1;
 226 W=0;
 227                                 SeqPix41(BPal13[attr|(*T2&0xC0)>>6]);
 228                                 SeqPix41(BPal13[attr|(*T2&0x30)>>4]);
 229                                 SeqPix41(BPal13[attr|(*T2&0x0C)>>2]);
 230                                 SeqPix41(BPal13[attr|(*T2&0x03)   ]);
 231                         }
 232                 }
 233                 if (T1 == VRAM+0x200) T1=VRAM;
 234         }
 235 }
 236
 237 // RefreshScr13a: N60-BASIC screen 3,4
 238 void MEMORY::RefreshScr13a() /*  64x 64 color / 128x 64 */
 239 {
 240         uint8_t X,Y;
 241         uint8_t *T1,*T2;
 242         uint8_t attr;
 243         int L;
 244
 245         T1 = VRAM;              /* attribute data */
 246         T2 = VRAM+0x0200;       /* graphic data */
 247         for (Y=0; Y<M1HEIGHT; Y++) {
 248                 SETSCRVARM1(Y); /* Drawing area */
 249                 for (X=0; X<16; X++,T1++,T2++) {
 250                         if (*T1&0x10) { /* 128x 64 */
 251                                 attr = *T1&0x02;
 252 W=0;
 253                                 SeqPix41(BPal14[attr|(*T2&0x80)>>7]);
 254                                 SeqPix41(BPal14[attr|(*T2&0x40)>>6]);
 255                                 SeqPix41(BPal14[attr|(*T2&0x20)>>5]);
 256                                 SeqPix41(BPal14[attr|(*T2&0x10)>>4]);
 257                                 SeqPix41(BPal14[attr|(*T2&0x08)>>3]);
 258                                 SeqPix41(BPal14[attr|(*T2&0x04)>>2]);
 259                                 SeqPix41(BPal14[attr|(*T2&0x02)>>1]);
 260                                 SeqPix41(BPal14[attr|(*T2&0x01)   ]);
 261                         } else { /*  64x 64 color */
 262                                 attr = (*T1&0x02)<<1;
 263 W=0;
 264                                 SeqPix41(L=BPal13[attr|(*T2&0xC0)>>6]);
 265                                 SeqPix41(L);
 266                                 SeqPix41(L=BPal13[attr|(*T2&0x30)>>4]);
 267                                 SeqPix41(L);
 268                                 SeqPix41(L=BPal13[attr|(*T2&0x0C)>>2]);
 269                                 SeqPix41(L);
 270                                 SeqPix41(L=BPal13[attr|(*T2&0x03)   ]);
 271                                 SeqPix41(L);
 272                         }
 273                 }
 274                 if (Y%3 != 2) { T1-=16; T2-=16; }
 275                 else if (T1 == VRAM+0x200) T1=VRAM;
 276         }
 277 }
 278
 279 // RefreshScr13b: N60-BASIC screen 3,4
 280 void MEMORY::RefreshScr13b() /* 128x 64 color */
 281 {
 282         uint8_t X,Y;
 283         uint8_t *T1,*T2;
 284         uint8_t attr;
 285
 286         T1 = VRAM;              /* attribute data */
 287         T2 = VRAM+0x0200;       /* graphic data */
 288         for (Y=0; Y<M1HEIGHT; Y++) {
 289                 SETSCRVARM1(Y); /* Drawing area */
 290                 for (X=0; X<32; X++,T1++,T2++) {
 291 W=0;
 292                         attr = (*T1&0x02)<<1;
 293                         SeqPix41(BPal13[attr|(*T2&0xC0)>>6]);
 294                         SeqPix41(BPal13[attr|(*T2&0x30)>>4]);
 295                         SeqPix41(BPal13[attr|(*T2&0x0C)>>2]);
 296                         SeqPix41(BPal13[attr|(*T2&0x03)   ]);
 297                 }
 298                 if (Y%3 != 2) { T1-=32; T2-=32; }
 299                 else if (T1 == VRAM+0x200) T1=VRAM;
 300         }
 301 }
 302
 303 // RefreshScr13c: N60-BASIC screen 3,4
 304 void MEMORY::RefreshScr13c() /* 128x 96 */
 305 {
 306         uint8_t X,Y;
 307         uint8_t *T1,*T2;
 308         uint8_t attr;
 309
 310         T1 = VRAM;              /* attribute data */
 311         T2 = VRAM+0x0200;       /* graphic data */
 312         for (Y=0; Y<M1HEIGHT; Y++) {
 313                 SETSCRVARM1(Y); /* Drawing area */
 314                 for (X=0; X<16; X++,T1++,T2++) {
 315                         attr = *T1&0x02;
 316 W=0;
 317                         SeqPix41(BPal14[attr|(*T2&0x80)>>7]);
 318                         SeqPix41(BPal14[attr|(*T2&0x40)>>6]);
 319                         SeqPix41(BPal14[attr|(*T2&0x20)>>5]);
 320                         SeqPix41(BPal14[attr|(*T2&0x10)>>4]);
 321                         SeqPix41(BPal14[attr|(*T2&0x08)>>3]);
 322                         SeqPix41(BPal14[attr|(*T2&0x04)>>2]);
 323                         SeqPix41(BPal14[attr|(*T2&0x02)>>1]);
 324                         SeqPix41(BPal14[attr|(*T2&0x01)   ]);
 325                 }
 326                 if (!(Y&1)) { T1-=16; T2-=16; }
 327                 else if (T1 == VRAM+0x200) T1=VRAM;
 328         }
 329 }
 330
 331 // RefreshScr13d: N60-BASIC screen 3,4
 332 void MEMORY::RefreshScr13d() /* 128x 96 color */
 333 {
 334         uint8_t X,Y;
 335         uint8_t *T1,*T2;
 336         uint8_t attr;
 337
 338         T1 = VRAM;              /* attribute data */
 339         T2 = VRAM+0x0200;       /* graphic data */
 340         for (Y=0; Y<M1HEIGHT; Y++) {
 341                 SETSCRVARM1(Y); /* Drawing area */
 342                 for (X=0; X<32; X++,T1++,T2++) {
 343                         attr = (*T1&0x02)<<1;
 344 W=0;
 345                         SeqPix41(BPal13[attr|(*T2&0xC0)>>6]);
 346                         SeqPix41(BPal13[attr|(*T2&0x30)>>4]);
 347                         SeqPix41(BPal13[attr|(*T2&0x0C)>>2]);
 348                         SeqPix41(BPal13[attr|(*T2&0x03)   ]);
 349                 }
 350                 if (!(Y&1)) { T1-=32; T2-=32; }
 351                 else if (T1 == VRAM+0x200) T1=VRAM;
 352         }
 353 }
 354
 355 // RefreshScr13e: N60-BASIC screen 3,4
 356 void MEMORY::RefreshScr13e() /* 128x192 */
 357 {
 358         uint8_t X,Y;
 359         uint8_t *T1,*T2;
 360         uint8_t attr;
 361
 362         T1 = VRAM;              /* attribute data */
 363         T2 = VRAM+0x0200;       /* graphic data */
 364         for (Y=0; Y<M1HEIGHT; Y++) {
 365                 SETSCRVARM1(Y); /* Drawing area */
 366                 for (X=0; X<16; X++,T1++,T2++) {
 367                         attr = *T1&0x02;
 368 W=0;
 369                         SeqPix41(BPal14[attr|(*T2&0x80)>>7]);
 370                         SeqPix41(BPal14[attr|(*T2&0x40)>>6]);
 371                         SeqPix41(BPal14[attr|(*T2&0x20)>>5]);
 372                         SeqPix41(BPal14[attr|(*T2&0x10)>>4]);
 373                         SeqPix41(BPal14[attr|(*T2&0x08)>>3]);
 374                         SeqPix41(BPal14[attr|(*T2&0x04)>>2]);
 375                         SeqPix41(BPal14[attr|(*T2&0x02)>>1]);
 376                         SeqPix41(BPal14[attr|(*T2&0x01)   ]);
 377                 }
 378                 if (T1 == VRAM+0x200) T1=VRAM;
 379         }
 380 }
 381
 382 // RefreshScr51: N60m/66-BASIC screen 1,2
 383 void MEMORY::RefreshScr51()
 384 {
 385         uint8_t X,Y,K;
 386         int FC,BC;
 387         uint8_t *S,*T1,*T2;
 388         uint8_t *G;
 389
 390         G = CGROM;              /* CGROM */
 391         T1 = VRAM;              /* attribute data */
 392         T2 = VRAM+0x0400;       /* ascii/semi-graphic data */
 393         for(Y=0; Y<M5HEIGHT; Y++) {
 394                 SETSCRVARM5(Y); /* Drawing area */
 395                 for(X=0; X<40; X++, T1++, T2++) {
 396                         /* get CGROM address and color */
 397                         S = G+(*T2<<4)+(*T1&0x80?0x1000:0);
 398                         FC = BPal[(*T1)&0x0F]; BC = BPal[(((*T1)&0x70)>>4)|CSS2];
 399                         K=*(S+Y%10);
 400 W=0;
 401                         SeqPix21(K&0x80? FC:BC); SeqPix21(K&0x40? FC:BC);
 402                         SeqPix21(K&0x20? FC:BC); SeqPix21(K&0x10? FC:BC);
 403                         SeqPix21(K&0x08? FC:BC); SeqPix21(K&0x04? FC:BC);
 404                         SeqPix21(K&0x02? FC:BC); SeqPix21(K&0x01? FC:BC);
 405                 }
 406                 if (Y%10!=9) { T1-=40; T2-=40; }
 407         }
 408 }
 409
 410 // RefreshScr53: N60m/66-BASIC screen 3
 411 void MEMORY::RefreshScr53()
 412 {
 413         uint8_t X,Y;
 414         uint8_t *T1,*T2;
 415
 416         T1 = VRAM;              /* attribute data */
 417         T2 = VRAM+0x2000;       /* graphic data */
 418         for(Y=0; Y<M5HEIGHT; Y++) {
 419                 SETSCRVARM5(Y); /* Drawing area */
 420                 for(X=0; X<40; X++) {
 421 W=0;
 422                         SeqPix41(BPal53[CSS3|((*T1)&0xC0)>>6|((*T2)&0xC0)>>4]);
 423                         SeqPix41(BPal53[CSS3|((*T1)&0x30)>>4|((*T2)&0x30)>>2]);
 424                         SeqPix41(BPal53[CSS3|((*T1)&0x0C)>>2|((*T2)&0x0C)   ]);
 425                         SeqPix41(BPal53[CSS3|((*T1)&0x03)   |((*T2)&0x03)<<2]);
 426                         T1++; T2++;
 427                 }
 428         }
 429 }
 430
 431 // RefreshScr54: N60m/66-BASIC screen 4
 432 void MEMORY::RefreshScr54()
 433 {
 434         uint8_t X,Y;
 435         uint8_t *T1,*T2;
 436         uint8_t cssor;
 437
 438         T1 = VRAM;              /* attribute data */
 439         T2 = VRAM+0x2000;       /* graphic data */
 440         /* CSS OR */
 441         cssor = CSS3|CSS2|CSS1;
 442         for(Y=0; Y<M5HEIGHT; Y++) {
 443                 SETSCRVARM5(Y); /* Drawing area */
 444                 for(X=0; X<40; X++) {
 445 W=0;
 446                         SeqPix21(BPal53[cssor|((*T1)&0x80)>>7|((*T2)&0x80)>>6]);
 447                         SeqPix21(BPal53[cssor|((*T1)&0x40)>>6|((*T2)&0x40)>>5]);
 448                         SeqPix21(BPal53[cssor|((*T1)&0x20)>>5|((*T2)&0x20)>>4]);
 449                         SeqPix21(BPal53[cssor|((*T1)&0x10)>>4|((*T2)&0x10)>>3]);
 450                         SeqPix21(BPal53[cssor|((*T1)&0x08)>>3|((*T2)&0x08)>>2]);
 451                         SeqPix21(BPal53[cssor|((*T1)&0x04)>>2|((*T2)&0x04)>>1]);
 452                         SeqPix21(BPal53[cssor|((*T1)&0x02)>>1|((*T2)&0x02)   ]);
 453                         SeqPix21(BPal53[cssor|((*T1)&0x01)   |((*T2)&0x01)<<1]);
 454                         T1++;T2++;
 455                 }
 456         }
 457 }
 458
 459 #if defined(_PC6601SR) || defined(_PC6001MK2SR)
 460 // RefreshScr61: N66-SR BASIC screen 1
 461 void MEMORY::RefreshScr61()
 462 {
 463         uint8_t X,Y,K;
 464         register int FC,BC;
 465         uint8_t *S,*T1,*T2;
 466         uint8_t *G;
 467         int high;
 468         int addr;
 469         int semi_addr;
 470
 471         G = CGROM;              /* CGROM */
 472         T1 = TEXTVRAM+1;                /* attribute data */
 473         T2 = TEXTVRAM;                  /* ascii/semi-graphic data */
 474         high= (rows==20)? 10:8;       /* charactor's high   SR BASIC 2002/2/23 */
 475         addr= (rows==20)? 0x2000: 0x1000; /* CGROM address  SR BASIC 2002/2/23 */
 476         semi_addr= (rows==20)? 0x3000: 0x4000; /* semi address 2003/7/8 */
 477         for(Y=0; Y<M5HEIGHT; Y++) {
 478                 SETSCRVARM5(Y); /* Drawing area */
 479                 for(X=0; X< cols; X++, T1+=2, T2+=2) {
 480 W=0;
 481                         S= G+(*T2<<4)+(*T1&0x80?semi_addr:addr); /*for CGROM6 SR semi graph 2002/2/23*//* 2003/7/8 */
 482                         FC = BPal[ (*T1)&0x0F];                                    /* fast Palet (2002/9/27) */
 483                         BC = BPal[ (((*T1)&0x70)>>4) |CSS2];
 484                         K=*(S+Y%high);                  /* character high 2002/2/23 */
 485                         SeqPix21(K&0x80? FC:BC); SeqPix21(K&0x40? FC:BC);
 486                         SeqPix21(K&0x20? FC:BC); SeqPix21(K&0x10? FC:BC);
 487                         SeqPix21(K&0x08? FC:BC); SeqPix21(K&0x04? FC:BC);
 488                         SeqPix21(K&0x02? FC:BC); SeqPix21(K&0x01? FC:BC);
 489                 }
 490                 if (Y% high!=high-1) { T1-=cols*2; T2-=cols*2; } /* character high  2002/2/23 */
 491         }
 492 }
 493
 494 // RefreshScr62  N66-SR BASIC screen 2
 495 void MEMORY::RefreshScr62()
 496 {
 497         uint8_t X,Y;
 498         uint8_t *T1,*T2;
 499         T1 = VRAM+ 0x1a00;
 500         T2 = VRAM;
 501         for(Y=0; Y<M6HEIGHT; Y++) {
 502                 SETSCRVARM5(Y); /* Drawing area */
 503                 for(X=0; X< 64; X++) {
 504 W=0;
 505                         SeqPix41(BPal53[ CSS3|((*T1)&0x0f) ]);
 506                         SeqPix41(BPal53[ CSS3|((*T1)&0xf0)>>4 ]);
 507                         T1++;
 508                         SeqPix41(BPal53[ CSS3|((*T1)&0x0f) ]);
 509                         SeqPix41(BPal53[ CSS3|((*T1)&0xf0)>>4 ]);
 510                         T1+=3;
 511                 }
 512                 for(X=64 ;X<80 ; X++) {
 513 W=0;
 514                         SeqPix41(BPal53[ CSS3|((*T2)&0x0f) ]);
 515                         SeqPix41(BPal53[ CSS3|((*T2)&0xf0)>>4 ]);
 516                         T2++;
 517                         SeqPix41(BPal53[ CSS3|((*T2)&0x0f) ]);
 518                         SeqPix41(BPal53[ CSS3|((*T2)&0xf0)>>4 ]);
 519                         T2+=3;
 520                 }
 521                 if( (Y & 1)==0)
 522                         { T1-=(254);  T2-=(62);}
 523                 else
 524                         { T1-=2; T2-=2; }
 525         }
 526 }
 527
 528 // RefreshScr63  N66-SR BASIC screen 3
 529 void MEMORY::RefreshScr63()
 530 {
 531         uint8_t X,Y;
 532         uint8_t *T1,*T2;
 533         uint8_t cssor;
 534
 535         T1 = VRAM+ 0x1a00;
 536         T2 = VRAM;
 537         cssor = CSS3|CSS2|CSS1;
 538         for(Y=0; Y<M6HEIGHT; Y++) {
 539                 SETSCRVARM5(Y);         /* Drawing area */
 540                 for(X=0; X< 64; X++) {
 541 W=0;
 542                         SeqPix41(BPal53[cssor|((*T1)&0x80)>>7|((*(T1+1))&0x80)>>6]);
 543                         SeqPix41(BPal53[cssor|((*T1)&0x40)>>6|((*(T1+1))&0x40)>>5]);
 544                         SeqPix41(BPal53[cssor|((*T1)&0x20)>>5|((*(T1+1))&0x20)>>4]);
 545                         SeqPix41(BPal53[cssor|((*T1)&0x10)>>4|((*(T1+1))&0x10)>>3]);
 546                         SeqPix41(BPal53[cssor|((*T1)&0x08)>>3|((*(T1+1))&0x08)>>2]);
 547                         SeqPix41(BPal53[cssor|((*T1)&0x04)>>2|((*(T1+1))&0x04)>>1]);
 548                         SeqPix41(BPal53[cssor|((*T1)&0x02)>>1|((*(T1+1))&0x02)   ]);
 549                         SeqPix41(BPal53[cssor|((*T1)&0x01)   |((*(T1+1))&0x01)<<1]);
 550                         T1+=4;
 551                 }
 552                 for(X=64 ;X<80 ; X++) {
 553 W=0;
 554                         SeqPix41(BPal53[cssor|((*T2)&0x80)>>7|((*(T2+1))&0x80)>>6]);
 555                         SeqPix41(BPal53[cssor|((*T2)&0x40)>>6|((*(T2+1))&0x40)>>5]);
 556                         SeqPix41(BPal53[cssor|((*T2)&0x20)>>5|((*(T2+1))&0x20)>>4]);
 557                         SeqPix41(BPal53[cssor|((*T2)&0x10)>>4|((*(T2+1))&0x10)>>3]);
 558                         SeqPix41(BPal53[cssor|((*T2)&0x08)>>3|((*(T2+1))&0x08)>>2]);
 559                         SeqPix41(BPal53[cssor|((*T2)&0x04)>>2|((*(T2+1))&0x04)>>1]);
 560                         SeqPix41(BPal53[cssor|((*T2)&0x02)>>1|((*(T2+1))&0x02)   ]);
 561                         SeqPix41(BPal53[cssor|((*T2)&0x01)   |((*(T2+1))&0x01)<<1]);
 562                         T2+=4;
 563                 }
 564                 if( (Y & 1)==0)
 565                         { T1-=(254);  T2-=(62);}
 566                 else
 567                         { T1-=2; T2-=2; }
 568         }
 569 }
 570
 571 void MEMORY::do_palet(int dest,int src)
 572 {
 573         int textpalet2[16]={0,4,1,5,2,6,3,7,8,12,9,13,10,14,11,15}; /*  color code-> VRAM code*/
 574         // *************** for RefreshScr 53/54/62/63 ***************************
 575         if ((CSS3 & 0x10) ==0 ) // CSS3 =0
 576         {
 577                 if(dest>=0 && dest<32 && src>=0 && src<32)
 578                 {
 579                         BPal53[dest]= BPal62[src];
 580                 }
 581         } else {                                // CSS3 =1
 582                 if (dest>=0 && dest<32 && src>=0 && src<32)
 583                 {
 584                         int dest1,dest2;
 585                         switch( dest+1)
 586                         {
 587                         case 16: dest1 =13; dest2 = 5; break;
 588                         case 15: dest1 =10; dest2 = 2; break;
 589                         case 14: dest1 =14; dest2 = 6; break;
 590                         case 13: dest1 = 1; dest2 = 9; break;
 591                         }
 592                         BPal53[16+dest1-1]= BPal62[src];
 593                         BPal53[16+dest2-1]= BPal62[src];
 594                 }
 595         }
 596         // ************** for RefreshScr51/61 **************************
 597         if(dest>=0 && dest<16 && src>=0 && src<16)
 598                 BPal[textpalet2[dest]]= BPal61[ textpalet2[src]];
 599 }
 600
 601 void MEMORY::make_semigraph(void)
 602 {
 603         uint8_t *P;
 604         unsigned int i, j, m1, m2;
 605         P = CGROM1+0x1000;
 606         for(i=0; i<64; i++) {
 607                 for(j=0; j<16; j++) {
 608                         switch (j/4) {
 609                         case 0: m1=0x20; m2=0x10; break;
 610                         case 1: m1=0x08; m2=0x04; break;
 611                         case 2: m1=0x02; m2=0x01; break;
 612                         default: m1=m2=0;
 613                         };
 614                         *P++=(i&m1 ? 0xF0: 0) | (i&m2 ? 0x0F: 0);
 615                 }
 616         }
 617         P = CGROM1+0x2000;
 618         for(i=0; i<16; i++) {
 619                 for(j=0; j<16; j++) {
 620                         switch (j/6) {
 621                         case 0: m1=0x08; m2=0x04; break;
 622                         case 1: m1=0x02; m2=0x01; break;
 623                         default: m1=m2=0;
 624                         };
 625                         *P++=(i&m1 ? 0xF0: 0) | (i&m2 ? 0x0F: 0);
 626                 }
 627         }
 628         P = CGROM6+0x4000;
 629         for(i=0; i<256; i++) {
 630                 for(j=0; j<16; j++) {
 631                         switch (j/2) {
 632                         case 0: m1=0x80; m2=0x40; break;
 633                         case 1: m1=0x20; m2=0x10; break;
 634                         case 2: m1=0x08; m2=0x04; break;
 635                         case 3: m1=0x02; m2=0x01; break;
 636                         default: m1=m2=0;
 637                         };
 638                         *P++=(i&m1 ? 0xF0: 0) | (i&m2 ? 0x0F: 0);
 639                 }
 640         }
 641 }
 642
 643 int MEMORY::chk_gvram(uint32_t A,int flag)
 644 {
 645         if (port60[ (A>>13)+flag ]==0x00 && bitmap)     // VRAM \82Ì\90æ\93ª\82©\82Â\81ACRT\82ª BITMAP mode
 646                 return 1;
 647         return 0;
 648 }
 649
 650 uint8_t MEMORY::gvram_read(uint32_t A)
 651 {
 652         uint8_t* adr;
 653         uint8_t  ret;
 654         int x,y,z,w,off;
 655
 656         x = A & 0x1fff;
 657         y = portCF*16+portCE;                 /* y\8dÀ\95W */
 658         if( y >=204) y-=204;                  /* Y\8dÀ\95W 204 \88È\8fã\82¾\82Æ 204 \88ø\82 add 2003/10/22 */
 659         w = (x <256) ? 256: 64;          /* width:0..255 \82È\82ç256 / 256..319\82È\82ç 64\82É\82·\82é*/
 660         off=(x <256) ? 0x1a00: 0x0000;   /* offset: Vram offset address */
 661         x = (x <256) ? x: x-256;              /* x:256..319 \82È\82ç 256\82ð\88ø\82\81@ */
 662         z = ((y & 1 )==1) ? 2: 0;        /* z:Y\8dÀ\95W\82ª\8aï\90\94\82È\82ç\81A2\82ð\91«\82·  */
 663         adr = (VRAM+ (off+ (y>>1)*w + (x&0xffc)+z));
 664         switch(x & 3)
 665         {
 666         case 0: ret=  *(adr);      break;
 667         case 1: ret=  *(adr)>>4;   break;
 668         case 2: ret=  *(adr+1);    break;
 669         case 3: ret=  *(adr+1)>>4; break;
 670         }
 671         return (ret);
 672 }
 673
 674 void MEMORY::gvram_write(uint32_t A, uint32_t V)
 675 {
 676         uint8_t* adr;
 677         int x,y,z,w,off;
 678
 679         x = A & 0x1fff;
 680         y = portCF*16+portCE;           /* y\8dÀ\95W */
 681         if( y >=204) y-=204;                    /* Y\8dÀ\95W 204 \88È\8fã\82¾\82Æ 204 \88ø\82 */
 682         w = (x <256) ? 256: 64;         /* width:0..255 \82È\82ç256 / 256..319\82È\82ç 64\82É\82·\82é*/
 683         off=(x <256) ? 0x1a00: 0x0000;  /* offset: Vram offset address */
 684         x = (x <256) ? x: x-256;            /* x:256..319 \82È\82ç 256\82ð\88ø\82\81@ */
 685         z = ((y & 1 )==1) ? 2: 0;       /* z:Y\8dÀ\95W\82ª\8aï\90\94\82È\82ç\81A2\82ð\91«\82·  */
 686         V&= 0x0f;
 687         adr = VRAM+(off+ (y>>1)*(w) + (x&0xffc)+z);
 688         switch(x & 3)
 689         {
 690         case 0: *(adr)=(*(adr)  &0xf0)  |V;    break;
 691         case 1: *(adr)=(*(adr)  &0x0f)  |V<<4; break;
 692         case 2: *(adr+1)=(*(adr+1)&0xf0)|V;    break;
 693         case 3: *(adr+1)=(*(adr+1)&0x0f)|V<<4; break;
 694         }
 695 }
 696 #endif
 697
 698 }
 699