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

Diff for /np2/generic/cmndraw.c between versions 1.7 and 1.10

version 1.7, 2004/04/05 09:45:06 version 1.10, 2004/04/09 10:52:20
Line 7 Line 7
 #include        "minifont.res"  #include        "minifont.res"
   
   
 void cmndraw_getpals(CMNPALFN *fn, CMNPALS *pal, UINT pals) {  
   
         UINT    i;  
   
         if (fn == NULL) {  
                 return;  
         }  
         if (fn->get8) {  
                 for (i=0; i<pals; i++) {  
                         pal[i].pal8 = (*fn->get8)(fn, i);  
                 }  
         }  
         if (fn->get32) {  
                 for (i=0; i<pals; i++) {  
                         pal[i].pal32.d = (*fn->get32)(fn, i);  
                 }  
                 if (fn->cnv16) {  
                         for (i=0; i<pals; i++) {  
                                 pal[i].pal16 = (*fn->cnv16)(fn, pal[i].pal32);  
                         }  
                 }  
         }  
 }  
   
 void cmndraw_makegrad(RGB32 *pal, int pals, RGB32 bg, RGB32 fg) {  void cmndraw_makegrad(RGB32 *pal, int pals, RGB32 bg, RGB32 fg) {
   
         int             i;          int             i;
Line 48  void cmndraw_makegrad(RGB32 *pal, int pa Line 24  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 cmndraw16_fill(const CMNVRAM *vram, int x, int y,  
                                                                                 int cx, int cy, UINT16 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 {  
                         *(UINT16 *)p = fg;  
                         p += vram->xalign;  
                 } while(--r);  
                 p += dalign;  
         } while(--cy);  
 }  
   
 void cmndraw16_setfg(const CMNVRAM *vram, const BYTE *src,  
                                                                                 int x, int y, UINT16 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) {  
                                 *(UINT16 *)q = fg;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;  
         } while(--cy);  
 }  
   
 void cmndraw16_setpat(const CMNVRAM *vram, const BYTE *src,  
                                                                                 int x, int y, UINT16 bg, UINT16 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) {  
                                 *(UINT16 *)q = fg;  
                         }  
                         else {  
                                 *(UINT16 *)q = bg;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;  
         } while(--cy);  
 }  
 #endif  
   
 #if defined(SUPPORT_24BPP)  
 void cmndraw24_fill(const CMNVRAM *vram, int x, int y,  
                                                                                 int cx, int cy, RGB32 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[RGB24_R] = fg.p.r;  
                         p[RGB24_G] = fg.p.g;  
                         p[RGB24_B] = fg.p.b;  
                         p += vram->xalign;  
                 } while(--r);  
                 p += dalign;  
         } while(--cy);  
 }  
   
 void cmndraw24_setfg(const CMNVRAM *vram, const BYTE *src,  
                                                                                 int x, int y, 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;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;  
         } 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 cmndraw32_fill(const CMNVRAM *vram, int x, int y,  
                                                                                 int cx, int cy, RGB32 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 {  
                         *(UINT32 *)p = fg.d;  
                         p += vram->xalign;  
                 } while(--r);  
                 p += dalign;  
         } while(--cy);  
 }  
   
 void cmndraw32_setfg(const CMNVRAM *vram, const BYTE *src,  
                                                                                 int x, int y, 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) {  
                                 *(UINT32 *)q = fg.d;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;  
         } while(--cy);  
 }  
   
 void cmndraw32_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) {  
                                 *(UINT32 *)q = fg.d;  
                         }  
                         else {  
                                 *(UINT32 *)q = bg.d;  
                         }  
                         bit >>= 1;  
                         q += vram->xalign;  
                 } while(--cx);  
                 q += dalign;  
         } while(--cy);  
 }  
 #endif  
   
   
   
 // ----  // ----
   
 void cmddraw_fill(CMNVRAM *vram, int x, int y, int cx, int cy, CMNPALS *pal) {  void cmndraw_fill(const CMNVRAM *vram, int x, int y,
   
         if ((vram == NULL) || (pal == NULL)) {  
                 return;  
         }  
         switch(vram->bpp) {  
 #if defined(SUPPORT_8BPP)  
                 case 8:  
                         cmndraw8_fill(vram, x, y, cx, cy, pal->pal8);  
                         break;  
 #endif  
 #if defined(SUPPORT_16BPP)  
                 case 16:  
                         cmndraw16_fill(vram, x, y, cx, cy, pal->pal16);  
                         break;  
 #endif  
 #if defined(SUPPORT_24BPP)  
                 case 24:  
                         cmndraw24_fill(vram, x, y, cx, cy, pal->pal32);  
                         break;  
 #endif  
 #if defined(SUPPORT_32BPP)  
                 case 32:  
                         cmndraw32_fill(vram, x, y, cx, cy, pal->pal32);  
                         break;  
 #endif  
         }  
 }  
   
   
 // ---- new  
   
 void cmndraw_fill2(const CMNVRAM *vram, int x, int y,  
                                                                                 int cx, int cy, CMNPAL fg) {                                                                                  int cx, int cy, CMNPAL fg) {
   
         BYTE    *p;          BYTE    *p;
Line 502  void cmndraw_fill2(const CMNVRAM *vram,  Line 69  void cmndraw_fill2(const CMNVRAM *vram, 
                         do {                          do {
                                 r = cx;                                  r = cx;
                                 do {                                  do {
                                         p[RGB24_R] = fg.pal32.r;                                          p[RGB24_R] = fg.pal32.p.r;
                                         p[RGB24_G] = fg.pal32.g;                                          p[RGB24_G] = fg.pal32.p.g;
                                         p[RGB24_B] = fg.pal32.b;                                          p[RGB24_B] = fg.pal32.p.b;
                                         p += vram->xalign;                                          p += vram->xalign;
                                 } while(--r);                                  } while(--r);
                                 p += dalign;                                  p += dalign;
Line 526  void cmndraw_fill2(const CMNVRAM *vram,  Line 93  void cmndraw_fill2(const CMNVRAM *vram, 
         }          }
 }  }
   
 void cmndraw_setfg2(const CMNVRAM *vram, const BYTE *src,  void cmndraw_setfg(const CMNVRAM *vram, const BYTE *src,
                                                                                 int x, int y, CMNPAL fg) {                                                                                  int x, int y, CMNPAL fg) {
   
 const BYTE      *p;  const BYTE      *p;
Line 616  const BYTE *p; Line 183  const BYTE *p;
         } while(--cy);          } while(--cy);
 }  }
   
 void cmndraw_setpat2(const CMNVRAM *vram, const BYTE *src,  void cmndraw_setpat(const CMNVRAM *vram, const BYTE *src,
                                                                                 int x, int y, CMNPAL bg, CMNPAL fg) {                                                                                  int x, int y, CMNPAL bg, CMNPAL fg) {
   
 const BYTE      *p;  const BYTE      *p;
Line 644  const BYTE *p; Line 211  const BYTE *p;
                                                 c = *p++;                                                  c = *p++;
                                         }                                          }
                                         if (c & bit) {                                          if (c & bit) {
                                                 *q = fg;                                                  *q = fg.pal8;
                                         }                                          }
                                         else {                                          else {
                                                 *q = bg;                                                  *q = bg.pal8;
                                         }                                          }
                                         bit >>= 1;                                          bit >>= 1;
                                         q += vram->xalign;                                          q += vram->xalign;
Line 718  const BYTE *p; Line 285  const BYTE *p;
 }  }
   
   
   
   
   
   
   
   
   
   
   
   
 // ----  // ----
   
 void cmddraw_text8(CMNVRAM *vram, int x, int y, const char *str, CMNPAL fg) {  void cmddraw_text8(CMNVRAM *vram, int x, int y, const char *str, CMNPAL fg) {
Line 755  const BYTE *ptr; Line 312  const BYTE *ptr;
                 }                  }
                 src[0] = ptr[0];                  src[0] = ptr[0];
                 CopyMemory(src + 2, ptr + 1, 7);                  CopyMemory(src + 2, ptr + 1, 7);
                 cmndraw_setfg2(vram, src, x, y, fg);                  cmndraw_setfg(vram, src, x, y, fg);
                 x += ptr[0] + 1;                  x += ptr[0] + 1;
         }          }
 }  }
Removed from v.1.7  
changed lines
  Added in v.1.10

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