[BACK]Return to palettes.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / xmil / vram

Diff for /xmil/vram/palettes.c between versions 1.1 and 1.6

version 1.1, 2004/08/01 05:31:31 version 1.6, 2004/08/07 12:10:27
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "scrnmng.h"  #include        "scrnmng.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "x1_io.h"  #include        "iocore.h"
 #include        "x1_crtc.h"  #include        "scrndraw.h"
 #include        "draw.h"  
 #include        "palettes.h"  #include        "palettes.h"
   #include        "makescrn.h"
   
   
         RGB32   x1n_pal32[256];                 // xm_palette          RGB32   x1n_pal32[256];                 // xm_palette
Line 20 Line 20
         int             xm_palettes = 0;          int             xm_palettes = 0;
   
   
   extern  BYTE    dispmode;
   extern  BYTE    pal_disp;
   
   
   static const UINT16 pal4096banktbl[2][64] = {
                           {       0x000, 0x008, 0x080, 0x088, 0x800, 0x808, 0x880, 0x888,
                                   0x004, 0x00C, 0x084, 0x08C, 0x804, 0x80C, 0x884, 0x88C,
                                   0x040, 0x048, 0x0C0, 0x0C8, 0x840, 0x848, 0x8C0, 0x8C8,
                                   0x044, 0x04C, 0x0C4, 0x0CC, 0x844, 0x84C, 0x8C4, 0x8CC,
                                   0x400, 0x408, 0x480, 0x488, 0xC00, 0xC08, 0xC80, 0xC88,
                                   0x404, 0x40C, 0x484, 0x48C, 0xC04, 0xC0C, 0xC84, 0xC8C,
                                   0x440, 0x448, 0x4C0, 0x4C8, 0xC40, 0xC48, 0xCC0, 0xCC8,
                                   0x444, 0x44C, 0x4C4, 0x4CC, 0xC44, 0xC4C, 0xCC4, 0xCCC},
   
                           {       0x000, 0x002, 0x020, 0x022, 0x200, 0x202, 0x220, 0x222,
                                   0x001, 0x003, 0x021, 0x023, 0x201, 0x203, 0x221, 0x223,
                                   0x010, 0x012, 0x030, 0x032, 0x210, 0x212, 0x230, 0x232,
                                   0x011, 0x013, 0x031, 0x033, 0x211, 0x213, 0x231, 0x233,
                                   0x100, 0x102, 0x120, 0x122, 0x300, 0x302, 0x320, 0x322,
                                   0x101, 0x103, 0x121, 0x123, 0x301, 0x303, 0x321, 0x323,
                                   0x110, 0x112, 0x130, 0x132, 0x310, 0x312, 0x330, 0x332,
                                   0x111, 0x113, 0x131, 0x133, 0x311, 0x313, 0x331, 0x333}};
   
 void pals_cnv16pal(RGB16 *dst, const RGB32 *src, UINT pals) {  
   
         while(pals--) {  
                 *dst++ = scrnmng_makepal16(*src++);  
         }  
 }  
   
   
 void pal_makegrad(RGB32 *pal, int pals, DWORD bg, DWORD fg) {  void pal_makegrad(RGB32 *pal, int pals, UINT32 bg, UINT32 fg) {
   
         int             i;          int             i;
   
         if (pals >= 2) {          if (pals >= 2) {
                 pals--;                  pals--;
                 for (i=0; i<=pals; i++) {                  for (i=0; i<=pals; i++) {
                         pal[i].p.b = (BYTE)                          pal[i].p.b = (UINT8)
                                 ((((fg >> 0) & 0x0000ff) * i +                                   ((((fg >> 0) & 0x0000ff) * i + 
                                 ((bg >> 0) & 0x0000ff) * (pals-i)) / pals);                                  ((bg >> 0) & 0x0000ff) * (pals-i)) / pals);
                         pal[i].p.g = (BYTE)                          pal[i].p.g = (UINT8)
                                 ((((fg >> 8) & 0x0000ff) * i +                                   ((((fg >> 8) & 0x0000ff) * i + 
                                 ((bg >> 8) & 0x0000ff) * (pals-i)) / pals);                                  ((bg >> 8) & 0x0000ff) * (pals-i)) / pals);
                         pal[i].p.r = (BYTE)                          pal[i].p.r = (UINT8)
                                 ((((fg >> 16) & 0x0000ff) * i +                                   ((((fg >> 16) & 0x0000ff) * i + 
                                 ((bg >> 16) & 0x0000ff) * (pals-i)) / pals);                                  ((bg >> 16) & 0x0000ff) * (pals-i)) / pals);
                         pal[i].p.e = 0;                          pal[i].p.e = 0;
Line 52  void pal_makegrad(RGB32 *pal, int pals,  Line 67  void pal_makegrad(RGB32 *pal, int pals, 
         }          }
 }  }
   
 // ---------------------------------------------------------------------------  void pals_cnv16pal(RGB16 *dst, const RGB32 *src, UINT pals) {
   
 static  BYTE    blankcol = 0;          while(pals--) {
 static  WORD    halfgrp = 0;                  *dst++ = scrnmng_makepal16(*src++);
 static  WORD    halftxt = 0;          }
   }
   
                 RGB32   TEXTPALS[24];  
                 RGB32   GRPHPALS[2][16];  
                 RGB32   GRPHPALS64[2][64];  
   
   // ----
   
 void textpalette1(BYTE num) {  static  WORD    halfgrp = 0;
   static  WORD    halftxt = 0;
   
         REG8    f;  
         RGB32   c;  
   
         f = 0;  typedef struct {
         c.p.e = 0;          UINT8   blankcol;
         c.p.b = (crtc_TEXTPAL[num] & 0x3) * 0x55;          UINT8   padding[3];
         if (c.p.b < blankcol) {          RGB32   text[24];
                 f |= 1;          RGB32   grph[2][16];
         }          RGB32   grph64[2][64];
         c.p.g = ((crtc_TEXTPAL[num] & 0x30) >> 4) * 0x55;  } PALS;
         if (c.p.g < blankcol) {  
                 f |= 2;  static  PALS    pals;
         }  
         c.p.r = ((crtc_TEXTPAL[num] & 0x0c) >> 2) * 0x55;  
         if (c.p.r < blankcol) {  void pal_settext(REG8 num) {
                 f |= 4;  
           REG8    textpal;
           REG8    black;
           RGB32   rgb;
   
           textpal = crtc_TEXTPAL[num];
           black = 0;
           rgb.p.e = 0;
           rgb.p.b = ((textpal >> 0) & 3) * 0x55;
           if (rgb.p.b < pals.blankcol) {
                   black |= 1;
           }
           rgb.p.g = ((textpal >> 4) & 3) * 0x55;
           if (rgb.p.g < pals.blankcol) {
                   black |= 2;
           }
           rgb.p.r = ((textpal >> 2) & 3) * 0x55;
           if (rgb.p.r < pals.blankcol) {
                   black |= 4;
           }
           if (black == 7) {
                   rgb.p.b = pals.blankcol;
                   rgb.p.g = pals.blankcol;
                   rgb.p.r = pals.blankcol;
         }          }
         if (f == 7) {          x1z_pal32[4096 + num].d = rgb.d;
                 c.d = 0x010101 * blankcol;  
         }  
         x1z_pal32[4096+num].d = c.d;  
 #if defined(SUPPORT_16BPP)  #if defined(SUPPORT_16BPP)
         if (scrnmng_getbpp() == 16) {          if (scrnmng_getbpp() == 16) {
                 x1z_pal16[4096+num] = scrnmng_makepal16(c);                  x1z_pal16[4096 + num] = scrnmng_makepal16(rgb);
         }          }
 #endif  #endif
   
         TEXTPALS[num].d = c.d;          pals.text[num].d = rgb.d;
         TEXTPALS[num].p.e = num + START_EXT;          pals.text[num].p.e = num + START_EXT;
   
         TEXTPALS[num+8].p.b = (halftxt * c.p.b) / 0x00ff;  
         TEXTPALS[num+8].p.g = (halftxt * c.p.g) / 0x00ff;  
         TEXTPALS[num+8].p.r = (halftxt * c.p.r) / 0x00ff;  
         TEXTPALS[num+8].p.e = num + START_EXT + 0x08;  
   
         TEXTPALS[num+16].p.b = (halfgrp * c.p.b) / 0x00ff;          pals.text[num+8].p.b = (halftxt * rgb.p.b) / 255;
         TEXTPALS[num+16].p.g = (halfgrp * c.p.g) / 0x00ff;          pals.text[num+8].p.g = (halftxt * rgb.p.g) / 255;
         TEXTPALS[num+16].p.r = (halfgrp * c.p.r) / 0x00ff;          pals.text[num+8].p.r = (halftxt * rgb.p.r) / 255;
         TEXTPALS[num+16].p.e = num + START_EXT + 0x10;          pals.text[num+8].p.e = num + START_EXT + 0x08;
   
           pals.text[num+16].p.b = (halfgrp * rgb.p.b) / 255;
           pals.text[num+16].p.g = (halfgrp * rgb.p.g) / 255;
           pals.text[num+16].p.r = (halfgrp * rgb.p.r) / 255;
           pals.text[num+16].p.e = num + START_EXT + 0x10;
   
         palandply = 1;          makescrn.palandply = 1;
 }  }
   
   void pal_setgrph(REG8 bank, REG8 num) {
   
 void grphpalette1(BYTE bank, BYTE num) {          UINT    grphpal;
           REG8    black;
         RGB32   c;          RGB32   rgb;
         BYTE    f = 0;  
           grphpal = crtc_GRPHPAL[bank][num];
         c.p.b = (crtc_GRPHPAL[bank][num] & 0xf) * 0x11;          black = 0;
         if (c.p.b < blankcol) {          rgb.p.b = ((grphpal >> 0) & 0x0f) * 0x11;
                 f |= 1;          if (rgb.p.b < pals.blankcol) {
         }                  black |= 1;
         c.p.g = (crtc_GRPHPAL[bank][num] >> 8) * 0x11;          }
         if (c.p.g < blankcol) {          rgb.p.g = ((grphpal >> 8) & 0x0f) * 0x11;
                 f |= 2;          if (rgb.p.g < pals.blankcol) {
         }                  black |= 2;
         c.p.r = ((crtc_GRPHPAL[bank][num] & 0xf0) >> 4) * 0x11;          }
         if (c.p.r < blankcol) {          rgb.p.r = ((grphpal >> 4) & 0x0f) * 0x11;
                 f |= 4;          if (rgb.p.r < pals.blankcol) {
                   black |= 4;
           }
           if (black == 7) {
                   rgb.p.b = pals.blankcol;
                   rgb.p.g = pals.blankcol;
                   rgb.p.r = pals.blankcol;
         }          }
         if (f == 7) {          pals.grph64[bank][num].d = rgb.d;
                 c.d = 0x010101 * blankcol;          pals.grph64[bank][num].p.e = num + START_PAL;
         }  
   
         GRPHPALS64[bank][num].d = c.d;  
         GRPHPALS64[bank][num].p.e = num + START_PAL;  
         if (!(((num >> 3) ^ num) & 7)) {          if (!(((num >> 3) ^ num) & 7)) {
                 num &= 7;                  num &= 7;
                 GRPHPALS[bank][num+0].d = c.d;                  pals.grph[bank][num+0].d = rgb.d;
                 GRPHPALS[bank][num+0].p.e = num + START_EXT + 0x18;                  pals.grph[bank][num+0].p.e = num + START_EXT + 0x18;
                 GRPHPALS[bank][num+8].p.b = (halfgrp * c.p.b) / 0xff;                  pals.grph[bank][num+8].p.b = (halfgrp * rgb.p.b) / 0xff;
                 GRPHPALS[bank][num+8].p.g = (halfgrp * c.p.g) / 0xff;                  pals.grph[bank][num+8].p.g = (halfgrp * rgb.p.g) / 0xff;
                 GRPHPALS[bank][num+8].p.r = (halfgrp * c.p.r) / 0xff;                  pals.grph[bank][num+8].p.r = (halfgrp * rgb.p.r) / 0xff;
                 GRPHPALS[bank][num+8].p.e = num + START_EXT + 0x20;                  pals.grph[bank][num+8].p.e = num + START_EXT + 0x20;
         }          }
         palandply = 1;          makescrn.palandply = 1;
 }  }
   
   void pal_setgrph4096(UINT num) {
   
 void grphpal4096(WORD num) {          UINT    grphpal;
           REG8    black;
           RGB32   rgb;
   
           grphpal = crtc_PAL4096[num];
           black = 0;
           rgb.p.e = 0;
           rgb.p.b = ((grphpal >> 0) & 0x0f) * 0x11;
           if (rgb.p.b < pals.blankcol) {
                   black |= 1;
           }
           rgb.p.g = ((grphpal >> 8) & 0x0f) * 0x11;
           if (rgb.p.g < pals.blankcol) {
                   black |= 2;
           }
           rgb.p.r = ((grphpal >> 4) & 0x0f) * 0x11;
           if (rgb.p.r < pals.blankcol) {
                   black |= 4;
           }
           if (black == 7) {
                   rgb.p.b = pals.blankcol;
                   rgb.p.g = pals.blankcol;
                   rgb.p.r = pals.blankcol;
           }
           x1z_pal32[num].d = rgb.d;
   #if defined(SUPPORT_16BPP)
           if (scrnmng_getbpp() == 16) {
                   x1z_pal16[num] = scrnmng_makepal16(rgb);
           }
   #endif
           makescrn.palandply = 1;
   }
   
         RGB32   c;  
         BYTE    f = 0;  
   
         c.p.e = 0;  // ----
         c.p.b = (crtc_PAL4096[num] & 0xf) * 0x11;  
         if (c.p.b < blankcol) {  static void pal4096to64(RGB32 *pal, const UINT16 *map) {
                 f |= 1;  
         }          UINT    r;
         c.p.g = (crtc_PAL4096[num] >> 8) * 0x11;  
         if (c.p.g < blankcol) {          r = 64;
                 f |= 2;          do {
                   pal->d = x1z_pal32[*map++].d;
                   pal++;
           } while(--r);
   }
   
   void pal_update(void) {
   
           int             i, j;
           BYTE    bit;
           BYTE    c;
           BYTE    skip8 = 0;
           BYTE    skip16 = 0;
   
           if (pal_disp & PAL_4096) {
                   switch(pal_disp & 0xf) {
                           case PAL_4096H:
                                   pal4096to64(x1n_pal32, pal4096banktbl[0]);
                                   xm_palettes = 64;
                                   break;
   
                           case PAL_4096L:
                                   pal4096to64(x1n_pal32, pal4096banktbl[1]);
                                   xm_palettes = 64;
                                   break;
   
                           case (PAL_4096H | PAL_64x2):
                                   pal4096to64(&x1n_pal32[ 0], pal4096banktbl[0]);
                                   pal4096to64(&x1n_pal32[64], pal4096banktbl[1]);
                                   xm_palettes = 128;
                                   break;
   
                           case (PAL_4096L | PAL_64x2):
                                   pal4096to64(&x1n_pal32[ 0], pal4096banktbl[0]);
                                   pal4096to64(&x1n_pal32[64], pal4096banktbl[1]);
                                   xm_palettes = 128;
                                   break;
   
                           default:                                                // fullcolor!
                                   return;
                   }
                   for (i=0; i<8; i++) {
                           x1n_pal32[xm_palettes++].d = pals.text[i].d;
                   }
         }          }
         c.p.r = ((crtc_PAL4096[num] & 0xf0) >> 4) * 0x11;          else if ((dispmode & SCRN64_MASK) == SCRN64_INVALID) {
         if (c.p.r < blankcol) {                  if ((xmilcfg.SKIP_LINE) && (!(crtc.s.SCRN_BITS & SCRN_24KHZ))) {
                 f |= 4;                          skip8 = 8;
                           skip16 = 16;
                   }
                   for (i=0, bit=1; i<8; i++, bit<<=1) {
                           if (!(crtc.s.EXTPALMODE & 0x80)) {
                                   c = 0;
                                   if (crtc.s.PAL_B & bit) {
                                           c |= 1;
                                   }
                                   if (crtc.s.PAL_R & bit) {
                                           c |= 2;
                                   }
                                   if (crtc.s.PAL_G & bit) {
                                           c |= 4;
                                   }
                           }
                           else {
                                   c = i;
                           }
                           x1n_pal32[i].d = pals.grph[pal_disp][c].d;
                           x1n_pal32[i+64].d = x1n_pal32[i+128].d
                                                                                   = pals.grph[pal_disp][c+skip8].d;
                           if (crtc.s.PLY & bit) {
                                   for (j=i+8; j<64; j+=8) {
                                           x1n_pal32[j].d = x1n_pal32[i].d;
                                           x1n_pal32[j+64].d = x1n_pal32[j+128].d
                                                                                                           = x1n_pal32[i+64].d;
                                   }
                           }
                           else {
                                   BYTE cnt = (crtc.s.BLACKPAL & 15) - 8;
                                   for (j=i+8; j<64; j+=8) {
                                           if (--cnt) {
                                                   c = crtc.s.TEXT_PAL[j>>3];
                                           }
                                           else {
                                                   c = 0;
                                           }
                                           x1n_pal32[j].d = pals.text[c].d;
                                           x1n_pal32[j+64].d = pals.text[c+skip8].d;
                                           x1n_pal32[j+128].d = pals.text[c+skip16].d;
                                   }
                           }
                   }
                   for (i=0; i<24; i++) {
                           x1n_pal32[i+192].d = pals.text[i].d;
                   }
                   for (i=0; i<16; i++) {
                           x1n_pal32[i+192+24].d = pals.grph[pal_disp][i].d;
                   }
                   xm_palettes = 64+64+64+24+16;
         }          }
         if (f == 7) {          else {
                 c.d = 0x010101 * blankcol;                  for (i=0; i<64; i++) {
                           x1n_pal32[i].d = pals.grph64[pal_disp][i].d;
                   }
                   for (i=0; i<8; i++) {
                           x1n_pal32[i+64].d = pals.text[i].d;
                   }
                   xm_palettes = 64+8;
         }          }
         x1z_pal32[num].d = c.d;  
 #if defined(SUPPORT_16BPP)  #if defined(SUPPORT_16BPP)
         if (scrnmng_getbpp() == 16) {          if (scrnmng_getbpp() == 16) {
                 x1z_pal16[num] = scrnmng_makepal16(c);                  pals_cnv16pal(x1n_pal16, x1n_pal32, xm_palettes);
         }          }
 #endif  #endif
         palandply = 1;          scrndraw_changepalette();
 }  }
   
   
   // ----
   
 void reflesh_palette(void) {  void pal_reset(void) {
   
         BYTE    i, j;          REG8    i;
         WORD    k;          REG8    j;
           UINT    k;
   
         blankcol = xmilcfg.BLKLIGHT;          pals.blankcol = xmilcfg.BLKLIGHT;
         if ((!xmilcfg.SKIP_LINE) || (crtc.SCRN_BITS & SCRN_24KHZ)) {          if ((!xmilcfg.SKIP_LINE) || (crtc.s.SCRN_BITS & SCRN_24KHZ)) {
                 blankcol >>= 1;                  pals.blankcol >>= 1;
         }          }
         halfgrp = xmilcfg.LINEDEPTH;          halfgrp = xmilcfg.LINEDEPTH;
         switch(xmilcfg.TEXT400L) {          switch(xmilcfg.TEXT400L) {
                 case 0:                  case 0:
                         halftxt = xmilcfg.LINEDEPTH;                          halftxt = xmilcfg.LINEDEPTH;
                         break;                          break;
   
                 case 1:                  case 1:
                         halftxt = 0xff;                          halftxt = 0xff;
                         break;                          break;
   
                 default:                  default:
                         halftxt = xmilcfg.LINETEXT;                          halftxt = xmilcfg.LINETEXT;
                         break;                          break;
         }          }
   
         for (i=0; i<8; i++) {          for (i=0; i<8; i++) {
                 textpalette1(i);                  pal_settext(i);
         }          }
         for (j=0; j<2; j++) {          for (i=0; i<2; i++) {
                 for (i=0; i<64; i++) {                  for (j=0; j<64; j++) {
                         grphpalette1(j, i);                          pal_setgrph(i, j);
                 }                  }
         }          }
         for (k=0; k<4096; k++) {          for (k=0; k<4096; k++) {
                 grphpal4096(k);                  pal_setgrph4096(k);
         }          }
 }  }
   
Removed from v.1.1  
changed lines
  Added in v.1.6

RetroPC.NET-CVS <cvs@retropc.net>