[BACK]Return to cmndraw.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / generic

Diff for /np2/generic/cmndraw.c between versions 1.2 and 1.9

version 1.2, 2004/03/09 23:39:19 version 1.9, 2004/04/08 13:51:52
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #include        "bmpdata.h"
 #include        "scrnmng.h"  #include        "scrnmng.h"
   #include        "cpucore.h"
   #include        "font.h"
 #include        "cmndraw.h"  #include        "cmndraw.h"
   #include        "minifont.res"
   
   
 void cmndraw_getpals(CMNPALFN *fn, CMNPAL *pal, UINT pals) {  void cmndraw_getpals(CMNPALFN *fn, CMNPALS *pal, UINT pals) {
   
         UINT    i;          UINT    i;
   
Line 44  void cmndraw_makegrad(RGB32 *pal, int pa Line 48  void cmndraw_makegrad(RGB32 *pal, int pa
         pal[i].d = fg.d;          pal[i].d = fg.d;
 }  }
   
 #if defined(SUPPORT_8BPP)  
 void cmndraw8_fill(const CMNVRAM *vram, int x, int y,  
                                                                                 int cx, int cy, BYTE fg) {  
   
         BYTE    *p;  
         int             dalign;  
         int             r;  
   
         p = vram->ptr + (x * vram->xalign) + (y * vram->yalign);  
         dalign = vram->yalign - (vram->xalign * cx);  
         do {  
                 r = cx;  
                 do {  
                         *p = fg;  
                         p += vram->xalign;  
                 } while(--r);  
                 p += dalign;  
         } while(--cy);  
 }  
   
 void cmndraw8_setfg(const CMNVRAM *vram, const BYTE *src,  
                                                                                 int x, int y, BYTE fg) {  
   
 const BYTE      *p;  // ----
         BYTE    *q;  
         BYTE    cy;  
         int             dalign;  
         BYTE    c;  
         BYTE    bit;  
         BYTE    cx;  
   
         p = src + 2;  
         q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);  
         dalign = vram->yalign - (vram->xalign * src[0]);  
         cy = src[1];  
         do {  
                 cx = src[0];  
                 bit = 0;  
                 c = 0;  
                 do {  
                         if (!bit) {  
                                 bit = 0x80;  
                                 c = *p++;  
                         }  
                         if (c & bit) {  
                                 *q = fg;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;  
         } while(--cy);  
 }  
   
 void cmndraw8_setpat(const CMNVRAM *vram, const BYTE *src,  
                                                                                 int x, int y, BYTE bg, BYTE fg) {  
   
 const BYTE      *p;  
         BYTE    *q;  
         BYTE    cy;  
         int             dalign;  
         BYTE    c;  
         BYTE    bit;  
         BYTE    cx;  
   
         p = src + 2;  
         q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);  
         dalign = vram->yalign - (vram->xalign * src[0]);  
         cy = src[1];  
         do {  
                 cx = src[0];  
                 bit = 0;  
                 c = 0;  
                 do {  
                         if (!bit) {  
                                 bit = 0x80;  
                                 c = *p++;  
                         }  
                         if (c & bit) {  
                                 *q = fg;  
                         }  
                         else {  
                                 *q = bg;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;  
         } while(--cy);  
 }  
 #endif  
   
 #if defined(SUPPORT_16BPP)  void cmndraw_fill(const CMNVRAM *vram, int x, int y,
 void cmndraw16_fill(const CMNVRAM *vram, int x, int y,                                                                                  int cx, int cy, CMNPAL fg) {
                                                                                 int cx, int cy, UINT16 fg) {  
   
         BYTE    *p;          BYTE    *p;
         int             dalign;          int             dalign;
         int             r;          int             r;
   
           if (vram == NULL) {
                   return;
           }
         p = vram->ptr + (x * vram->xalign) + (y * vram->yalign);          p = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
         dalign = vram->yalign - (vram->xalign * cx);          dalign = vram->yalign - (vram->xalign * cx);
         do {          switch(vram->bpp) {
                 r = cx;  #if defined(SUPPORT_8BPP)
                 do {                  case 8:
                         *(UINT16 *)p = fg;                          do {
                         p += vram->xalign;                                  r = cx;
                 } while(--r);                                  do {
                 p += dalign;                                          *p = fg.pal8;
         } while(--cy);                                          p += vram->xalign;
                                   } while(--r);
                                   p += dalign;
                           } while(--cy);
                           break;
   #endif
   #if defined(SUPPORT_16BPP)
                   case 16:
                           do {
                                   r = cx;
                                   do {
                                           *(UINT16 *)p = fg.pal16;
                                           p += vram->xalign;
                                   } while(--r);
                                   p += dalign;
                           } while(--cy);
                           break;
   #endif
   #if defined(SUPPORT_24BPP)
                   case 24:
                           do {
                                   r = cx;
                                   do {
                                           p[RGB24_R] = fg.pal32.p.r;
                                           p[RGB24_G] = fg.pal32.p.g;
                                           p[RGB24_B] = fg.pal32.p.b;
                                           p += vram->xalign;
                                   } while(--r);
                                   p += dalign;
                           } while(--cy);
                           break;
   #endif
   #if defined(SUPPORT_32BPP)
                   case 32:
                           do {
                                   r = cx;
                                   do {
                                           *(UINT32 *)p = fg.pal32.d;
                                           p += vram->xalign;
                                   } while(--r);
                                   p += dalign;
                           } while(--cy);
                           break;
   #endif
           }
 }  }
   
 void cmndraw16_setfg(const CMNVRAM *vram, const BYTE *src,  void cmndraw_setfg(const CMNVRAM *vram, const BYTE *src,
                                                                                 int x, int y, UINT16 fg) {                                                                                  int x, int y, CMNPAL fg) {
   
 const BYTE      *p;  const BYTE      *p;
         BYTE    *q;          BYTE    *q;
Line 167  const BYTE *p; Line 128  const BYTE *p;
         BYTE    bit;          BYTE    bit;
         BYTE    cx;          BYTE    cx;
   
           if (vram == NULL) {
                   return;
           }
         p = src + 2;          p = src + 2;
         q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);          q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
         dalign = vram->yalign - (vram->xalign * src[0]);          dalign = vram->yalign - (vram->xalign * src[0]);
Line 175  const BYTE *p; Line 139  const BYTE *p;
                 cx = src[0];                  cx = src[0];
                 bit = 0;                  bit = 0;
                 c = 0;                  c = 0;
                 do {                  switch(vram->bpp) {
                         if (!bit) {  #if defined(SUPPORT_8BPP)
                                 bit = 0x80;                          case 8:
                                 c = *p++;                                  do {
                         }                                          if (!bit) {
                         if (c & bit) {                                                  bit = 0x80;
                                 *(UINT16 *)q = fg;                                                  c = *p++;
                         }                                          }
                         bit >>= 1;                                          if (c & bit) {
                         q += vram->xalign;                                                  *q = fg.pal8;
                 } while(--cx);                                          }
                                           bit >>= 1;
                                           q += vram->xalign;
                                   } while(--cx);
                                   break;
   #endif
   #if defined(SUPPORT_16BPP)
                           case 16:
                                   do {
                                           if (!bit) {
                                                   bit = 0x80;
                                                   c = *p++;
                                           }
                                           if (c & bit) {
                                                   *(UINT16 *)q = fg.pal16;
                                           }
                                           bit >>= 1;
                                           q += vram->xalign;
                                   } while(--cx);
                                   break;
   #endif
   #if defined(SUPPORT_24BPP)
                           case 24:
                                   do {
                                           if (!bit) {
                                                   bit = 0x80;
                                                   c = *p++;
                                           }
                                           if (c & bit) {
                                                   q[RGB24_R] = fg.pal32.p.r;
                                                   q[RGB24_G] = fg.pal32.p.g;
                                                   q[RGB24_B] = fg.pal32.p.b;
                                           }
                                           bit >>= 1;
                                           q += vram->xalign;
                                   } while(--cx);
                                   break;
   #endif
   #if defined(SUPPORT_32BPP)
                           case 32:
                                   do {
                                           if (!bit) {
                                                   bit = 0x80;
                                                   c = *p++;
                                           }
                                           if (c & bit) {
                                                   *(UINT32 *)q = fg.pal32.d;
                                           }
                                           bit >>= 1;
                                           q += vram->xalign;
                                   } while(--cx);
                                   break;
   #endif
                   }
                 q += dalign;                  q += dalign;
         } while(--cy);          } while(--cy);
 }  }
   
 void cmndraw16_setpat(const CMNVRAM *vram, const BYTE *src,  void cmndraw_setpat(const CMNVRAM *vram, const BYTE *src,
                                                                                 int x, int y, UINT16 bg, UINT16 fg) {                                                                                  int x, int y, CMNPAL bg, CMNPAL fg) {
   
 const BYTE      *p;  const BYTE      *p;
         BYTE    *q;          BYTE    *q;
Line 209  const BYTE *p; Line 226  const BYTE *p;
                 cx = src[0];                  cx = src[0];
                 bit = 0;                  bit = 0;
                 c = 0;                  c = 0;
                 do {                  switch(vram->bpp) {
                         if (!bit) {  #if defined(SUPPORT_8BPP)
                                 bit = 0x80;                          case 8:
                                 c = *p++;                                  do {
                         }                                          if (!bit) {
                         if (c & bit) {                                                  bit = 0x80;
                                 *(UINT16 *)q = fg;                                                  c = *p++;
                         }                                          }
                         else {                                          if (c & bit) {
                                 *(UINT16 *)q = bg;                                                  *q = fg.pal8;
                         }                                          }
                         bit >>= 1;                                          else {
                         q += vram->xalign;                                                  *q = bg.pal8;
                 } while(--cx);                                          }
                 q += dalign;                                          bit >>= 1;
         } while(--cy);                                          q += vram->xalign;
 }                                  } while(--cx);
                                   break;
   #endif
   #if defined(SUPPORT_16BPP)
                           case 16:
                                   do {
                                           if (!bit) {
                                                   bit = 0x80;
                                                   c = *p++;
                                           }
                                           if (c & bit) {
                                                   *(UINT16 *)q = fg.pal16;
                                           }
                                           else {
                                                   *(UINT16 *)q = bg.pal16;
                                           }
                                           bit >>= 1;
                                           q += vram->xalign;
                                   } while(--cx);
                                   break;
 #endif  #endif
   
 #if defined(SUPPORT_24BPP)  #if defined(SUPPORT_24BPP)
 void cmndraw24_fill(const CMNVRAM *vram, int x, int y,                          case 24:
                                                                                 int cx, int cy, RGB32 fg) {                                  do {
                                           if (!bit) {
         BYTE    *p;                                                  bit = 0x80;
         int             dalign;                                                  c = *p++;
         int             r;                                          }
                                           if (c & bit) {
         p = vram->ptr + (x * vram->xalign) + (y * vram->yalign);                                                  q[RGB24_R] = fg.pal32.p.r;
         dalign = vram->yalign - (vram->xalign * cx);                                                  q[RGB24_G] = fg.pal32.p.g;
         do {                                                  q[RGB24_B] = fg.pal32.p.b;
                 r = cx;                                          }
                 do {                                          else {
                         p[RGB24_R] = fg.p.r;                                                  q[RGB24_R] = bg.pal32.p.r;
                         p[RGB24_G] = fg.p.g;                                                  q[RGB24_G] = bg.pal32.p.g;
                         p[RGB24_B] = fg.p.b;                                                  q[RGB24_B] = bg.pal32.p.b;
                         p += vram->xalign;                                          }
                 } while(--r);                                          bit >>= 1;
                 p += dalign;                                          q += vram->xalign;
         } while(--cy);                                  } while(--cx);
 }                                  break;
   #endif
 void cmndraw24_setfg(const CMNVRAM *vram, const BYTE *src,  #if defined(SUPPORT_32BPP)
                                                                                 int x, int y, RGB32 fg) {                          case 32:
                                   do {
 const BYTE      *p;                                          if (!bit) {
         BYTE    *q;                                                  bit = 0x80;
         BYTE    cy;                                                  c = *p++;
         int             dalign;                                          }
         BYTE    c;                                          if (c & bit) {
         BYTE    bit;                                                  *(UINT32 *)q = fg.pal32.d;
         BYTE    cx;                                          }
                                           else {
         p = src + 2;                                                  *(UINT32 *)q = bg.pal32.d;
         q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);                                          }
         dalign = vram->yalign - (vram->xalign * src[0]);                                          bit >>= 1;
         cy = src[1];                                          q += vram->xalign;
         do {                                  } while(--cx);
                 cx = src[0];                                  break;
                 bit = 0;  #endif
                 c = 0;                  }
                 do {  
                         if (!bit) {  
                                 bit = 0x80;  
                                 c = *p++;  
                         }  
                         if (c & bit) {  
                                 q[RGB24_R] = fg.p.r;  
                                 q[RGB24_G] = fg.p.g;  
                                 q[RGB24_B] = fg.p.b;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;                  q += dalign;
         } while(--cy);          } while(--cy);
 }  }
   
 void cmndraw24_setpat(const CMNVRAM *vram, const BYTE *src,  
                                                                                 int x, int y, RGB32 bg, RGB32 fg) {  
   
 const BYTE      *p;  // ----
         BYTE    *q;  
         BYTE    cy;  
         int             dalign;  
         BYTE    c;  
         BYTE    bit;  
         BYTE    cx;  
   
         p = src + 2;  
         q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);  
         dalign = vram->yalign - (vram->xalign * src[0]);  
         cy = src[1];  
         do {  
                 cx = src[0];  
                 bit = 0;  
                 c = 0;  
                 do {  
                         if (!bit) {  
                                 bit = 0x80;  
                                 c = *p++;  
                         }  
                         if (c & bit) {  
                                 q[RGB24_R] = fg.p.r;  
                                 q[RGB24_G] = fg.p.g;  
                                 q[RGB24_B] = fg.p.b;  
                         }  
                         else {  
                                 q[RGB24_R] = bg.p.r;  
                                 q[RGB24_G] = bg.p.g;  
                                 q[RGB24_B] = bg.p.b;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;  
         } while(--cy);  
 }  
 #endif  
   
 #if defined(SUPPORT_32BPP)  void cmddraw_text8(CMNVRAM *vram, int x, int y, const char *str, CMNPAL fg) {
 void cmndraw32_fill(const CMNVRAM *vram, int x, int y,  
                                                                                 int cx, int cy, RGB32 fg) {  
   
         BYTE    *p;          UINT    s;
         int             dalign;  const BYTE      *ptr;
         int             r;          BYTE    src[10];
   
         p = vram->ptr + (x * vram->xalign) + (y * vram->yalign);          if ((vram == NULL) || (str == NULL)) {
         dalign = vram->yalign - (vram->xalign * cx);                  return;
         do {          }
                 r = cx;          src[0] = 0;
                 do {          src[1] = 7;
                         *(UINT32 *)p = fg.d;          while(*str) {
                         p += vram->xalign;                  s = (UINT)(*str++);
                 } while(--r);                  ptr = NULL;
                 p += dalign;                  if ((s >= 0x20) && (s < 0x80)) {
         } while(--cy);                          ptr = minifont + (s - 0x20) * 8;
                   }
                   else if ((s >= 0xa0) && (s < 0xe0)) {
                           ptr = minifont + (s - 0xa0 + 0x60) * 8;
                   }
                   if (ptr == NULL) {
                           continue;
                   }
                   src[0] = ptr[0];
                   CopyMemory(src + 2, ptr + 1, 7);
                   cmndraw_setfg(vram, src, x, y, fg);
                   x += ptr[0] + 1;
           }
 }  }
   
 void cmndraw32_setfg(const CMNVRAM *vram, const BYTE *src,  
                                                                                 int x, int y, RGB32 fg) {  
   
 const BYTE      *p;  // ---- bmp
         BYTE    *q;  
         BYTE    cy;  
         int             dalign;  
         BYTE    c;  
         BYTE    bit;  
         BYTE    cx;  
   
         p = src + 2;  BOOL cmndraw_bmp4inf(CMNBMP *bmp, const void *ptr) {
         q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);  
         dalign = vram->yalign - (vram->xalign * src[0]);  
         cy = src[1];  
         do {  
                 cx = src[0];  
                 bit = 0;  
                 c = 0;  
                 do {  
                         if (!bit) {  
                                 bit = 0x80;  
                                 c = *p++;  
                         }  
                         if (c & bit) {  
                                 *(UINT32 *)q = fg.d;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;  
         } while(--cy);  
 }  
   
 void cmndraw32_setpat(const CMNVRAM *vram, const BYTE *src,  const BMPFILE   *bf;
                                                                                 int x, int y, RGB32 bg, RGB32 fg) {  const BMPINFO   *bi;
   const BYTE              *palptr;
           BMPDATA         inf;
           BYTE            *src;
           int                     bmpalign;
           UINT            pals;
           UINT            c;
   
 const BYTE      *p;          if ((bmp == NULL) || (ptr == NULL)) {
         BYTE    *q;                  return(FAILURE);
         BYTE    cy;          }
         int             dalign;          bf = (BMPFILE *)ptr;
         BYTE    c;          bi = (BMPINFO *)(bf + 1);
         BYTE    bit;          palptr = (BYTE *)(bi + 1);
         BYTE    cx;          if (((bf->bfType[0] != 'B') && (bf->bfType[1] != 'M')) ||
                   (bmpdata_getinfo(bi, &inf) != SUCCESS) || (inf.bpp != 4)) {
                   return(FAILURE);
           }
           pals = min(LOADINTELDWORD(bi->biClrUsed), 16);
   
         p = src + 2;          src = (BYTE *)bf + (LOADINTELDWORD(bf->bfOffBits));
         q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);          bmpalign = bmpdata_getalign(bi);
         dalign = vram->yalign - (vram->xalign * src[0]);          if (inf.height > 0) {
         cy = src[1];                  bmp->ptr = src + ((inf.height - 1) * bmpalign);
         do {                  bmp->width = inf.width;
                 cx = src[0];                  bmp->height = inf.height;
                 bit = 0;                  bmp->align = bmpalign * -1;
                 c = 0;          }
                 do {          else {
                         if (!bit) {                  bmp->ptr = src;
                                 bit = 0x80;                  bmp->width = inf.width;
                                 c = *p++;                  bmp->height = inf.height * -1;
                         }                  bmp->align = bmpalign;
                         if (c & bit) {          }
                                 *(UINT32 *)q = fg.d;          bmp->pals = pals;
                         }          ZeroMemory(bmp->paltbl, sizeof(bmp->paltbl));
                         else {          for (c=0; c<pals; c++) {
                                 *(UINT32 *)q = bg.d;                  bmp->paltbl[c].p.b = palptr[c*4+0];
                         }                  bmp->paltbl[c].p.g = palptr[c*4+1];
                         bit >>= 1;                  bmp->paltbl[c].p.r = palptr[c*4+2];
                         q += vram->xalign;          }
                 } while(--cx);          return(SUCCESS);
                 q += dalign;  
         } while(--cy);  
 }  }
 #endif  
   
   void cmndraw_bmp16(CMNVRAM *vram, const void *ptr, CMNPALCNV cnv, UINT flag) {
   
           CMNBMP  bmp;
           CMNPAL  pal[16];
           BYTE    *src;
           BYTE    *dst;
           int             yalign;
           int             x;
           int             y;
           UINT    c;
   
           if ((vram == NULL) || (cnv == NULL) ||
                   (cmndraw_bmp4inf(&bmp, ptr) != SUCCESS) ||
                   (vram->width < bmp.width) || (vram->height < bmp.height)) {
                   return;
           }
           (*cnv)(pal, bmp.paltbl, bmp.pals, vram->bpp);
           src = bmp.ptr;
           dst = vram->ptr;
           switch(flag & 0x03) {
                   case CMNBMP_CENTER:
                           dst += ((vram->width - bmp.width) / 2) * vram->xalign;
                           break;
   
 // ----                  case CMNBMP_RIGHT:
                           dst += (vram->width - bmp.width) * vram->xalign;
 void cmddraw_fill(CMNVRAM *vram, int x, int y, int cx, int cy, CMNPAL *pal) {                          break;
           }
           switch(flag & 0x0c) {
                   case CMNBMP_MIDDLE:
                           dst += ((vram->height - bmp.height) / 2) * vram->yalign;
                           break;
   
         if ((vram == NULL) || (pal == NULL)) {                  case CMNBMP_BOTTOM:
                 return;                          dst += (vram->height - bmp.height) * vram->yalign;
                           break;
         }          }
         switch(vram->bpp) {          yalign = vram->yalign - (bmp.width * vram->xalign);
           for (y=0; y<bmp.height; y++) {
                   switch(vram->bpp) {
 #if defined(SUPPORT_8BPP)  #if defined(SUPPORT_8BPP)
                 case 8:                          case 8:
                         cmndraw8_fill(vram, x, y, cx, cy, pal->pal8);                                  for (x=0; x<bmp.width; x++) {
                         break;                                          if (!(x & 1)) {
                                                   c = src[x >> 1] >> 4;
                                           }
                                           else {
                                                   c = src[x >> 1] & 15;
                                           }
                                           *dst = pal[c].pal8;
                                           dst += vram->xalign;
                                   }
                                   break;
 #endif  #endif
 #if defined(SUPPORT_16BPP)  #if defined(SUPPORT_16BPP)
                 case 16:                          case 16:
                         cmndraw16_fill(vram, x, y, cx, cy, pal->pal16);                                  for (x=0; x<bmp.width; x++) {
                         break;                                          if (!(x & 1)) {
                                                   c = src[x >> 1] >> 4;
                                           }
                                           else {
                                                   c = src[x >> 1] & 15;
                                           }
                                           *(UINT16 *)dst = pal[c].pal16;
                                           dst += vram->xalign;
                                   }
                                   break;
 #endif  #endif
 #if defined(SUPPORT_24BPP)  #if defined(SUPPORT_24BPP)
                 case 24:                          case 24:
                         cmndraw24_fill(vram, x, y, cx, cy, pal->pal32);                                  for (x=0; x<bmp.width; x++) {
                         break;                                          if (!(x & 1)) {
                                                   c = src[x >> 1] >> 4;
                                           }
                                           else {
                                                   c = src[x >> 1] & 15;
                                           }
                                           dst[RGB24_R] = pal[c].pal32.p.r;
                                           dst[RGB24_G] = pal[c].pal32.p.g;
                                           dst[RGB24_B] = pal[c].pal32.p.b;
                                           dst += vram->xalign;
                                   }
                                   break;
 #endif  #endif
 #if defined(SUPPORT_32BPP)  #if defined(SUPPORT_32BPP)
                 case 32:                          case 32:
                         cmndraw32_fill(vram, x, y, cx, cy, pal->pal32);                                  for (x=0; x<bmp.width; x++) {
                         break;                                          if (!(x & 1)) {
                                                   c = src[x >> 1] >> 4;
                                           }
                                           else {
                                                   c = src[x >> 1] & 15;
                                           }
                                           *(UINT32 *)dst = pal[c].pal32.d;
                                           dst += vram->xalign;
                                   }
                                   break;
 #endif  #endif
                   }
                   src += bmp.align;
                   dst += yalign;
         }          }
 }  }
   
Removed from v.1.2  
changed lines
  Added in v.1.9

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