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

Diff for /xmil/vram/makescrn.c between versions 1.4 and 1.16

version 1.4, 2004/08/08 16:39:04 version 1.16, 2005/02/04 06:42:12
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "scrnmng.h"  #include        "scrnmng.h"
   #include        "sysmng.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "vram.h"  #include        "vram.h"
Line 9 Line 10
 #include        "makesub.h"  #include        "makesub.h"
   
   
                 MAKESCRN        makescrn;          MAKESCRN        makescrn;
           UINT            drawtime = 0;
                 BYTE    scrnallflash;  
                 BYTE    blinktest = 0;  
   
 static  BYTE    lastdisp = 0;  
                 BYTE    dispflg;  
                 BYTE    *dispp = &GRP_RAM[GRAM_BANK0];  
                 BYTE    *dispp2 = &GRP_RAM[GRAM_BANK1];  
 static  BYTE    blinktime = 1;  
   
                 DWORD   drawtime = 0;  
   
   
 static void fillupdatetmp(void) {  static void fillupdatetmp(void) {
   
         UINT32  *p;  
         UINT    i;          UINT    i;
   
         p = (UINT32 *)updatetmp;          for (i=0; i<0x800; i++) {
         for (i=0; i<0x200; i++) {                  TRAMUPDATE(i) |= UPDATE_TVRAM;
                 p[i] |= (UPDATE_TVRAM << 24) | (UPDATE_TVRAM << 16) |  
                                                                                 (UPDATE_TVRAM << 8) | UPDATE_TVRAM;  
         }          }
 }  }
   
 #if 1  
 static void flashupdatetmp(void) {  static void flashupdatetmp(void) {
   
         UINT    posl;          UINT    posl;
Line 48  static void flashupdatetmp(void) { Line 35  static void flashupdatetmp(void) {
         REG16   udtbase;          REG16   udtbase;
         REG16   udt;          REG16   udt;
   
         posl = crtc.s.TXT_TOP;          if (!makescrn.vramsize) {
         y = crtc.s.TXT_YL;                  return;
           }
           posl = crtc.e.pos;
           y = crtc.e.yl;
         do {          do {
                 for (x=0; x<crtc.s.TXT_XL; x++) {                  for (x=0; x<crtc.s.reg[CRTCREG_HDISP]; x++) {
                         if (!(tram[TRAM_ATR + LOW11(posl + x)] & TRAMATR_Yx2)) {                          if (!(TRAM_ATR(LOW11(posl + x)) & TRAMATR_Yx2)) {
                                 break;                                  break;
                         }                          }
                 }                  }
                 y2 = (x < crtc.s.TXT_XL)?FALSE:TRUE;                  y2 = (x < crtc.s.reg[CRTCREG_HDISP])?FALSE:TRUE;
                 udtbase = (x < crtc.s.TXT_XL)?0x0000:0x0404;                  udtbase = (x < crtc.s.reg[CRTCREG_HDISP])?0x0000:0x0404;
                 r = (crtc.s.TXT_XL + 1) >> 1;                  r = (crtc.s.reg[CRTCREG_HDISP] + 1) >> 1;
                 do {                  do {
                         posr = LOW11(posl + 1);                          posr = LOW11(posl + 1);
                         atr = (tram[TRAM_ATR + posl] << 8) | tram[TRAM_ATR + posr];                          atr = (TRAM_ATR(posl) << 8) | TRAM_ATR(posr);
                         udt = udtbase;                          udt = udtbase;
                         if (!y2) {                          if (!y2) {
                                 if (atr & (TRAMATR_Yx2 << 8)) {                                  if (atr & (TRAMATR_Yx2 << 8)) {
Line 85  static void flashupdatetmp(void) { Line 75  static void flashupdatetmp(void) {
                         if (atr & (TRAMATR_Xx2 << 0)) {                         // 右側倍角?                          if (atr & (TRAMATR_Xx2 << 0)) {                         // 右側倍角?
                                 udt |= 0x0008;                                  udt |= 0x0008;
                         }                          }
                         if ((updatetmp[posl] ^ (udt >> 8)) & 0x1f) {                          if ((TRAMUPDATE(posl) ^ (udt >> 8)) & 0x1f) {
                                 updatetmp[posl] = (UINT8)((udt >> 8) | UPDATE_TVRAM);                                  TRAMUPDATE(posl) = (UINT8)((udt >> 8) | UPDATE_TRAM);
                         }                          }
                         if ((updatetmp[posr] ^ (udt >> 0)) & 0x1f) {                          if ((TRAMUPDATE(posr) ^ (udt >> 0)) & 0x1f) {
                                 updatetmp[posr] = (UINT8)((udt >> 0) | UPDATE_TVRAM);                                  TRAMUPDATE(posr) = (UINT8)((udt >> 0) | UPDATE_TRAM);
                         }                          }
                         posl = LOW11(posl + 2);                          posl = LOW11(posl + 2);
                 } while(--r);                  } while(--r);
                 if (crtc.s.TXT_XL & 1) {                  if (crtc.s.reg[CRTCREG_HDISP] & 1) {
                         posl = LOW11(posl - 1);                          posl = LOW11(posl - 1);
                 }                  }
         } while(--y);          } while(--y);
 }  }
 #else  
 static LABEL void flashupdatetmp(void) {  
   
                 __asm {  
                                 push    ebx  
                                 push    esi  
                                 push    edi  
   
                                 movzx   esi, crtc.s.TXT_TOP  
                                 xor             dl, dl  
                                                                                 // まず行すべてが縦倍角か調べる  
 check_tateflag: mov             edi, esi  
                                 movzx   ecx, crtc.s.TXT_XL  
 tateflaglp_s:   and             edi, (TRAM_MAX - 1)  
                                 test    tram[TRAM_ATR + edi], X1ATR_Yx2  
                                 je              tatex1  
                                 inc             edi  
                                 loop    tateflaglp_s  
                                                                                 // すべて縦倍角 だったら  
   
                                 movzx   ecx, crtc.s.TXT_XL  
                                 shr             cl, 1  
   
 tatex2loop_s:   and             esi, (TRAM_MAX - 1)  
                                 mov             ax, (UPDATE_TVRAM or 04h) * 0101h               // 縦倍角  
                                 mov             bx, word ptr (tram[TRAM_ATR + esi])  
   
                                 test    bl, X1ATR_Xx2  
                                 je              tatex2_norleft  
                                                                                                 // 倍角フラグが立ってる  
                                 or              ax, 08h + 12h * 256             // 左４倍角 + 右縦倍角は確定  
                                 test    bh, X1ATR_Xx2  
                                 je              tatex2_pcg  
                                 or              ah, 8                                   // 右側も倍角ビットが立ってた  
                                 jmp             tatex2_pcg  
   
 tatex2_norleft: test    bh, X1ATR_Xx2                   // ４倍角でない場合  
                                 je              tatex2_pcg  
                                 or              ah, 8                                   // 右側のみ倍角だった  
 tatex2_pcg:             mov             bx, word ptr (updatetmp[esi])  
                                 and             bx, UPDATE_TVRAM * 0101h  
                                 or              ax, bx                                  // UPDATEフラグを加える  
                                 cmp             word ptr (updatetmp[esi]), ax  
                                 je              tatex2noupdate  
                                 or              ax, UPDATE_TVRAM * 0101h  
                                 mov             word ptr (updatetmp[esi]), ax  
 tatex2noupdate: add             esi, 2  
                                 loop    tatex2loop_s  
                                 jmp             nextlinecheck  
   
 tatex1:                 movzx   ecx, crtc.s.TXT_XL  
                                 shr             cl, 1  
                                 xor             dh, dh  
 tatex1loop_s:   and             esi, (TRAM_MAX - 1)  
                                 xor             ax, ax  
                                 mov             bx, word ptr (tram[TRAM_ATR + esi])  
                                 or              dh, dh                                  // 縦ノーマルは既にあったか？  
                                 jne             tatex1_tate_e  
                                 test    bl, X1ATR_Yx2  
                                 je              tatex1_tate0  
                                 mov             al, UPDATE_TVRAM or 1   // 左潰れ縦倍角  
                                 test    bh, X1ATR_Yx2  
                                 je              tatex1_tate0  
                                 mov             ah, UPDATE_TVRAM or 1   // 右潰れ縦倍角  
                                 jmp             tatex1_tate_e  
 tatex1_tate0:   inc             dh                                              // 縦ノーマルの出現  
 tatex1_tate_e:  
                                 test    bl, X1ATR_Xx2  
                                 je              tatex1_norleft  
                                                                                                 // 倍角フラグが立ってる  
                                 or              ax, 08h + (12h * 256)   // 左横倍角 は確定  
                                 test    bh, X1ATR_Xx2  
                                 je              tatex1_pcg  
                                 or              ah, 8                                   // 右側も倍角ビットが立ってた  
                                 jmp             tatex1_pcg  
   
 tatex1_norleft: test    bh, X1ATR_Xx2                   // 倍角でない場合  
                                 je              tatex1_pcg  
                                 or              ah, 8                                   // 右側のみ倍角だった  
 tatex1_pcg:             mov             bx, word ptr (updatetmp[esi])  
                                 and             bx, UPDATE_TVRAM * 0101h  
                                 or              ax, bx  
                                 cmp             word ptr (updatetmp[esi]), ax  
                                 je              tatex1noupdate  
                                 or              ax, UPDATE_TVRAM * 0101h  
                                 mov             word ptr (updatetmp[esi]), ax  
 tatex1noupdate: add             esi, 2  
                                 loop    tatex1loop_s  
   
 nextlinecheck:  inc             dl  
                                 cmp             dl, crtc.s.TXT_YL  
                                 jb              check_tateflag  
   
                                 pop             edi  
                                 pop             esi  
                                 pop             ebx  
                                 ret  
         }  
 }  
 #endif  
   
 static BRESULT updateblink(void) {  static BRESULT updateblink(void) {
   
Line 205  static BRESULT updateblink(void) { Line 95  static BRESULT updateblink(void) {
         REG8    update;          REG8    update;
         UINT    r;          UINT    r;
   
         if (blinktime) {          pos = makescrn.vramtop;
                 blinktime--;          makescrn.blinktest ^= 0x10;
                 return(FALSE);          update = 0;
           r = makescrn.vramsize;
           while(r) {
                   r--;
                   if (TRAM_ATR(pos) & 0x10) {
                           TRAMUPDATE(pos) |= UPDATE_TRAM;
                           update = UPDATE_TRAM;
                   }
                   pos = LOW11(pos + 1);
           }
           if (update) {
                   return(TRUE);
         }          }
         else {          else {
                 blinktime = 30 - 1;                  return(FALSE);
                 pos = makescrn.vramtop;  
                 blinktest ^= 0x10;  
                 update = 0;  
                 r = makescrn.vramsize;  
                 while(r) {  
                         r--;  
                         if (tram[TRAM_ATR + pos] & 0x10) {  
                                 updatetmp[pos] |= UPDATE_TRAM;  
                                 update = UPDATE_TRAM;  
                         }  
                         pos = LOW11(pos + 1);  
                 }  
                 if (update) {  
                         makescrn.existblink = 1;  
                         return(TRUE);  
                 }  
                 else {  
                         return(FALSE);  
                 }  
         }          }
 }  }
   
   
 // ----  // ----
   
   typedef void (*MAKEFN)(void);
   
   static void width_dummy(void) { }
   
   static const UINT8 screendraw[] = {
                                   MAKESCRN_320x200S,      MAKESCRN_320x400,
                                   MAKESCRN_320x200S,      MAKESCRN_320x400,
                                   MAKESCRN_320x200S,      MAKESCRN_320x400,
                                   MAKESCRN_320x200S,      MAKESCRN_320x200H,
   
                                   MAKESCRN_320x200S,      MAKESCRN_320x400,
                                   MAKESCRN_320x200S,      MAKESCRN_320x400,
                                   MAKESCRN_320x200S,      MAKESCRN_320x200H,
                                   MAKESCRN_320x200S,      MAKESCRN_320x200H,
   
   #if defined(SUPPORT_TURBOZ)
                                   MAKESCRN_320x200H,      MAKESCRN_320x200H,
                                   MAKESCRN_320x200H,      MAKESCRN_320x200H,
                                   MAKESCRN_320x200H,      MAKESCRN_320x200H,
                                   MAKESCRN_320x200H,      MAKESCRN_320x200H,
   
                                   MAKESCRN_320x200H,      MAKESCRN_320x200H,
                                   MAKESCRN_320x200H,      MAKESCRN_320x200H,
                                   MAKESCRN_320x200H,      MAKESCRN_320x200H,
                                   MAKESCRN_320x200H,      MAKESCRN_320x200H,
   #endif
   };
   
   static const MAKEFN screenmake[] = {
                                   width80x25_200l,        width80x25_400h,
                                   width80x25_200l,        width80x25_200h,
                                   width80x12_200l,        width80x12_400h,
                                   width80x12_200l,        width80x12_200h,
   
                                   width80x20l,            width80x20h,
                                   width80x20l,            width80x20h,
                                   width80x10l,            width80x10h,
                                   width80x10l,            width80x10h,
   
   #if defined(SUPPORT_TURBOZ)
                                   width_dummy,            width_dummy,
                                   width_dummy,            width_dummy,
                                   width_dummy,            width_dummy,
                                   width_dummy,            width_dummy,
   
                                   width_dummy,            width_dummy,
                                   width_dummy,            width_dummy,
                                   width_dummy,            width_dummy,
                                   width_dummy,            width_dummy,
   #endif
   };
   
   
 static void changemodes(void) {  static void changemodes(void) {
   
         lastdisp = crtc.e.dispmode;          REG8    dispmode;
         if (!(lastdisp & SCRN_BANK1)) {  
                 dispp = GRP_RAM + GRAM_BANK0;          dispmode = crtc.e.dispmode;
                 dispp2 = GRP_RAM + GRAM_BANK1;          makescrn.dispmode = dispmode;
                 dispflg = UPDATE_TRAM | UPDATE_VRAM0;          makescrn.drawmode = screendraw[dispmode & DISPMODE_MASKMODE];
           if (dispmode & DISPMODE_WIDTH80) {
                   makescrn.drawmode |= 1;
           }
           sysmng_scrnwidth((dispmode & DISPMODE_WIDTH80) == 0);
   
           if (!(dispmode & DISPMODE_BANK1)) {
                   makescrn.disp1 = gram + GRAM_BANK0;
                   makescrn.disp2 = gram + GRAM_BANK1;
                   makescrn.dispflag = UPDATE_TRAM + UPDATE_VRAM0;
         }          }
         else {          else {
                 dispp = GRP_RAM + GRAM_BANK1;                  makescrn.disp1 = gram + GRAM_BANK1;
                 dispp2 = GRP_RAM + GRAM_BANK0;                  makescrn.disp2 = gram + GRAM_BANK0;
                 dispflg = UPDATE_TRAM | UPDATE_VRAM1;                  makescrn.dispflag = UPDATE_TRAM + UPDATE_VRAM1;
         }          }
         scrnallflash = 1;  
         makescrn.palandply = 1;  
 }  }
   
 static void changecrtc(void) {  static void changecrtc(void) {
   
         REG8    widthmode;          UINT    scrnxmax;
           UINT    scrnymax;
           UINT    textxl;
           UINT    surfcx;
         UINT    fontcy;          UINT    fontcy;
         UINT    underlines;          UINT    underlines;
         REG8    y2;          REG8    y2;
         UINT    charcy;          UINT    charcy;
         UINT    surfcy;          UINT    surfcy;
           UINT    surfsy;
           UINT    x;
           UINT    y;
           UINT8   *p;
   
         makescrn.vramtop = LOW11(crtc.s.TXT_TOP);          makescrn.vramtop = crtc.e.pos;
   
         if (crtc.s.TXT_XL <= 40) {          scrnxmax = (makescrn.dispmode & DISPMODE_WIDTH80)?80:40;
                 if (lastdisp & SCRN_DRAW4096) {          scrnymax = 200;
                         widthmode = SCRNWIDTHMODE_4096;  
                 }  
                 else {  
                         widthmode = SCRNWIDTHMODE_WIDTH40;  
                 }  
         }  
         else {  
                 widthmode = SCRNWIDTHMODE_WIDTH80;  
         }  
         scrndraw_changewidth(widthmode);  
   
         makescrn.surfcx = min(80, crtc.s.TXT_XL);          textxl = crtc.s.reg[CRTCREG_HDISP];
         makescrn.surfrx = crtc.s.TXT_XL - makescrn.surfcx;          surfcx = min(scrnxmax, textxl);
   
         fontcy = crtc.s.FNT_YL;          fontcy = crtc.e.fonty;
         if (crtc.s.SCRN_BITS & SCRN_24KHZ) {          underlines = (makescrn.dispmode & DISPMODE_UNDERLINE)?2:0;
                 fontcy >>= 1;  
         }  
         underlines = (crtc.s.SCRN_BITS & SCRN_UNDERLINE)?2:0;  
         if (fontcy > underlines) {          if (fontcy > underlines) {
                 fontcy -= underlines;                  fontcy -= underlines;
         }          }
         else {          else {
                 fontcy = 0;                  fontcy = 0;
         }          }
         y2 = (crtc.s.SCRN_BITS & SCRN_TEXTYx2)?1:0;          y2 = (makescrn.dispmode & DISPMODE_TEXTYx2)?1:0;
         fontcy >>= y2;          fontcy >>= y2;
 #if 0  #if 0
         if (((dispmode & SCRN64_MASK) != SCRN64_INVALID) && (fontcy > 8)) {          if (((dispmode & SCRN64_MASK) != SCRN64_INVALID) && (fontcy > 8)) {
Line 307  static void changecrtc(void) { Line 243  static void changecrtc(void) {
         charcy = fontcy + underlines;          charcy = fontcy + underlines;
         makescrn.fontcy = fontcy;          makescrn.fontcy = fontcy;
         makescrn.charcy = charcy;          makescrn.charcy = charcy;
   
         charcy <<= y2;          charcy <<= y2;
         surfcy = 200 / charcy;          surfcy = scrnymax / charcy;
         if (surfcy > crtc.s.TXT_YL) {          if (surfcy > crtc.e.yl) {
                 surfcy = crtc.s.TXT_YL;                  surfcy = crtc.e.yl;
           }
   
           surfsy = charcy * surfcy * 2;
           // ハイドライド３で画面が消えないのでロジックを修正すべし
           x = min(scrnxmax, makescrn.surfcx);
           if (surfcx < x) {                                                               // 小さくなった
                   x = (x - surfcx) * 8;
                   p = screenmap + (surfcx * 8);
                   y = surfsy;
                   while(y) {
                           y--;
                           ZeroMemory(p, x);
                           p += SURFACE_WIDTH;
                   }
         }          }
           if (surfsy < makescrn.surfsy) {
                   ZeroMemory(screenmap + (SURFACE_WIDTH * surfsy),
                                                                   SURFACE_WIDTH * (makescrn.surfsy - surfsy));
           }
           makescrn.surfcx = surfcx;
           makescrn.surfrx = textxl - surfcx;
         makescrn.surfcy = surfcy;          makescrn.surfcy = surfcy;
         makescrn.surfstep = (SURFACE_WIDTH * charcy * 2) - (makescrn.surfcx * 8);          makescrn.surfsy = surfsy;
         makescrn.vramsize = min(0x800, surfcy * crtc.s.TXT_XL);          makescrn.surfstep = (SURFACE_WIDTH * charcy * 2) - (surfcx * 8);
         scrnmng_setheight(0, charcy * surfcy * 2);          makescrn.vramsize = min(0x800, surfcy * textxl);
   //      scrnmng_setheight(0, charcy * surfcy * 2);
 }  }
   
   
 // -------------------------------------------------------------------------  
   
 typedef void (*DRAWFN)(void);  
   
 static const DRAWFN screendraw[8] = {  
                                 width80x25_200l,        width80x25_400h,  
                                 width80x25_200l,        width80x25_200h,  
                                 width80x12_200l,        width80x12_400h,  
                                 width80x12_200l,        width80x12_200h};  
   
 static const DRAWFN screendraw2[8] = {  
                                 width80x20l,            width80x20h,  
                                 width80x20l,            width80x20h,  
                                 width80x10l,            width80x10h,  
                                 width80x10l,            width80x10h};  
   
   
 void scrnupdate(void) {  void scrnupdate(void) {
   
         BRESULT ddrawflash;          REG8    flag;
           REG8    existblink;
   
         if (!corestat.drawframe) {          if (!corestat.drawframe) {
                 return;                  return;
         }          }
         corestat.drawframe = 0;          corestat.drawframe = 0;
   
         ddrawflash = FALSE;          flag = makescrn.nextdraw;
         if (lastdisp != crtc.e.dispmode) {          if (crtc.e.scrnflash) {
                   crtc.e.scrnflash = 0;
                   flag |= SCRNUPD_FLASH;
           }
           if (crtc.e.scrnallflash) {
                   crtc.e.scrnallflash = 0;
                   flag |= SCRNUPD_ALLFLASH;
           }
           if (crtc.e.palandply) {
                   crtc.e.palandply = 0;
                   flag |= SCRNUPD_PALANDPLY;
           }
   
           if (makescrn.dispmode != crtc.e.dispmode) {
                   TRACEOUT(("change mode!"));
                 changemodes();                  changemodes();
                   flag |= SCRNUPD_ALLFLASH | SCRNUPD_PALANDPLY;
         }          }
         if (scrnallflash) {          if (flag & SCRNUPD_ALLFLASH) {
                 scrnallflash = 0;  
                 fillupdatetmp();  
                 changecrtc();                  changecrtc();
                 makescrn.scrnflash = 1;                  TRACEOUT(("flash! %dx%d", makescrn.surfcx, makescrn.surfcy));
                   fillupdatetmp();
                   flag |= SCRNUPD_FLASH;
         }          }
         if (makescrn.remakeattr) {          if (crtc.e.remakeattr) {
                 makescrn.remakeattr = 0;                  crtc.e.remakeattr = 0;
                 flashupdatetmp();                  flashupdatetmp();
         }          }
         if (makescrn.palandply) {          if (flag & SCRNUPD_PALANDPLY) {
                 makescrn.palandply = 0;  
                 pal_update();                  pal_update();
                 ddrawflash = 1;  
         }          }
         if (makescrn.existblink) {  
                 makescrn.scrnflash |= updateblink();  
         }  
   
         if (makescrn.scrnflash) {  
                 makescrn.scrnflash = 0;  
                 makescrn.fontycnt = 0;  
                 switch(lastdisp & SCRN64_MASK) {  
                         case SCRN64_320x200:  
 //                              width40x25_64s();  
                                 break;  
   
                         case SCRN64_L320x200x2:  
 //                              width40x25_64x2();  
                                 break;  
   
                         case SCRN64_L640x200:  
 //                              width80x25_64s();  
                                 break;  
   
                         case SCRN64_H320x400:  
 //                              width40x25_64h();  
                                 break;  
   
                         case SCRN64_320x200x4096:  
 //                              width40x25_4096();  
                                 break;  
   
                         case SCRN64_320x100:  
 //                              width40x12_64l();  
                                 break;  
   
                         case SCRN64_320x100x2:  
 //                              width40x12_64x2();  
                                 break;  
   
                         case SCRN64_L640x100:  
 //                              width80x12_64s();  
                                 break;  
   
                         case SCRN64_H320x200:          if (crtc.e.blinktime) {
 //                              width40x12_64h();                  crtc.e.blinktime--;
                                 break;          }
           else {
                         case SCRN64_320x100x4096:                  crtc.e.blinktime = 30 - 1;
 //                              width40x12_4096();                  if (crtc.e.existblink) {
                                 break;                          existblink = updateblink();
                           crtc.e.existblink = existblink;
                           flag |= existblink;
                   }
           }
   
 //                      case SCRN64_INVALID:          if (flag & SCRNUPD_FLASH) {
                         default:                  if (makescrn.vramsize) {
                                 if (!(crtc.s.SCRN_BITS & SCRN_UNDERLINE)) {                          makescrn.fontycnt = 0;
                                         screendraw[crtc.s.SCRN_BITS & 7]();                          screenmake[makescrn.dispmode & DISPMODE_MASKMODE]();
                                 }  #if 0
                                 else {                          switch(lastdisp & SCRN64_MASK) {
                                         screendraw2[crtc.s.SCRN_BITS & 7]();                                  case SCRN64_320x200:
                                 }  //                                      width40x25_64s();
                                 break;                                          break;
   
                                   case SCRN64_L320x200x2:
   //                                      width40x25_64x2();
                                           break;
   
                                   case SCRN64_L640x200:
   //                                      width80x25_64s();
                                           break;
   
                                   case SCRN64_H320x400:
   //                                      width40x25_64h();
                                           break;
   
                                   case SCRN64_320x200x4096:
   //                                      width40x25_4096();
                                           break;
   
                                   case SCRN64_320x100:
   //                                      width40x12_64l();
                                           break;
   
                                   case SCRN64_320x100x2:
   //                                      width40x12_64x2();
                                           break;
   
                                   case SCRN64_L640x100:
   //                                      width80x12_64s();
                                           break;
   
                                   case SCRN64_H320x200:
   //                                      width40x12_64h();
                                           break;
   
                                   case SCRN64_320x100x4096:
   //                                      width40x12_4096();
                                           break;
   
   //                              case SCRN64_INVALID:
                                   default:
                                           if (!(crtc.s.SCRN_BITS & SCRN_UNDERLINE)) {
                                                   screenmake[(crtc.s.SCRN_BITS & 7) + 0]();
                                           }
                                           else {
                                                   screenmake[(crtc.s.SCRN_BITS & 7) + 8]();
                                           }
                                           break;
                           }
   #endif
                 }                  }
                 ddrawflash = 1;  
         }          }
   
         if (ddrawflash) {          if (flag) {
                 ddrawflash = 0;                  makescrn.nextdraw = scrndraw_draw(flag & SCRNUPD_ALLFLASH);
                 scrndraw_draw(FALSE);  
                 drawtime++;                  drawtime++;
         }          }
 }  }
Line 441  void makescrn_initialize(void) { Line 404  void makescrn_initialize(void) {
   
 void makescrn_reset(void) {  void makescrn_reset(void) {
   
         fillupdatetmp();  
         changemodes();          changemodes();
         changecrtc();          changecrtc();
           flashupdatetmp();
 }  }
   
Removed from v.1.4  
changed lines
  Added in v.1.16

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