CRTC.java
     1: //========================================================================================
     2: //  CRTC.java
     3: //    en:CRT controller
     4: //    ja:CRTコントローラ
     5: //  Copyright (C) 2003-2025 Makoto Kamada
     6: //
     7: //  This file is part of the XEiJ (X68000 Emulator in Java).
     8: //  You can use, modify and redistribute the XEiJ if the conditions are met.
     9: //  Read the XEiJ License for more details.
    10: //  https://stdkmd.net/xeij/
    11: //========================================================================================
    12: 
    13: //----------------------------------------------------------------------------------------
    14: //
    15: //    垂直同期
    16: //                                     ラスタ0
    17: //                                       ↓
    18: //                             ┌──────────────垂直周期──────────────┐
    19: //                 ━━━━━━━━━━━┓    ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓    ┏━━━━━━━━━━━
    20: //    垂直同期信号      垂直パルス間     ┃    ┃                       垂直パルス間                       ┃    ┃     垂直パルス間
    21: //                                       ┗━━┛                                                          ┗━━┛
    22: //                             │  垂直  │垂直│  垂直  │                                      │  垂直  │垂直│  垂直  │
    23: //                             │フロント  同期   バック │                                      │フロント  同期   バック │
    24: //                             │ ポーチ  パルス  ポーチ │                                      │ ポーチ  パルス  ポーチ │
    25: //                1━━━━━━┓                        ┏━━━━━━━━━━━━━━━━━━━┓                        ┏━━━━━━1
    26: //    垂直映像信号 垂直映像期間┃      垂直空白期間      ┃             垂直映像期間             ┃      垂直空白期間      ┃垂直映像期間
    27: //       V-DISP   0            ┗━━━━━━━━━━━━┛                                      ┗━━━━━━━━━━━━┛            0
    28: //
    29: //
    30: //    水平同期
    31: //                             ┌──────────────水平周期──────────────┐
    32: //                1                      ┏━━┓                                                          ┏━━┓                      1
    33: //    水平同期信号      水平パルス間     ┃    ┃                       水平パルス間                       ┃    ┃     水平パルス間
    34: //       H-SYNC   0━━━━━━━━━━━┛    ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛    ┗━━━━━━━━━━━0
    35: //                             │  水平  │水平│  水平  │                                      │  水平  │水平│  水平  │
    36: //                             │フロント  同期   バック │                                      │フロント  同期   バック │
    37: //                             │ ポーチ  パルス  ポーチ │                                      │ ポーチ  パルス  ポーチ │
    38: //                 ━━━━━━┓                        ┏━━━━━━━━━━━━━━━━━━━┓                        ┏━━━━━━
    39: //    水平映像信号 水平映像期間┃      水平空白期間      ┃             水平映像期間             ┃      水平空白期間      ┃水平映像期間
    40: //                             ┗━━━━━━━━━━━━┛                                      ┗━━━━━━━━━━━━┛
    41: //                             └┐                                                              └┐
    42: //                1━━━━━━━┓                                                                ┏━━━━━━━━━━━━━━━━━━1
    43: //      CRTC IRQ                 ┃                            IRQラスタ                           ┃
    44: //                0              ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛                                    0
    45: //                               └┐                                                              └┐
    46: //                1                ┏━━━━━━━━━━━━━━━ ∥ ━━━━━━━━━━━━━━━┓                                  1
    47: //    垂直映像信号                 ┃    垂直映像期間開始ラスタ     ∥     垂直映像期間終了ラスタ    ┃
    48: //       V-DISP   0━━━━━━━━┛                               ∥                               ┗━━━━━━━━━━━━━━━━━0
    49: //
    50: //
    51: //    HT  水平周期カラム数
    52: //    HS  水平同期パルスカラム数
    53: //    HB  水平バックポーチカラム数
    54: //    HD  水平映像期間カラム数
    55: //    HF  水平フロントポーチカラム数
    56: //    VT  垂直周期ラスタ数
    57: //    VS  垂直同期パルスラスタ数
    58: //    VB  垂直バックポーチラスタ数
    59: //    VD  垂直映像期間ラスタ数
    60: //    VF  垂直フロントポーチラスタ数
    61: //
    62: //    0x00e80000  .w  R00  HT-1=HS+HB+HD+HF-1
    63: //    0x00e80002  .w  R01  HS-1
    64: //    0x00e80004  .w  R02  HS+HB-5
    65: //    0x00e80006  .w  R03  HS+HB+HD-5
    66: //    0x00e80008  .w  R04  VT-1=VS+VB+VD+VF-1
    67: //    0x00e8000a  .w  R05  VS-1
    68: //    0x00e8000c  .w  R06  VS+VB-1
    69: //    0x00e8000e  .w  R07  VS+VB+VD-1
    70: //    0x00e80029  .b  R20L
    71: //
    72: //    0x00e8e007  bit1  HRL
    73: //
    74: //
    75: //  ----------------------------------------------------------------------------------------------------------------------------
    76: //       解像度  サイズ         色x枚    R00   R01   R02   R03    R04   R05   R06   R07    R20L  HRL       水平同期周波数
    77: //  CRTMOD              実画面                                                                             垂直同期周波数
    78: //                                       HT   HS   HB   HD   HF   VT   VS   VB   VD   VF               垂直周期 理論値 実測値
    79: //  ----------------------------------------------------------------------------------------------------------------------------
    80: //    $00  高   512x512  1024     16x1  $005B $0009 $0011 $0051  $0237 $0005 $0028 $0228   $15    0  69.552MHz/3/8/ 92=31.500kHz
    81: //    $04                 512     16x4   92-1  10-1  22-5  86-5  568-1   6-1  41-1 553-1  %10101          31.500kHz/568=55.458Hz
    82: //    $08                 512    256x2   92   10   12   64    6  568    6   35  512   15                  18032μs   18026μs
    83: //    $0C                 512  65536x1
    84: //  ----------------------------------------------------------------------------------------------------------------------------
    85: //    $01  低   512x512  1024     16x1  $004B $0003 $0005 $0045  $0103 $0002 $0010 $0100   $05    0  38.864MHz/4/8/ 76=15.980kHz
    86: //    $05                 512     16x4   76-1   4-1  10-5  74-5  260-1   2-1  17-1 257-1  %00101          15.980kHz/260=61.462Hz
    87: //    $09                 512    256x2   76    4    6   64    2  260    2   15  240    3                  16270μs   16265μs
    88: //    $0D                 512  65536x1
    89: //  ----------------------------------------------------------------------------------------------------------------------------
    90: //    $02  高   256x256  1024     16x1  $002D $0004 $0006 $0026  $0237 $0005 $0028 $0228   $10    0  69.552MHz/6/8/ 46=31.500kHz
    91: //    $06                 512     16x4   46-1   5-1  11-5  43-5  568-1   6-1  41-1 553-1  %10000          31.500kHz/568=55.458Hz
    92: //    $0A                 512    256x2   46    5    6   32    3  568    6   35  512   15                  18032μs   18027μs
    93: //    $0E                 512  65536x1
    94: //  ----------------------------------------------------------------------------------------------------------------------------
    95: //    $03  低   256x256  1024     16x1  $0025 $0001 $0000 $0020  $0103 $0002 $0010 $0100   $00    0  38.864MHz/8/8/ 38=15.980kHz
    96: //    $07                 512     16x4   38-1   2-1   5-5  37-5  260-1   2-1  17-1 257-1  %00000          15.980kHz/260=61.462Hz
    97: //    $0B                 512    256x2   38    2    3   32    1  260    2   15  240    3                  16270μs   16265μs
    98: //    $0F                 512  65536x1
    99: //  ----------------------------------------------------------------------------------------------------------------------------
   100: //    $10  高   768x512  1024     16x1  $0089 $000E $001C $007C  $0237 $0005 $0028 $0228   $16    0  69.552MHz/2/8/138=31.500kHz
   101: //    $14                 512    256x2  138-1  15-1  33-5 129-5  568-1   6-1  41-1 553-1  %10110          31.500kHz/568=55.458Hz
   102: //    $18                 512  65536x1  138   15   18   96    9  568    6   35  512   15                  18032μs   18026μs
   103: //  ----------------------------------------------------------------------------------------------------------------------------
   104: //    $11  中  1024x424  1024     16x1  $00AF $000F $001F $009F  $01D0 $0007 $0020 $01C8   $16    0  69.552MHz/2/8/176=24.699kHz
   105: //    $15                 512    256x2  176-1  16-1  36-5 164-5  465-1   8-1  33-1 457-1  %10110          24.699kHz/465=53.116Hz
   106: //    $19                 512  65536x1  176   16   20  128   12  465    8   25  424    8                  18827μs   18822μs
   107: //  ----------------------------------------------------------------------------------------------------------------------------
   108: //    $12  中  1024x848  1024     16x1  $00AF $000F $001F $009F  $01D0 $0007 $0020 $01C8   $1A    0  69.552MHz/2/8/176=24.699kHz
   109: //    $16                 512    256x2  176-1  16-1  36-5 164-5  465-1   8-1  33-1 457-1  %11010          24.699kHz/465=53.116Hz
   110: //    $1A                 512  65536x1  176   16   20  128   12  465    8   25  424    8                  18827μs   18862μs
   111: //  ----------------------------------------------------------------------------------------------------------------------------
   112: //    $13  中   640x480  1024     16x1  $0063 $000B $000D $005D  $020C $0001 $0021 $0201   $17    0  50.350MHz/2/8/100=31.469kHz
   113: //    $17        (VGA)    512    256x2  100-1  12-1  18-5  98-5  525-1   2-1  34-1 514-1  %10111          31.469kHz/525=59.940Hz
   114: //    $1B                 512  65536x1  100   12    6   80    2  525    2   32  480   11                  16683μs   16678μs
   115: //  ----------------------------------------------------------------------------------------------------------------------------
   116: //
   117: //
   118: //  CRTMOD$10(768x512)のR20LとHRLを変更して垂直周期を計測し、R20LとHRLとオシレータと分周比の関係を調べた
   119: //
   120: //           オシレータ/分周比    垂直周期               オシレータ/分周比    垂直周期
   121: //     R20L HRL               理論値    実測値     R20L HRL               理論値    実測値
   122: //      $00  0  38.864MHz/8  129082μs  129079μs     $00  1  38.864MHz/8  129082μs  129079μs
   123: //      $01  0  38.864MHz/4   64541μs   64539μs     $01  1  38.864MHz/4   64541μs   64539μs
   124: //      $02  0  38.864MHz/8  129082μs  129078μs     $02  1  38.864MHz/8  129082μs  129079μs
   125: //      $03  0  38.864MHz/8  129082μs  129079μs     $03  1  38.864MHz/8  129082μs  129078μs
   126: //      $04  0  38.864MHz/8  129082μs  129306μs     $04  1  38.864MHz/8  129082μs  129306μs
   127: //      $05  0  38.864MHz/4   64541μs   64653μs     $05  1  38.864MHz/4   64541μs   64653μs
   128: //      $06  0  38.864MHz/8  129082μs  129306μs     $06  1  38.864MHz/8  129082μs  129306μs
   129: //      $07  0  38.864MHz/8  129082μs  129307μs     $07  1  38.864MHz/8  129082μs  129306μs
   130: //      $08  0  38.864MHz/8  129082μs  129306μs     $08  1  38.864MHz/8  129082μs  129307μs
   131: //      $09  0  38.864MHz/4   64541μs   64652μs     $09  1  38.864MHz/4   64541μs   64652μs
   132: //      $0A  0  38.864MHz/8  129082μs  129305μs     $0A  1  38.864MHz/8  129082μs  129306μs
   133: //      $0B  0  38.864MHz/8  129082μs  129307μs     $0B  1  38.864MHz/8  129082μs  129306μs
   134: //      $0C  0  38.864MHz/8  129082μs  129307μs     $0C  1  38.864MHz/8  129082μs  129306μs
   135: //      $0D  0  38.864MHz/4   64541μs   64652μs     $0D  1  38.864MHz/4   64541μs   64653μs
   136: //      $0E  0  38.864MHz/8  129082μs  129305μs     $0E  1  38.864MHz/8  129082μs  129306μs
   137: //      $0F  0  38.864MHz/8  129082μs  129306μs     $0F  1  38.864MHz/8  129082μs  129307μs
   138: //      $10  0  69.552MHz/6   54095μs   54093μs     $10  1  69.552MHz/8   72127μs   72126μs
   139: //      $11  0  69.552MHz/3   27048μs   27047μs     $11  1  69.552MHz/4   36064μs   36060μs
   140: //      $12  0  69.552MHz/2   18032μs   18031μs     $12  1  69.552MHz/2   18032μs   18029μs
   141: //      $13  0  50.350MHz/2   24909μs   24905μs     $13  1  50.350MHz/2   24909μs   24905μs
   142: //      $14  0  69.552MHz/6   54095μs   54094μs     $14  1  69.552MHz/8   72127μs   72124μs
   143: //      $15  0  69.552MHz/3   27048μs   27046μs     $15  1  69.552MHz/4   36064μs   36061μs
   144: //      $16  0  69.552MHz/2   18032μs   18030μs     $16  1  69.552MHz/2   18032μs   18030μs
   145: //      $17  0  50.350MHz/2   24909μs   24906μs     $17  1  50.350MHz/2   24909μs   24906μs
   146: //      $18  0  69.552MHz/6   54095μs   54188μs     $18  1  69.552MHz/8   72127μs   72251μs
   147: //      $19  0  69.552MHz/3   27048μs   27094μs     $19  1  69.552MHz/4   36064μs   36124μs
   148: //      $1A  0  69.552MHz/2   18032μs   18061μs     $1A  1  69.552MHz/2   18032μs   18062μs
   149: //      $1B  0  50.350MHz/2   24909μs   24950μs     $1B  1  50.350MHz/2   24909μs   24950μs
   150: //      $1C  0  69.552MHz/6   54095μs   54189μs     $1C  1  69.552MHz/8   72127μs   72250μs
   151: //      $1D  0  69.552MHz/3   27048μs   27092μs     $1D  1  69.552MHz/4   36064μs   36125μs
   152: //      $1E  0  69.552MHz/2   18032μs   18062μs     $1E  1  69.552MHz/2   18032μs   18062μs
   153: //      $1F  0  50.350MHz/2   24909μs   24951μs     $1F  1  50.350MHz/2   24909μs   24950μs
   154: //
   155: //    perl -e "for$o(38.863632,69.551900,50.349800){for$d(6,8,3,4,2){printf'  //      %6.3fMHz/%d  %6.0fus%c',$o,$d,1/($o/($d*8*138*568)),10;}}"
   156: //
   157: //     オシレータ/分周比
   158: //                    理論値    R20L  HRL
   159: //      38.864MHz/6   96811μs
   160: //      38.864MHz/8  129082μs  %0**00  *
   161: //                             %0**1*  *
   162: //      38.864MHz/3   48406μs
   163: //      38.864MHz/4   64541μs  %0**01  *
   164: //      38.864MHz/2   32270μs
   165: //      69.552MHz/6   54095μs  %1**00  0
   166: //      69.552MHz/8   72127μs  %1**00  1
   167: //      69.552MHz/3   27048μs  %1**01  0
   168: //      69.552MHz/4   36064μs  %1**01  1
   169: //      69.552MHz/2   18032μs  %1**10  *
   170: //      50.350MHz/6   74726μs
   171: //      50.350MHz/8   99634μs
   172: //      50.350MHz/3   37363μs
   173: //      50.350MHz/4   49817μs
   174: //      50.350MHz/2   24909μs  %1**11  *
   175: //
   176: //      オシレータと分周比はR20のbit4,1,0とHRLで決まる
   177: //      HRLをセットすると69.552MHzの3分周と6分周が4分周と8分周に変わる
   178: //      VGAモードのための50.350MHzのオシレータと起動時のVキーとNキーの処理はX68000 Compact(IPLROM 1.2)で追加された
   179: //      X68000 XVI(IPLROM 1.1)までの機種ではVGAモードは使用できない
   180: //
   181: //----------------------------------------------------------------------------------------
   182: //
   183: //  R08 外部同期水平アジャスト
   184: //
   185: //    スーパーインポーズするときビデオの映像とX68000の映像を重ねるために、
   186: //    ビデオとX68000の水平同期パルスの先頭の時間差を38.863632MHzのサイクル数で指定する。
   187: //
   188: //    低解像度512x512(インターレース)のとき
   189: //      水平同期パルス幅は4カラム。R01=4-1=3
   190: //      水平バックポーチは6カラム。R02=4+6-5=5
   191: //      推測される計算式。おそらく正しい?
   192: //        perl -e "print((4.7+4.7)*38.863632-(4*8*(4+6))-1)"
   193: //        44.3181408
   194: //      外部同期水平アジャストは44
   195: //
   196: //    低解像度256x256のとき
   197: //      水平同期パルス幅は2カラム。R01=2-1=1
   198: //      水平バックポーチは3カラム。R02=2+3-5=0
   199: //      推測される計算式。1ドット追加する?
   200: //        perl -e "print((4.7+4.7)*38.863632-(8*(8*(2+3)+1))-1)"
   201: //        36.3181408
   202: //      外部同期水平アジャストは36
   203: //
   204: //    低解像度以外の設定値27の根拠は不明
   205: //
   206: //----------------------------------------------------------------------------------------
   207: //
   208: //  ラスタコピー
   209: //
   210: //    関係するレジスタ
   211: //      $00E8002A  .w  CRTC R21         bit3     1=テキストプレーン3をラスタコピーする,0=しない
   212: //                                      bit2     1=テキストプレーン2をラスタコピーする,0=しない
   213: //                                      bit1     1=テキストプレーン1をラスタコピーする,0=しない
   214: //                                      bit0     1=テキストプレーン0をラスタコピーする,0=しない
   215: //      $00E8002C  .w  CRTC R22         bit15-8  ソースラスタブロック番号(0~255)
   216: //                                      bit7-0   デスティネーションラスタブロック番号(0~255)
   217: //      $00E80480  .w  CRTC 動作ポート  bit3     1=水平フロントポーチでラスタコピーする,0=しない
   218: //      $00E88001  .b  MFP GPIPデータ   bit7     1=水平同期パルス,0=水平パルス間(水平バックポーチ+水平映像期間+水平フロントポーチ)
   219: //                                      bit4     1=垂直映像期間,0=垂直空白期間(垂直フロントポーチ+垂直同期パルス+垂直バックポーチ)
   220: //
   221: //    ラスタコピーの動作
   222: //      水平フロントポーチの先頭で(動作ポート&8)!=0のとき、
   223: //      (R21&1)!=0ならばテキストプレーン0($00E00000~$00E1FFFF)について、
   224: //      (R21&2)!=0ならばテキストプレーン1($00E20000~$00E3FFFF)について、
   225: //      (R21&4)!=0ならばテキストプレーン2($00E40000~$00E5FFFF)について、
   226: //      (R21&8)!=0ならばテキストプレーン3($00E60000~$00E7FFFF)について、それぞれ、
   227: //      ラスタブロック(R22>>>8)(テキストVRAMのオフセット(R22>>>8)*512~(R22>>>8)*512+511)の内容を、
   228: //      ラスタブロック(R22&255)(テキストVRAMのオフセット(R22&255)*512~(R22&255)*512+511)へ、コピーする
   229: //
   230: //      メモ
   231: //        ラスタコピーは水平同期パルスではなく水平フロントポーチで行われる
   232: //          水平同期パルスに入る前に終わっている
   233: //        動作ポートのbit3はMPUがラスタコピーの機能をON/OFFするための単なるスイッチである
   234: //          0→1が動作開始を意味するトリガーのようなものではない
   235: //          CRTCが動作終了を知らせるフラグのようなものでもない
   236: //
   237: //    水平同期パルスの待ち方
   238: //      水平同期パルスは非常に短い
   239: //          画面モード        水平同期パルスの長さ          10MHz換算
   240: //          高解像度768x512   1/31500*10/92*1e6=3.45μs   34クロック
   241: //          低解像度512x512   1/15980*4/76*1e6=3.29μs    32クロック
   242: //          中解像度1024x848  1/24699*16/176*1e6=3.68μs  36クロック
   243: //          VGA 640x480       1/31469*12/100*1e6=3.81μs  38クロック
   244: //      水平同期パルスを待つときは見逃さないように割り込みを禁止してなるべく短い間隔でGPIPデータを監視しなければならない
   245: //      普通の方法
   246: //                  lea.l   GPIPデータ,a0
   247: //                  割り込みを禁止する
   248: //          1:      tst.b   (a0)
   249: //                  bpl.s   1b
   250: //      ショートの条件分岐命令は通過する方が速い
   251: //                  lea.l   GPIPデータ,a0
   252: //                  割り込みを禁止する
   253: //          1:      .rept   9
   254: //                  tst.b   (a0)
   255: //                  bmi.s   2f
   256: //                  .endm
   257: //                  tst.b   (a0)
   258: //                  bpl.s   1b
   259: //          2:
   260: //      水平同期パルスの先頭を通過したかどうかが分かればよいので、多少進み過ぎても問題ない
   261: //                  lea.l   GPIPデータ,a0
   262: //                  割り込みを禁止する
   263: //          1:      move.b  (a0),d0
   264: //                  .rept   9
   265: //                  or.b    (a0),d0
   266: //                  .endm
   267: //                  bpl.s   1b
   268: //
   269: //    ラスタコピーの手順
   270: //      10MHz機ではGPIPデータの監視の条件分岐とR22の更新とループの分岐が水平同期パルスに収まらないので水平パルス間を待つ必要がほとんど無い
   271: //      しかし、水平同期パルスだけを待つ方法ではMPUが速いとき1回の水平同期パルスにR22を2回更新してしまいラスタコピーに失敗する可能性がある
   272: //      MPUがどんなに速くても問題なく動作させるには水平同期パルスと水平パルス間を両方待たなければならない
   273: //                  move.w  #コピーするラスタブロック数-1,d3
   274: //                  bmi.s   5f
   275: //                  割り込みを禁止する
   276: //                  水平同期パルスを待つ
   277: //                  水平パルス間を待つ
   278: //                  R21を設定する
   279: //                  R22を設定する
   280: //                  動作ポートのbit3をセットする
   281: //                  bra.s   4f
   282: //          3:      割り込みを禁止する
   283: //                  水平同期パルスを待つ
   284: //                  水平パルス間を待つ
   285: //                  R22を更新する
   286: //          4:      割り込みを許可する
   287: //                  dbra.w  d3.3b
   288: //                  割り込みを禁止する
   289: //                  水平同期パルスを待つ
   290: //                  水平パルス間を待つ
   291: //                  動作ポートのbit3をクリアする
   292: //                  割り込みを許可する
   293: //          5:
   294: //
   295: //    画面クリア
   296: //        ラスタブロック63が余っているとき
   297: //          同時アクセスを使ってラスタブロック63をクリア
   298: //          ラスタブロック63からラスタブロック(開始行*4+0)へラスタコピー
   299: //          ラスタブロック63からラスタブロック(開始行*4+1)へラスタコピー
   300: //                  :
   301: //          ラスタブロック63からラスタブロック(終了行*4+2)へラスタコピー
   302: //          ラスタブロック63からラスタブロック(終了行*4+3)へラスタコピー
   303: //
   304: //    16ドットスムーススクロールアップ
   305: //        ラスタブロック63が余っているとき
   306: //          同時アクセスを使ってラスタブロック63をクリア
   307: //          垂直映像期間を待つ
   308: //          垂直空白期間を待つ
   309: //          ラスタブロック(開始行*4+4)からラスタブロック(開始行*4)へラスタコピー
   310: //          ラスタブロック(開始行*4+5)からラスタブロック(開始行*4+1)へラスタコピー
   311: //                  :
   312: //          ラスタブロック(終了行*4+2)からラスタブロック(終了行*4-2)へラスタコピー
   313: //          ラスタブロック(終了行*4+3)からラスタブロック(終了行*4-1)へラスタコピー
   314: //          ラスタブロック63からラスタブロック(終了行*4+1)へラスタコピー
   315: //          ラスタブロック63からラスタブロック(終了行*4+1)へラスタコピー
   316: //          ラスタブロック63からラスタブロック(終了行*4+2)へラスタコピー
   317: //          ラスタブロック63からラスタブロック(終了行*4+3)へラスタコピー
   318: //
   319: //    8ドットスムーススクロールアップ
   320: //        ラスタブロック63が余っているとき
   321: //          同時アクセスを使ってラスタブロック63をクリア
   322: //        以下を2回繰り返す
   323: //          垂直映像期間を待つ
   324: //          垂直空白期間を待つ
   325: //          ラスタブロック(開始行*4+2)からラスタブロック(開始行*4)へラスタコピー
   326: //          ラスタブロック(開始行*4+3)からラスタブロック(開始行*4+1)へラスタコピー
   327: //                  :
   328: //          ラスタブロック(終了行*4+2)からラスタブロック(終了行*4)へラスタコピー
   329: //          ラスタブロック(終了行*4+3)からラスタブロック(終了行*4+1)へラスタコピー
   330: //          ラスタブロック63からラスタブロック(終了行*4+2)へラスタコピー
   331: //          ラスタブロック63からラスタブロック(終了行*4+3)へラスタコピー
   332: //
   333: //    4ドットスムーススクロールアップ
   334: //        ラスタブロック63が余っているとき
   335: //          同時アクセスを使ってラスタブロック63をクリア
   336: //        以下を4回繰り返す
   337: //          垂直映像期間を待つ
   338: //          垂直空白期間を待つ
   339: //          ラスタブロック(開始行*4+1)からラスタブロック(開始行*4)へラスタコピー
   340: //          ラスタブロック(開始行*4+2)からラスタブロック(開始行*4+1)へラスタコピー
   341: //                  :
   342: //          ラスタブロック(終了行*4+2)からラスタブロック(終了行*4+1)へラスタコピー
   343: //          ラスタブロック(終了行*4+3)からラスタブロック(終了行*4+2)へラスタコピー
   344: //          ラスタブロック63からラスタブロック(終了行*4+3)へラスタコピー
   345: //
   346: //    16ドットスムーススクロールダウン
   347: //      スクロールダウンのときmemcpyの要領で下からコピーすると途中で走査線と衝突して画面に亀裂が入ってしまい見苦しくなる
   348: //      スクロールダウンのときも上からコピーする
   349: //      画面外の余っているラスタブロックをバッファに使う
   350: //      Aをクリアしておいて0→B,A→0,1→A,B→1,2→B,A→2,3→A,B→3,…の順にコピーする
   351: //      スクロールアップは走査線の4倍の速さで進むがスクロールダウンは2倍なので水平同期パルスを頻繁に見逃すと走査線に追い付かれてしまう
   352: //      ラスタブロック56~63をバッファとして使う
   353: //          同時アクセスを使ってラスタブロック56をクリア
   354: //          ラスタブロック56からラスタブロック57へラスタコピー
   355: //          ラスタブロック56からラスタブロック58へラスタコピー
   356: //          ラスタブロック56からラスタブロック59へラスタコピー
   357: //          垂直映像期間を待つ
   358: //          垂直空白期間を待つ
   359: //          ラスタブロック(開始行*4)からラスタブロック60へラスタコピー
   360: //          ラスタブロック(開始行*4+1)からラスタブロック61へラスタコピー
   361: //          ラスタブロック(開始行*4+2)からラスタブロック62へラスタコピー
   362: //          ラスタブロック(開始行*4+3)からラスタブロック63へラスタコピー
   363: //          ラスタブロック56からラスタブロック(開始行*4)へラスタコピー
   364: //          ラスタブロック57からラスタブロック(開始行*4+1)へラスタコピー
   365: //          ラスタブロック58からラスタブロック(開始行*4+2)へラスタコピー
   366: //          ラスタブロック59からラスタブロック(開始行*4+3)へラスタコピー
   367: //          ラスタブロック(開始行*4+4)からラスタブロック56へラスタコピー
   368: //          ラスタブロック(開始行*4+5)からラスタブロック57へラスタコピー
   369: //          ラスタブロック(開始行*4+6)からラスタブロック58へラスタコピー
   370: //          ラスタブロック(開始行*4+7)からラスタブロック59へラスタコピー
   371: //          ラスタブロック60からラスタブロック(開始行*4+4)へラスタコピー
   372: //          ラスタブロック61からラスタブロック(開始行*4+5)へラスタコピー
   373: //          ラスタブロック62からラスタブロック(開始行*4+6)へラスタコピー
   374: //          ラスタブロック63からラスタブロック(開始行*4+7)へラスタコピー
   375: //                  :
   376: //          ラスタブロック56/60からラスタブロック(終了行*4)へラスタコピー
   377: //          ラスタブロック57/61からラスタブロック(終了行*4+1)へラスタコピー
   378: //          ラスタブロック58/62からラスタブロック(終了行*4+2)へラスタコピー
   379: //          ラスタブロック59/63からラスタブロック(終了行*4+3)へラスタコピー
   380: //      画面外のラスタブロックを利用できない場合は最下行になる行の一部をメモリに退避させてから最下行とその上のラスタブロックをバッファに使う
   381: //
   382: //    8ドットスムーススクロールダウン
   383: //        以下を2回繰り返す
   384: //          同時アクセスを使ってラスタブロック60をクリア
   385: //          ラスタブロック60からラスタブロック61へラスタコピー
   386: //          垂直映像期間を待つ
   387: //          垂直空白期間を待つ
   388: //          ラスタブロック(開始行*4)からラスタブロック62へラスタコピー
   389: //          ラスタブロック(開始行*4+1)からラスタブロック63へラスタコピー
   390: //          ラスタブロック60からラスタブロック(開始行*4)へラスタコピー
   391: //          ラスタブロック61からラスタブロック(開始行*4+1)へラスタコピー
   392: //          ラスタブロック(開始行*4+2)からラスタブロック60へラスタコピー
   393: //          ラスタブロック(開始行*4+3)からラスタブロック61へラスタコピー
   394: //          ラスタブロック62からラスタブロック(開始行*4+2)へラスタコピー
   395: //          ラスタブロック63からラスタブロック(開始行*4+3)へラスタコピー
   396: //                  :
   397: //          ラスタブロック60/62からラスタブロック(終了行*4+2)へラスタコピー
   398: //          ラスタブロック61/63からラスタブロック(終了行*4+3)へラスタコピー
   399: //
   400: //    4ドットスムーススクロールダウン
   401: //        以下を4回繰り返す
   402: //          同時アクセスを使ってラスタブロック62をクリア
   403: //          垂直映像期間を待つ
   404: //          垂直空白期間を待つ
   405: //          ラスタブロック(開始行*4)からラスタブロック63へラスタコピー
   406: //          ラスタブロック62からラスタブロック(開始行*4)へラスタコピー
   407: //          ラスタブロック(開始行*4+1)からラスタブロック62へラスタコピー
   408: //          ラスタブロック63からラスタブロック(開始行*4+1)へラスタコピー
   409: //                  :
   410: //          ラスタブロック62/63からラスタブロック(終了行*4+3)へラスタコピー
   411: //
   412: //----------------------------------------------------------------------------------------
   413: 
   414: package xeij;
   415: 
   416: import java.lang.*;  //Boolean,Character,Class,Comparable,Double,Exception,Float,IllegalArgumentException,Integer,Long,Math,Number,Object,Runnable,SecurityException,String,StringBuilder,System
   417: import java.util.*;  //ArrayList,Arrays,Calendar,GregorianCalendar,HashMap,Map,Map.Entry,Timer,TimerTask,TreeMap
   418: 
   419: public class CRTC {
   420: 
   421:   //拡張グラフィック画面
   422:   //  メモリモード5  1024ドット512色(拡張)
   423:   //  メモリモード7  1024ドット65536色(拡張)
   424:   public static final boolean CRT_EXTENDED_GRAPHIC = true;  //true=拡張グラフィック画面をONにできる
   425:   public static boolean crtExtendedGraphicRequest;  //true=次回起動時に拡張グラフィック画面をONにする
   426:   public static boolean crtExtendedGraphicOn;  //true=拡張グラフィック画面がON
   427: 
   428:   //画面モードに変更があったとき描画をリスタートさせるまでの遅延(XEiJ.TMR_FREQ単位)
   429:   public static final long CRT_RESTART_DELAY = XEiJ.TMR_FREQ / 5;  //0.2秒
   430: 
   431:   //レジスタ
   432:   //  R00-R19/R22-R23はwrite onlyでreadすると常に0が返るが読めないと不便なのでreadできるようにする
   433:   //  動作ポートはreadできるが1を書き込んだビットは0を書き込むまで1のまま
   434:   //  未定義ビットは常に0
   435:   public static final int CRT_R00_H_FRONT_END = 0x00e80000;  //R00  bit7-0   水平フロントポーチ終了カラム
   436:   public static final int CRT_R01_H_SYNC_END  = 0x00e80002;  //R01  bit7-0   水平同期パルス終了カラム
   437:   public static final int CRT_R02_H_BACK_END  = 0x00e80004;  //R02  bit7-0   水平バックポーチ終了カラム
   438:   public static final int CRT_R03_H_DISP_END  = 0x00e80006;  //R03  bit7-0   水平映像期間終了カラム
   439:   public static final int CRT_R04_V_FRONT_END = 0x00e80008;  //R04  bit9-0   垂直フロントポーチ終了ラスタ
   440:   public static final int CRT_R05_V_SYNC_END  = 0x00e8000a;  //R05  bit9-0   垂直同期パルス終了ラスタ
   441:   public static final int CRT_R06_V_BACK_END  = 0x00e8000c;  //R06  bit9-0   垂直バックポーチ終了ラスタ
   442:   public static final int CRT_R07_V_DISP_END  = 0x00e8000e;  //R07  bit9-0   垂直映像期間終了ラスタ
   443:   public static final int CRT_R08_ADJUST      = 0x00e80010;  //R08  bit7-0   外部同期アジャスト。TVとX68000の水平同期パルスの立下りの時間差(39MHz)
   444:   public static final int CRT_R09_IRQ_RASTER  = 0x00e80012;  //R09  bit9-0   IRQラスタ。0=垂直同期パルス開始ラスタ
   445:   public static final int CRT_R10_TX_X        = 0x00e80014;  //R10  bit9-0   テキストX方向スクロール
   446:   public static final int CRT_R11_TX_Y        = 0x00e80016;  //R11  bit9-0   テキストY方向スクロール
   447:   public static final int CRT_R12_GR_X_0      = 0x00e80018;  //R12  bit9-0   グラフィックX方向スクロール4bitページ0
   448:   public static final int CRT_R13_GR_Y_0      = 0x00e8001a;  //R13  bit9-0   グラフィックY方向スクロール4bitページ0
   449:   public static final int CRT_R14_GR_X_1      = 0x00e8001c;  //R14  bit8-0   グラフィックX方向スクロール4bitページ1
   450:   public static final int CRT_R15_GR_Y_1      = 0x00e8001e;  //R15  bit8-0   グラフィックY方向スクロール4bitページ1
   451:   public static final int CRT_R16_GR_X_2      = 0x00e80020;  //R16  bit8-0   グラフィックX方向スクロール4bitページ2
   452:   public static final int CRT_R17_GR_Y_2      = 0x00e80022;  //R17  bit8-0   グラフィックY方向スクロール4bitページ2
   453:   public static final int CRT_R18_GR_X_3      = 0x00e80024;  //R18  bit8-0   グラフィックX方向スクロール4bitページ3
   454:   public static final int CRT_R19_GR_Y_3      = 0x00e80026;  //R19  bit8-0   グラフィックY方向スクロール4bitページ3
   455:   public static final int CRT_R20_MODE        = 0x00e80028;  //R20  bit12    テキストストレージ
   456:   //                                                                bit11    グラフィックストレージ
   457:   //                                                                bit10-8  メモリモード  0=512ドット16色
   458:   //                                                                                       1=512ドット256色
   459:   //                                                                                       2=メモリモード2
   460:   //                                                                                       3=512ドット65536色
   461:   //                                                                                       4=1024ドット16色
   462:   //                                                                                       5=1024ドット16色/1024ドット256色(拡張)
   463:   //                                                                                       6=1024ドット16色
   464:   //                                                                                       7=1024ドット16色/1024ドット65536色(拡張)
   465:   //                                                                bit4     解像度  0=低解像度,1=高解像度
   466:   //                                                                bit3-2   垂直解像度  0=256(ラスタ2度読み),1=512,2=1024,3=1024
   467:   //                                                                bit1-0   水平解像度  0=256,1=512,2=768,3=640
   468:   public static final int CRT_R21_SELECT      = 0x00e8002a;  //R21  bit9     1=ビットマスクON
   469:   //                                                                bit8     1=同時アクセスON
   470:   //                                                                bit7     1=プレーン3を同時アクセスする
   471:   //                                                                bit6     1=プレーン2を同時アクセスする
   472:   //                                                                bit5     1=プレーン1を同時アクセスする
   473:   //                                                                bit4     1=プレーン0を同時アクセスする
   474:   //                                                                bit3     1=プレーン3をラスタコピー/高速クリアする
   475:   //                                                                bit2     1=プレーン2をラスタコピー/高速クリアする
   476:   //                                                                bit1     1=プレーン1をラスタコピー/高速クリアする
   477:   //                                                                bit0     1=プレーン0をラスタコピー/高速クリアする
   478:   public static final int CRT_R22_BLOCK       = 0x00e8002c;  //R22  bit15-8  0~255 ソースラスタブロック番号
   479:   //                                                                bit7-0   0~255 デスティネーションラスタブロック番号
   480:   public static final int CRT_R23_MASK        = 0x00e8002e;  //R23  bit15-0  ビットマスク。1のビットに書き込まない
   481:   public static final int CRT_R24             = 0x00e80030;  //R24
   482:   public static final int CRT_ACTION          = 0x00e80480;  //動作ポート  bit0  1=画像入力開始
   483:   //                                                                       bit1  1=次の垂直表示開始で高速クリア開始
   484:   //                                                                       bit3  1=ラスタコピー実行
   485: 
   486:   //ドットクロックオシレータ
   487:   //  int k = crtHRLCurr << 3 | crtHighResoCurr << 2 | crtHResoCurr;
   488:   //  crtColumnTime = (int) ((double) (XEiJ.TMR_FREQ * 8 * CRT_DIVS[k]) / (double) crtFreqs[CRT_OSCS[k]] + 0.5);
   489:   //  10**12/(4*10**6)*8*1024=2048000000。4MHzを下回ると8分周で1024ドットの水平映像期間がintに収まらなくなる
   490:   public static final int[] CRT_OSCS = { 0, 0, 0, 0, 1, 1, 1, 2, 0, 0, 0, 0, 1, 1, 1, 2 };  //HRLR20410→オシレータの番号
   491:   public static final int[] CRT_DIVS = { 8, 4, 8, 8, 6, 3, 2, 2, 8, 4, 8, 8, 8, 4, 2, 2 };  //HRLR20410→分周比
   492:   public static final int CRT_MIN_FREQ =  10000000;  //オシレータの周波数の下限(Hz)
   493:   public static final int CRT_MAX_FREQ = 400000000;  //オシレータの周波数の上限(Hz)
   494:   public static final int[] CRT_DEFAULT_FREQS = { 38863632, 69551900, 50349800 };  //デフォルトのオシレータの周波数(Hz)
   495:   public static final int[] crtFreqsRequest = new int[3];  //リセット後のオシレータの周波数(Hz)
   496:   public static final int[] crtFreqs = new int[3];  //現在のオシレータの周波数(Hz)
   497: 
   498:   //レジスタ
   499:   //  ゼロ拡張
   500:   public static int crtR00HFrontEndPort;                 //R00 7-0 水平フロントポーチ終了カラム
   501:   public static int crtR00HFrontEndMask;
   502:   public static int crtR00HFrontEndTest;
   503:   public static int crtR00HFrontEndCurr;
   504:   public static int crtR01HSyncEndPort;                  //R01 7-0 水平同期パルス終了カラム
   505:   public static int crtR01HSyncEndMask;
   506:   public static int crtR01HSyncEndTest;
   507:   public static int crtR01HSyncEndCurr;
   508:   public static int crtR02HBackEndPort;                  //R02 7-0 水平バックポーチ終了カラム
   509:   public static int crtR02HBackEndMask;
   510:   public static int crtR02HBackEndTest;
   511:   public static int crtR02HBackEndCurr;
   512:   public static int crtR03HDispEndPort;                  //R03 7-0 水平映像期間終了カラム
   513:   public static int crtR03HDispEndMask;
   514:   public static int crtR03HDispEndTest;
   515:   public static int crtR03HDispEndCurr;
   516:   public static int crtR04VFrontEndPort;                 //R04 9-0 垂直フロントポーチ終了ラスタ
   517:   public static int crtR04VFrontEndMask;
   518:   public static int crtR04VFrontEndTest;
   519:   public static int crtR04VFrontEndCurr;
   520:   public static int crtR05VSyncEndPort;                  //R05 9-0 垂直同期パルス終了ラスタ
   521:   public static int crtR05VSyncEndMask;
   522:   public static int crtR05VSyncEndTest;
   523:   public static int crtR05VSyncEndCurr;
   524:   public static int crtR06VBackEndPort;                  //R06 9-0 垂直バックポーチ終了ラスタ
   525:   public static int crtR06VBackEndMask;
   526:   public static int crtR06VBackEndTest;
   527:   public static int crtR06VBackEndCurr;
   528:   public static int crtVDispStart;                       //        垂直映像期間開始ラスタ。crtR06VBackEndCurr+1
   529:   public static int crtR07VDispEndPort;                  //R07 9-0 垂直映像期間終了ラスタ
   530:   public static int crtR07VDispEndMask;
   531:   public static int crtR07VDispEndTest;
   532:   public static int crtR07VDispEndCurr;
   533:   public static int crtVIdleStart;                       //        垂直空白期間開始ラスタ。crtR07VDispEndCurr+1
   534:   public static int crtR08Adjust;                        //R08 7-0 外部同期水平アジャスト
   535:   public static int crtR09IRQRasterPort;                 //R09 9-0 IRQラスタ。0=垂直同期パルス開始ラスタ
   536:   public static int crtR09IRQRasterMask;
   537:   public static int crtR09IRQRasterTest;
   538:   public static int crtR09IRQRasterCurr;
   539:   public static int crtR10TxXPort;                       //R10 9-0 テキストX方向スクロール
   540:   public static int crtR10TxXMask;
   541:   public static int crtR10TxXTest;
   542:   public static int crtR10TxXCurr;
   543:   public static int crtR11TxYPort;                       //R11 9-0 テキストY方向スクロール
   544:   public static int crtR11TxYMask;
   545:   public static int crtR11TxYTest;
   546:   public static int crtR11TxYCurr;
   547:   public static int crtR11TxYZero;                       //垂直映像期間開始時のテキストY方向スクロール
   548:   public static int crtR11TxYZeroLast;
   549:   public static final int[] crtR12GrXPort = new int[4];  //[0] R12 9-0 グラフィックX方向スクロール0
   550:   //                                                       [1] R14 8-0 グラフィックX方向スクロール1
   551:   //                                                       [2] R16 8-0 グラフィックX方向スクロール2
   552:   //                                                       [3] R18 8-0 グラフィックX方向スクロール3
   553:   public static final int[] crtR12GrXMask = new int[4];
   554:   public static final int[] crtR12GrXTest = new int[4];
   555:   public static final int[] crtR12GrXCurr = new int[4];
   556:   public static final int[] crtR13GrYPort = new int[4];  //[0] R13 9-0 グラフィックY方向スクロール0
   557:   //                                                       [1] R15 8-0 グラフィックY方向スクロール1
   558:   //                                                       [2] R17 8-0 グラフィックY方向スクロール2
   559:   //                                                       [3] R19 8-0 グラフィックY方向スクロール3
   560:   public static final int[] crtR13GrYMask = new int[4];
   561:   public static final int[] crtR13GrYTest = new int[4];
   562:   public static final int[] crtR13GrYCurr = new int[4];
   563:   public static final int[] crtR13GrYZero = new int[4];  //垂直映像期間開始時のグラフィックY方向スクロール
   564:   public static final int[] crtR13GrYZeroLast = new int[4];
   565:   public static int crtTextStorage;                      //R20 12 テキストストレージ 0=OFF,1=ON
   566:   public static int crtGraphicStorage;                   //R20 11 グラフィックストレージ 0=OFF,1=ON
   567:   public static int crtMemoryModePort;                   //R20 10-8 0=512ドット16色,1=512ドット256色,3=512ドット65536色,4=1024ドット16色,5=1024ドット256色(拡張),7=1024ドット65536色(拡張)
   568:   public static int crtMemoryModeMask;
   569:   public static int crtMemoryModeTest;
   570:   public static int crtMemoryModeCurr;
   571:   public static int crtHighResoPort;                     //R20 4    0=低解像度,1=高解像度
   572:   public static int crtHighResoMask;
   573:   public static int crtHighResoTest;
   574:   public static int crtHighResoCurr;
   575:   public static int crtVResoPort;                        //R20 3-2  垂直解像度
   576:   public static int crtVResoMask;
   577:   public static int crtVResoTest;
   578:   public static int crtVResoCurr;
   579:   public static int crtHResoPort;                        //R20 1-0  水平解像度
   580:   public static int crtHResoMask;
   581:   public static int crtHResoTest;
   582:   public static int crtHResoCurr;
   583:   public static boolean crtCCPlane0;                     //R21 0 true=プレーン0をラスタコピー/高速クリアする
   584:   public static boolean crtCCPlane1;                     //    1 true=プレーン1をラスタコピー/高速クリアする
   585:   public static boolean crtCCPlane2;                     //    2 true=プレーン2をラスタコピー/高速クリアする
   586:   public static boolean crtCCPlane3;                     //    3 true=プレーン3をラスタコピー/高速クリアする
   587:   public static boolean crtSimPlane0;                    //    4 true=プレーン0を同時アクセスする
   588:   public static boolean crtSimPlane1;                    //    5 true=プレーン1を同時アクセスする
   589:   public static boolean crtSimPlane2;                    //    6 true=プレーン2を同時アクセスする
   590:   public static boolean crtSimPlane3;                    //    7 true=プレーン3を同時アクセスする
   591:   public static boolean crtSimAccess;                    //    8 true=同時アクセス有効
   592:   public static boolean crtBitMask;                      //    9 true=ビットマスク有効
   593:   public static int crtR22SrcBlock;                      //R22 15-8 ソースラスタブロック番号
   594:   public static int crtR22DstBlock;                      //    7-0  デスティネーションラスタブロック番号
   595:   public static int crtR23Mask;                          //R23 15-0 ビットマスク。1のビットに書き込まない
   596:   public static boolean crtRasterCopyOn;                 //動作ポート 2        true=次の水平フロントポーチでラスタコピー実行
   597:   public static boolean crtClearStandby;                 //動作ポート 1(write) true=次の垂直表示開始で高速クリア開始
   598:   public static int crtClearFrames;                      //  実行中の高速クリアの残りフレーム数。インターレースのとき2、それ以外は1から始めてデクリメントする
   599: 
   600:   public static int crtHRLPort;  //0または1。1のとき69.552MHzの3分周と6分周が4分周と8分周に変わる
   601:   public static int crtHRLMask;
   602:   public static int crtHRLTest;
   603:   public static int crtHRLCurr;
   604: 
   605:   public static boolean crtDuplication;  //true=ラスタ2度読み。crtHighResoCurr==1&&crtVResoCurr==0&&((SpriteScreen.sprReg8ResoCurr&12)!=4)
   606:   public static boolean crtInterlace;  //true=インターレース。crtHighResoCurr+1<=crtVResoCurr
   607:   public static boolean crtSlit;  //true=スリット。crtHighResoCurr==0&&crtVResoCurr==0
   608:   public static boolean crtDupExceptSp;  //true=ラスタ2度読み(スプライトを除く)。crtHighResoCurr==1&&crtVResoCurr==0&&((SpriteScreen.sprReg8ResoCurr&12)==4)
   609:   public static int crtHSyncColumn;  //水平同期パルスカラム数(修正後)
   610:   public static int crtHBackColumn;  //水平バックポーチカラム数(修正後)
   611:   public static int crtHDispColumn;  //水平映像期間カラム数(修正後)
   612:   public static int crtHFrontColumn;  //水平フロントポーチカラム数(修正後)
   613:   public static int crtHTotalColumn;  //水平トータルカラム数(修正後)
   614:   public static double crtVsyncMultiplier;  //垂直同期周波数に掛ける数
   615:   public static int crtColumnTime;  //水平カラム時間(XEiJ.TMR_FREQ単位)
   616:   public static int crtHSyncLength;  //水平同期パルスの長さ(XEiJ.TMR_FREQ単位)。crtColumnTime*(crtR01HSyncEndCurr+1)
   617:   public static int crtHBackLength;  //水平バックポーチの長さ(XEiJ.TMR_FREQ単位)。crtColumnTime*(crtR02HBackEndCurr-crtR01HSyncEndCurr)
   618:   public static int crtHDispLength;  //水平映像期間の長さ(XEiJ.TMR_FREQ単位)。crtColumnTime*(crtR03HDispEndCurr-crtR02HBackEndCurr)
   619:   public static int crtHFrontLength;  //水平フロントポーチの長さ(XEiJ.TMR_FREQ単位)。crtColumnTime*(crtR00HFrontEndCurr-crtR03HDispEndCurr)
   620:   public static int crtHBackDispLength;  //水平バックポーチと水平映像期間の長さ(XEiJ.TMR_FREQ単位)。crtColumnTime*(crtR03HDispEndCurr-crtR01HSyncEndCurr)
   621:   public static long crtTotalLength;  //垂直周期(ミリ)。0=未確定
   622:   public static long crtTotalLengthMNP;  //垂直周期(マイクロナノピコ)。0=未確定
   623: 
   624:   //  描画のルール
   625:   //    更新されていないラスタのビットマップへの変換を省略する
   626:   //    更新されたラスタを含む矩形をクリッピングエリアとしてペイントする
   627:   //    更新されたラスタは水平映像期間に入った瞬間に1ラスタ分変換する
   628:   //      水平映像期間の途中でパレットレジスタやスクロールレジスタを操作してもそのラスタには反映されない
   629:   //        768x512で256色の画面は作れない
   630:   //      スプライト画面も水平バックポーチが終わる前に書き換えればそのラスタに反映される
   631:   //  更新されたラスタだけを描画する手順
   632:   //    初期化
   633:   //      crtAllStamp=1。2ずつ増やすので0になることはない
   634:   //      for all y
   635:   //        crtRasterStamp[y]=0
   636:   //    画面モードが変更されたりスクロールレジスタやパレットレジスタが操作されて画面の全体が変化した可能性があるとき
   637:   //      crtAllStamp+=2。常に奇数
   638:   //    VRAMやスプライトレジスタが操作されて画面の一部が変化した可能性があるとき
   639:   //      crtRasterStamp[y]=0
   640:   //    垂直映像期間開始ラスタに入るとき
   641:   //      crtDirtyY0=-1。更新なし
   642:   //      crtScreenY=0
   643:   //    描画フレームの垂直映像期間の水平映像期間に入ったとき
   644:   //      crtRasterStamp[crtScreenY]!=crtAllStamp。再描画が必要
   645:   //        crtRasterStamp[crtScreenY]=crtAllStamp
   646:   //        crtDirtyY0<0
   647:   //          crtDirtyY0=crtScreenY。更新あり
   648:   //        crtDirtyY1=crtScreenY
   649:   //        drawRaster(crtScreenY)
   650:   //      crtScreenY++
   651:   //    垂直映像期間終了ラスタから出たとき
   652:   //      crtDirtyY0>=0。更新されたとき
   653:   //        crtDirtyY0からcrtDirtyY1までをrepaintする
   654:   public static int crtDirtyY0;  //垂直映像期間にビットマップが更新された範囲の上端のスクリーンY座標。-1=更新されていない
   655:   public static int crtDirtyY1;  //垂直映像期間にビットマップが更新された範囲の下端のスクリーンY座標。更新された範囲の高さはcrtDirtyY1-crtDirtyY0+1
   656: 
   657:   public static final int[] crtRasterStamp = new int[1024 + 15];  //ラスタスタンプ。0=VRAMが操作されてこのラスタを再描画する必要がある
   658:   public static int crtAllStamp;  //全再描画スタンプ
   659: 
   660:   //  768x512ドット256色
   661:   //    作り方
   662:   //      画面モードを768x512ドットにしてグラフィック画面だけ512x512ドット256色にする
   663:   //      512x512ドット256色ページ0に768x512ドット256色の画像の左1/3と中央1/3を描く
   664:   //      512x512ドット256色ページ1に768x512ドット256色の画像の右1/3と中央1/3を描く
   665:   //      0<=y<=511のすべてのラスタについて
   666:   //        256<=x<=511でページ0をOFF、ページ1をON、768<=xでページ0をON、ページ1をOFFにする
   667:   //        256<=x<=511の範囲はページ0とページ1の両方に画像が描かれているのでどこで切り替えてもよいが、
   668:   //        10MHzのとき256<=x<=511の期間は73サイクル、NOP命令18個分しかないので、かなりシビアな処理になる
   669:   //        (768x512ドットの画面は69.552MHzを2分周して作られるので28.755ns/dot)
   670:   //    方針
   671:   //      描画する必要のないラスタをラスタスタンプと全再描画スタンプが一致するかどうかで見分けているが、
   672:   //      この全再描画スタンプを流用する
   673:   //      水平映像期間開始時から終了時までの間に全再描画スタンプが変化したとき、
   674:   //      水平映像期間終了時にラスタの後半を再描画する
   675:   //      分割する必要がないときのオーバーヘッドをなるべく減らす
   676:   //        分割する必要がないときの1ラスタあたりのオーバーヘッド
   677:   //          static変数のコピーが1回
   678:   //          static変数同士の比較が2回
   679:   //          if分岐が2回
   680:   //    手順
   681:   //      水平映像期間開始時
   682:   //        いろいろ
   683:   //        crtBeginningAllStamp=crtAllStamp;
   684:   //        ラスタ描画(src,dst);
   685:   //      水平映像期間終了時
   686:   //        if crtBeginningAllStamp!=crtAllStamp;
   687:   //          ラスタ描画(src,dst);
   688:   //        ラスタ番号++
   689:   //        いろいろ
   690:   //      ラスタ描画(src,dst);
   691:   //        int da=dst<<XEiJ.PNL_BM_OFFSET_BITS;
   692:   //        int db=da+XEiJ.pnlScreenWidth;
   693:   //        if crtBeginningAllStamp!=crtAllStamp
   694:   //          int half=XEiJ.pnlScreenWidth>>4<<3;
   695:   //          sx+=half;
   696:   //          gx1st+=half<<1;
   697:   //          gx2nd+=half<<1;
   698:   //          gx3rd+=half<<1;
   699:   //          gx4th+=half<<1;
   700:   //          tc=tc+(half>>3)&127;
   701:   //          gx+=half;
   702:   //          da+=half;
   703:   //    参考
   704:   //      https://twitter.com/kugimoto0715/status/800231367699116032
   705:   //      ArimacさんのBMPL.X/LPICL.Xの添付ドキュメントX256.DOC
   706:   public static int crtBeginningAllStamp;  //水平映像期間開始時の全再描画スタンプ
   707: 
   708:   public static int crtRasterNumber;  //ラスタ番号。0=垂直同期パルス開始ラスタ
   709:   public static int crtDataY;  //データY座標
   710:   public static int crtScreenY;  //スクリーンY座標
   711:   public static int crtFrameParity;  //フレームパリティ
   712: 
   713:   //  水平フロントポーチでアクションを起こすべきラスタかどうかの判別を高速化する
   714:   //  垂直空白期間
   715:   //  crtRasterHashIdle = ((crtRasterCopyOn ? ~CRT_RASTER_HASH_ZERO : CRT_RASTER_HASH_ZERO) |
   716:   //                       (RasterBreakPoint.RBP_ON && RasterBreakPoint.rbpActiveBreakRaster >= 0 ?
   717:   //                        CRT_RASTER_HASH_MSB >>> RasterBreakPoint.rbpActiveBreakRaster : CRT_RASTER_HASH_ZERO) |
   718:   //                       (crtR09IRQRasterCurr <= crtR04VFrontEndCurr ?
   719:   //                        CRT_RASTER_HASH_MSB >>> crtR09IRQRasterCurr |
   720:   //                        CRT_RASTER_HASH_MSB >>> (crtR09IRQRasterCurr < crtR04VFrontEndCurr ? crtR09IRQRasterCurr + 1 : 0) :
   721:   //                        CRT_RASTER_HASH_ZERO);
   722:   //                       CRT_RASTER_HASH_MSB >>> crtVDispStart |
   723:   //                       CRT_RASTER_HASH_MSB >>> crtR04VFrontEndCurr + 1);
   724:   //  垂直映像期間
   725:   //  crtRasterHashDisp = ((crtRasterCopyOn ? ~CRT_RASTER_HASH_ZERO : CRT_RASTER_HASH_ZERO) |
   726:   //                       (RasterBreakPoint.RBP_ON && RasterBreakPoint.rbpActiveBreakRaster >= 0 ?
   727:   //                        CRT_RASTER_HASH_MSB >>> RasterBreakPoint.rbpActiveBreakRaster : CRT_RASTER_HASH_ZERO) |
   728:   //                       (crtR09IRQRasterCurr <= crtR04VFrontEndCurr ?
   729:   //                        CRT_RASTER_HASH_MSB >>> crtR09IRQRasterCurr |
   730:   //                        CRT_RASTER_HASH_MSB >>> (crtR09IRQRasterCurr < crtR04VFrontEndCurr ? crtR09IRQRasterCurr + 1 : 0) :
   731:   //                        CRT_RASTER_HASH_ZERO);
   732:   //                       CRT_RASTER_HASH_MSB >>> crtVIdleStart);
   733:   public static final boolean CRT_RASTER_HASH_ON = true;
   734:   public static final long CRT_RASTER_HASH_ZERO = 0x0000000000000000L;  //crtRasterHashと同じ型の0
   735:   public static final long CRT_RASTER_HASH_MSB  = 0x8000000000000000L;  //crtRasterHashと同じ型のMSBだけセットした値
   736:   public static long crtRasterHashIdle;  //垂直空白期間。intまたはlong
   737:   public static long crtRasterHashDisp;  //垂直映像期間。intまたはlong
   738:   //public static final int CRT_RASTER_HASH_ZERO = 0x00000000;  //crtRasterHashと同じ型の0
   739:   //public static final int CRT_RASTER_HASH_MSB  = 0x80000000;  //crtRasterHashと同じ型のMSBだけセットした値
   740:   //public static int crtRasterHashIdle;  //垂直空白期間。intまたはlong
   741:   //public static int crtRasterHashDisp;  //垂直映像期間。intまたはlong
   742: 
   743:   public static TickerQueue.Ticker crtTicker;
   744:   public static long crtClock;
   745: 
   746:   public static long crtContrastClock;  //次にコントラストを変更する時刻
   747:   public static long crtCaptureClock;  //次に画面をキャプチャする時刻
   748:   public static long crtFrameTaskClock;  //Math.min(crtContrastClock,crtCaptureClock)
   749: 
   750:   //間欠描画
   751:   //  描画するフレームの間隔を空けることで描画の負荷を減らす
   752:   //  間欠間隔 interval>=0
   753:   //    interval=0    デフォルト。すべてのフレームが描画フレーム
   754:   //    interval=1..  描画フレームの後の少なくともintervalフレームを省略フレームとすることで描画フレームの割合を1/(interval+1)以下に抑える
   755:   //                  インターレースの場合は間欠間隔を偶数に切り上げることで偶数フレームと奇数フレームが交互に更新されるようにする
   756:   //  間欠カウンタ counter>=0
   757:   //    counter=0     描画フレーム。画面が更新されたときは描画するフレーム
   758:   //    counter=1~n  省略フレーム。常に描画しないフレーム
   759:   //  描画フレームの垂直映像期間の水平映像期間に入ったとき
   760:   //    ラスタが更新されたとき
   761:   //      描画フレーム(counter==0)のとき
   762:   //        画面の合成と16bit→32bitの変換を行う
   763:   //        更新されたラスタの範囲を記録する
   764:   //      省略フレーム(counter!=0)のとき
   765:   //        何もしない
   766:   //  垂直映像期間終了ラスタから出たとき
   767:   //    描画フレーム(counter==0)のとき
   768:   //      更新されたラスタがあったとき
   769:   //        更新されたラスタの範囲を描画する
   770:   //        counter=interval
   771:   //      更新されたラスタがなかったとき
   772:   //        何もしない
   773:   //    省略フレーム(counter!=0)のとき
   774:   //      counter--
   775:   //!!! XEiJ.PNL_USE_THREADとCRTC.CRT_ENABLE_INTERMITTENTを同時にtrueにしないこと
   776:   public static final boolean CRT_ENABLE_INTERMITTENT = false;  //true=間欠描画を有効にする
   777:   public static int crtIntermittentInterval;  //間欠間隔。描画フレームの間に挟む省略フレームの数の下限
   778:   public static int crtIntermittentCounter;  //間欠カウンタ。0=描画フレーム,1..interval=省略フレーム
   779: 
   780:   //走査線エフェクト
   781:   enum ScanlineEffect {
   782:     OFF {  //なし。そのままコピー
   783:       @Override public void drawRaster (int screenY) {
   784:         int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
   785:         System.arraycopy (XEiJ.pnlBM, da - XEiJ.PNL_BM_WIDTH,  //from
   786:                           XEiJ.pnlBM, da,  //to
   787:                           XEiJ.pnlScreenWidth);  //length
   788:       }
   789:     },
   790:     WEAK {  //弱。7/8倍してコピー
   791:       @Override public void drawRaster (int screenY) {
   792:         int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
   793:         int db = da + XEiJ.pnlScreenWidth;
   794:         while (da < db) {
   795:           int t;
   796:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH    )];
   797:           XEiJ.pnlBM[da    ] = t - ((t >> 3) & 0x001f1f1f);
   798:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 1)];
   799:           XEiJ.pnlBM[da + 1] = t - ((t >> 3) & 0x001f1f1f);
   800:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 2)];
   801:           XEiJ.pnlBM[da + 2] = t - ((t >> 3) & 0x001f1f1f);
   802:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 3)];
   803:           XEiJ.pnlBM[da + 3] = t - ((t >> 3) & 0x001f1f1f);
   804:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 4)];
   805:           XEiJ.pnlBM[da + 4] = t - ((t >> 3) & 0x001f1f1f);
   806:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 5)];
   807:           XEiJ.pnlBM[da + 5] = t - ((t >> 3) & 0x001f1f1f);
   808:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 6)];
   809:           XEiJ.pnlBM[da + 6] = t - ((t >> 3) & 0x001f1f1f);
   810:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 7)];
   811:           XEiJ.pnlBM[da + 7] = t - ((t >> 3) & 0x001f1f1f);
   812:           da += 8;
   813:         }
   814:       }
   815:     },
   816:     MEDIUM {  //中。3/4倍してコピー
   817:       @Override public void drawRaster (int screenY) {
   818:         int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
   819:         int db = da + XEiJ.pnlScreenWidth;
   820:         while (da < db) {
   821:           int t;
   822:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH    )];
   823:           XEiJ.pnlBM[da    ] = t - ((t >> 2) & 0x003f3f3f);
   824:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 1)];
   825:           XEiJ.pnlBM[da + 1] = t - ((t >> 2) & 0x003f3f3f);
   826:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 2)];
   827:           XEiJ.pnlBM[da + 2] = t - ((t >> 2) & 0x003f3f3f);
   828:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 3)];
   829:           XEiJ.pnlBM[da + 3] = t - ((t >> 2) & 0x003f3f3f);
   830:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 4)];
   831:           XEiJ.pnlBM[da + 4] = t - ((t >> 2) & 0x003f3f3f);
   832:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 5)];
   833:           XEiJ.pnlBM[da + 5] = t - ((t >> 2) & 0x003f3f3f);
   834:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 6)];
   835:           XEiJ.pnlBM[da + 6] = t - ((t >> 2) & 0x003f3f3f);
   836:           t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 7)];
   837:           XEiJ.pnlBM[da + 7] = t - ((t >> 2) & 0x003f3f3f);
   838:           da += 8;
   839:         }
   840:       }
   841:     },
   842:     STRONG {  //強。1/2倍してコピー
   843:       @Override public void drawRaster (int screenY) {
   844:         int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
   845:         int db = da + XEiJ.pnlScreenWidth;
   846:         while (da < db) {
   847:           XEiJ.pnlBM[da    ] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH    )] >> 1) & 0xff7f7f7f;
   848:           XEiJ.pnlBM[da + 1] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 1)] >> 1) & 0xff7f7f7f;
   849:           XEiJ.pnlBM[da + 2] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 2)] >> 1) & 0xff7f7f7f;
   850:           XEiJ.pnlBM[da + 3] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 3)] >> 1) & 0xff7f7f7f;
   851:           XEiJ.pnlBM[da + 4] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 4)] >> 1) & 0xff7f7f7f;
   852:           XEiJ.pnlBM[da + 5] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 5)] >> 1) & 0xff7f7f7f;
   853:           XEiJ.pnlBM[da + 6] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 6)] >> 1) & 0xff7f7f7f;
   854:           XEiJ.pnlBM[da + 7] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 7)] >> 1) & 0xff7f7f7f;
   855:           da += 8;
   856:         }
   857:       }
   858:     },
   859:     BLACK {  //黒
   860:       @Override public void drawRaster (int screenY) {
   861:         int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
   862:         int db = da + XEiJ.pnlScreenWidth;
   863:         Arrays.fill (XEiJ.pnlBM,  //array
   864:                      da,  //from
   865:                      db,  //to
   866:                      0xff000000);  //value
   867:       }
   868:     };
   869:     public abstract void drawRaster (int screenY);
   870:   }  //enum ScanlineEffect
   871:   public static ScanlineEffect crtScanlineEffect;
   872: 
   873:   //1024ドットノンインターレース
   874:   //  R04/R05/R06/R07/R09の幅を10ビットから11ビットに拡張する
   875:   //  垂直映像期間のラスタ数R07-R06が1024を超えてはならない
   876:   public static boolean crtEleventhBitRequest;
   877:   public static boolean crtEleventhBit;
   878:   public static int crtVerticalMask;  //0x03ffまたは0x07ff
   879: 
   880:   //テキスト画面のスクロール
   881:   //  グラフィック画面は球面スクロールでデータのアドレスが1ラスタ毎にループするが、
   882:   //  テキスト画面は円筒スクロールでデータのアドレスが4ラスタ(=1ラスタブロック)毎にループするので、
   883:   //  X方向のスクロール位置に範囲外の値を指定すると画面が乱れる
   884:   //  改造メニューで球面スクロールを選択できる
   885:   public static boolean crtSphericalScrolling;  //false=円筒スクロール,true=球面スクロール
   886:   public static int crtMask3;
   887:   public static int crtMaskMinus4;
   888:   public static int crtMask511;
   889:   public static void crtSetSphericalScrolling (boolean spherical) {
   890:     crtSphericalScrolling = spherical;
   891:     crtMask3 = spherical ? 0 : 3;  //0:3
   892:     crtMaskMinus4 = ~crtMask3;  //-1:-4
   893:     crtMask511 = crtMask3 << 7 | 127;  //127:511
   894:     crtAllStamp += 2;
   895:   }
   896: 
   897:   //CRTC R00のビット0
   898:   public static boolean crtR00Bit0Zero;  //false=1に固定する,true=0を書き込める
   899: 
   900:   //crtInit ()
   901:   //  CRTコントローラを初期化する
   902:   public static void crtInit () {
   903:     //if (CRT_EXTENDED_GRAPHIC) {
   904:     //  crtExtendedGraphicRequest = false;
   905:     //}
   906:     //crtR12GrXPort = new int[4];
   907:     //crtR12GrXMask = new int[4];
   908:     //crtR12GrXTest = new int[4];
   909:     //crtR12GrXCurr = new int[4];
   910:     //crtR13GrYPort = new int[4];
   911:     //crtR13GrYMask = new int[4];
   912:     //crtR13GrYTest = new int[4];
   913:     //crtR13GrYCurr = new int[4];
   914:     //crtR13GrYZero = new int[4];
   915:     //crtR13GrYZeroLast = new int[4];
   916:     //crtRasterStamp = new int[1024 + 15];  //1024以降はスプライトコントローラが更新してしまうので追加したダミー
   917: 
   918:     //走査線エフェクト
   919:     switch (Settings.sgsGetString ("scanline").toLowerCase ()) {
   920:     case "off":
   921:       crtScanlineEffect = ScanlineEffect.OFF;
   922:       break;
   923:     case "weak":
   924:       crtScanlineEffect = ScanlineEffect.WEAK;
   925:       break;
   926:     case "medium":
   927:       crtScanlineEffect = ScanlineEffect.MEDIUM;
   928:       break;
   929:     case "strong":
   930:       crtScanlineEffect = ScanlineEffect.STRONG;
   931:       break;
   932:     case "black":
   933:       crtScanlineEffect = ScanlineEffect.BLACK;
   934:       break;
   935:     }
   936: 
   937:     //ドットクロックオシレータ
   938:     {
   939:       String[] a = (Settings.sgsGetString ("dotclock") + ",,,0").split (",");
   940:       for (int i = 0; i < 3; i++) {
   941:         int freq = -1;
   942:         try {
   943:           freq = Integer.parseInt (a[i], 10);
   944:         } catch (NumberFormatException nfe) {
   945:         }
   946:         crtFreqsRequest[i] = CRT_MIN_FREQ <= freq && freq <= CRT_MAX_FREQ ? freq : CRT_DEFAULT_FREQS[i];
   947:       }
   948:     }
   949: 
   950:     //1024ドットノンインターレース
   951:     crtEleventhBitRequest = Settings.sgsGetOnOff ("eleventhbit");
   952: 
   953:     //テキスト画面のスクロール
   954:     crtSphericalScrolling = Settings.sgsGetOnOff ("sphericalscrolling");
   955:     crtMask3 = 3;
   956:     crtMaskMinus4 = -4;
   957:     crtMask511 = 511;
   958: 
   959:     //CRTC R00のビット0
   960:     crtR00Bit0Zero = Settings.sgsGetOnOff ("r00bit0zero");
   961: 
   962:     if (true) {
   963:       crtCCPlane0 = false;
   964:       crtCCPlane1 = false;
   965:       crtCCPlane2 = false;
   966:       crtCCPlane3 = false;
   967:       crtSimPlane0 = false;
   968:       crtSimPlane1 = false;
   969:       crtSimPlane2 = false;
   970:       crtSimPlane3 = false;
   971:       crtSimAccess = false;
   972:       crtBitMask = false;
   973:     }
   974:     crtReset ();
   975:   }  //crtInit()
   976: 
   977:   //crtTini ()
   978:   //  後始末
   979:   public static void crtTini () {
   980: 
   981:     //走査線エフェクト
   982:     Settings.sgsPutString ("scanline",
   983:                            crtScanlineEffect == ScanlineEffect.OFF ? "off" :
   984:                            crtScanlineEffect == ScanlineEffect.WEAK ? "weak" :
   985:                            crtScanlineEffect == ScanlineEffect.MEDIUM ? "medium" :
   986:                            crtScanlineEffect == ScanlineEffect.STRONG ? "strong" :
   987:                            crtScanlineEffect == ScanlineEffect.BLACK ? "black" :
   988:                            "");
   989: 
   990:     //ドットクロックオシレータ
   991:     {
   992:       StringBuilder sb = new StringBuilder ();
   993:       for (int i = 0; i < 3; i++) {
   994:         if (0 < i) {
   995:           sb.append (',');
   996:         }
   997:         if (crtFreqsRequest[i] != CRT_DEFAULT_FREQS[i]) {
   998:           sb.append (crtFreqsRequest[i]);
   999:         }
  1000:       }
  1001:       Settings.sgsPutString ("dotclock", sb.toString ());
  1002:     }
  1003: 
  1004:     //1024ドットノンインターレース
  1005:     Settings.sgsPutOnOff ("eleventhbit", crtEleventhBitRequest);
  1006: 
  1007:     //テキスト画面のスクロール
  1008:     Settings.sgsPutOnOff ("sphericalscrolling", crtSphericalScrolling);
  1009: 
  1010:     //CRTC R00のビット0
  1011:     Settings.sgsPutOnOff ("r00bit0zero", crtR00Bit0Zero);
  1012: 
  1013:   }  //crtTini
  1014: 
  1015:   //crtReset ()
  1016:   //  リセット
  1017:   //  CRTCのレジスタを初期化する
  1018:   //  レジスタが設定されてCRT_RESTART_DELAYが経過するまでCRTCの動作を停止する
  1019:   //  以下で呼び出される
  1020:   //    初期化
  1021:   //    MPUのreset命令
  1022:   public static void crtReset () {
  1023:     if (CRT_EXTENDED_GRAPHIC) {
  1024:       crtExtendedGraphicOn = crtExtendedGraphicRequest;
  1025:       if (crtExtendedGraphicOn) {
  1026:         System.out.println (Multilingual.mlnJapanese ?
  1027:                             "拡張グラフィック画面が有効になりました" :
  1028:                             "Extended graphic screen has been activated");
  1029:       }
  1030:     }
  1031: 
  1032:     //ドットクロックオシレータ
  1033:     for (int i = 0; i < 3; i++) {
  1034:       crtFreqs[i] = crtFreqsRequest[i];
  1035:     }
  1036: 
  1037:     //1024ドットノンインターレース
  1038:     crtEleventhBit = crtEleventhBitRequest;
  1039:     crtVerticalMask = crtEleventhBit ? 0x07ff : 0x03ff;
  1040: 
  1041:     crtR00HFrontEndPort = 0;
  1042:     crtR00HFrontEndMask = 0;
  1043:     crtR00HFrontEndTest = 0;
  1044:     crtR00HFrontEndCurr = 0;
  1045:     crtR01HSyncEndPort = 0;
  1046:     crtR01HSyncEndMask = 0;
  1047:     crtR01HSyncEndTest = 0;
  1048:     crtR01HSyncEndCurr = 0;
  1049:     crtR02HBackEndPort = 0;
  1050:     crtR02HBackEndMask = 0;
  1051:     crtR02HBackEndTest = 0;
  1052:     crtR02HBackEndCurr = 0;
  1053:     crtR03HDispEndPort = 0;
  1054:     crtR03HDispEndMask = 0;
  1055:     crtR03HDispEndTest = 0;
  1056:     crtR03HDispEndCurr = 0;
  1057:     crtR04VFrontEndPort = 0;
  1058:     crtR04VFrontEndMask = 0;
  1059:     crtR04VFrontEndTest = 0;
  1060:     crtR04VFrontEndCurr = 0;
  1061:     crtR05VSyncEndPort = 0;
  1062:     crtR05VSyncEndMask = 0;
  1063:     crtR05VSyncEndTest = 0;
  1064:     crtR05VSyncEndCurr = 0;
  1065:     crtR06VBackEndPort = 0;
  1066:     crtR06VBackEndMask = 0;
  1067:     crtR06VBackEndTest = 0;
  1068:     crtR06VBackEndCurr = 0;
  1069:     crtVDispStart = 0;
  1070:     crtR07VDispEndPort = 0;
  1071:     crtR07VDispEndMask = 0;
  1072:     crtR07VDispEndTest = 0;
  1073:     crtR07VDispEndCurr = 0;
  1074:     crtVIdleStart = 0;
  1075:     crtR08Adjust = 0;
  1076:     crtR09IRQRasterPort = 1023;
  1077:     crtR09IRQRasterMask = 0;
  1078:     crtR09IRQRasterTest = 1023;
  1079:     crtR09IRQRasterCurr = 1023;
  1080:     crtR10TxXPort = 0;
  1081:     crtR10TxXMask = 0;
  1082:     crtR10TxXTest = 0;
  1083:     crtR10TxXCurr = 0;
  1084:     crtR11TxYPort = 0;
  1085:     crtR11TxYMask = 0;
  1086:     crtR11TxYTest = 0;
  1087:     crtR11TxYCurr = 0;
  1088:     crtR11TxYZero = 0;
  1089:     crtR11TxYZeroLast = -1;
  1090:     for (int i = 0; i < 4; i++) {
  1091:       crtR12GrXPort[i] = 0;
  1092:       crtR12GrXMask[i] = 0;
  1093:       crtR12GrXTest[i] = 0;
  1094:       crtR12GrXCurr[i] = 0;
  1095:       crtR13GrYPort[i] = 0;
  1096:       crtR13GrYMask[i] = 0;
  1097:       crtR13GrYTest[i] = 0;
  1098:       crtR13GrYCurr[i] = 0;
  1099:       crtR13GrYZero[i] = 0;
  1100:       crtR13GrYZeroLast[i] = -1;
  1101:     }
  1102:     crtTextStorage = 0;
  1103:     crtGraphicStorage = 0;
  1104:     crtMemoryModePort = 0;
  1105:     crtMemoryModeMask = 0;
  1106:     crtMemoryModeTest = 0;
  1107:     crtMemoryModeCurr = 0;
  1108:     crtHighResoPort = 0;
  1109:     crtHighResoMask = 0;
  1110:     crtHighResoTest = 0;
  1111:     crtHighResoCurr = 0;
  1112:     crtVResoPort = 0;
  1113:     crtVResoMask = 0;
  1114:     crtVResoTest = 0;
  1115:     crtVResoCurr = 0;
  1116:     crtHResoPort = 0;
  1117:     crtHResoMask = 0;
  1118:     crtHResoTest = 0;
  1119:     crtHResoCurr = 0;
  1120:     if (false) {
  1121:       crtCCPlane0 = false;
  1122:       crtCCPlane1 = false;
  1123:       crtCCPlane2 = false;
  1124:       crtCCPlane3 = false;
  1125:       crtSimPlane0 = false;
  1126:       crtSimPlane1 = false;
  1127:       crtSimPlane2 = false;
  1128:       crtSimPlane3 = false;
  1129:       crtSimAccess = false;
  1130:       crtBitMask = false;
  1131:     }
  1132:     crtR22SrcBlock = 0;
  1133:     crtR22DstBlock = 0;
  1134:     crtR23Mask = 0x0000;
  1135:     crtRasterCopyOn = false;
  1136:     crtClearStandby = false;
  1137:     crtClearFrames = 0;
  1138: 
  1139:     crtHRLPort = 0;
  1140:     crtHRLMask = 0;
  1141:     crtHRLTest = 0;
  1142:     crtHRLCurr = 0;
  1143:     XEiJ.pnlStretchMode = 1.0F;
  1144:     XEiJ.pnlStereoscopicShutter = 0;  //左右OPEN
  1145:     crtDuplication = false;
  1146:     crtInterlace = false;
  1147:     crtSlit = false;
  1148:     crtDupExceptSp = false;
  1149:     crtHSyncColumn = 2;
  1150:     crtHBackColumn = 2;
  1151:     crtHDispColumn = 2;
  1152:     crtHFrontColumn = 2;
  1153:     crtHTotalColumn = 8;
  1154:     crtVsyncMultiplier = 1.0;
  1155:     crtColumnTime = 0;
  1156:     crtHSyncLength = 0;
  1157:     crtHBackLength = 0;
  1158:     crtHDispLength = 0;
  1159:     crtHFrontLength = 0;
  1160:     crtHBackDispLength = 0;
  1161:     crtTotalLength = 0L;
  1162:     crtTotalLengthMNP = 0L;
  1163: 
  1164:     if (!XEiJ.PNL_USE_THREAD) {
  1165:       crtDirtyY0 = -1;
  1166:       crtDirtyY1 = -1;
  1167:     }
  1168: 
  1169:     Arrays.fill (crtRasterStamp, 0);
  1170:     crtAllStamp = 1;  //初回は全再描画
  1171: 
  1172:     crtBeginningAllStamp = 1;
  1173: 
  1174:     crtRasterNumber = 0;
  1175:     crtDataY = 0;
  1176:     crtScreenY = 0;
  1177:     crtFrameParity = 0;
  1178: 
  1179:     crtRasterHashIdle = CRT_RASTER_HASH_ZERO;
  1180:     crtRasterHashDisp = CRT_RASTER_HASH_ZERO;
  1181: 
  1182:     crtContrastClock = XEiJ.FAR_FUTURE;
  1183:     crtCaptureClock = XEiJ.FAR_FUTURE;
  1184:     crtFrameTaskClock = Math.min (crtContrastClock, crtCaptureClock);
  1185: 
  1186:     if (CRT_ENABLE_INTERMITTENT) {  //間欠描画
  1187:       //crtIntermittentInterval = 0;
  1188:       crtIntermittentCounter = 0;
  1189:     }
  1190: 
  1191:     if (crtTicker != null) {
  1192:       TickerQueue.tkqRemove (crtTicker);
  1193:       crtTicker = null;
  1194:     }
  1195:     crtClock = XEiJ.FAR_FUTURE;  //停止
  1196: 
  1197:   }  //crtReset()
  1198: 
  1199:   //crtRestart ()
  1200:   //  CRTCのレジスタが設定されたのでCRT_RESTART_DELAY後にInitialStageを開始する
  1201:   public static void crtRestart () {
  1202:     if (crtTicker != null) {
  1203:       TickerQueue.tkqRemove (crtTicker);
  1204:     }
  1205:     TickerQueue.tkqAdd (crtTicker = InitialStage, crtClock = XEiJ.mpuClockTime + CRT_RESTART_DELAY);  //スクリーンの初期化へ
  1206:   }  //crtRestart()
  1207: 
  1208:   //crtStereoscopicStart ()
  1209:   //  垂直映像開始で
  1210:   public static void crtStereoscopicStart () {
  1211:     if (XEiJ.PNL_USE_THREAD) {
  1212:       XEiJ.pnlBM = (XEiJ.pnlStereoscopicShutter != 1 ? XEiJ.pnlBMLeftArray[XEiJ.pnlBMWrite & 3] :  //0=3=左右OPENまたは2=左OPENのとき左に描く
  1213:                     XEiJ.pnlBMRightArray[XEiJ.pnlBMWrite & 3]);  //1=右OPENのとき右に描く
  1214:     } else {
  1215:       XEiJ.pnlBM = (XEiJ.pnlStereoscopicShutter != 1 ? XEiJ.pnlBMLeft :  //0=3=左右OPENまたは2=左OPENのとき左に描く
  1216:                     XEiJ.pnlBMRight);  //1=右OPENのとき右に描く
  1217:     }
  1218:     crtAllStamp += 2;
  1219:   }
  1220: 
  1221:   //crtStereoscopicDrawRaster (screenY)
  1222:   //  drawRasterの後で
  1223:   public static void crtStereoscopicDrawRaster (int screenY) {
  1224:     if (XEiJ.pnlStereoscopicShutter == 0 ||
  1225:         XEiJ.pnlStereoscopicShutter == 3) {  //0=3=左右OPENのとき
  1226:       if (XEiJ.PNL_USE_THREAD) {
  1227:         System.arraycopy (XEiJ.pnlBMLeftArray[XEiJ.pnlBMWrite & 3], screenY << XEiJ.PNL_BM_OFFSET_BITS,
  1228:                           XEiJ.pnlBMRightArray[XEiJ.pnlBMWrite & 3], screenY << XEiJ.PNL_BM_OFFSET_BITS,
  1229:                           XEiJ.pnlScreenWidth);  //左から右へコピー
  1230:       } else {
  1231:         System.arraycopy (XEiJ.pnlBMLeft, screenY << XEiJ.PNL_BM_OFFSET_BITS,
  1232:                           XEiJ.pnlBMRight, screenY << XEiJ.PNL_BM_OFFSET_BITS,
  1233:                           XEiJ.pnlScreenWidth);  //左から右へコピー
  1234:       }
  1235:     }
  1236:   }
  1237: 
  1238:   //crtUpdateScreen ()
  1239:   //  スクリーンを更新する
  1240:   public static void crtUpdateScreen () {
  1241:     if (!XEiJ.PNL_USE_THREAD) {
  1242:       if (XEiJ.pnlZoomRatioOutY == 1 << 16) {  //拡大なし
  1243:         XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1 + crtDirtyY0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, crtDirtyY1 - crtDirtyY0 + 1);
  1244:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
  1245:           XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3 + crtDirtyY0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, crtDirtyY1 - crtDirtyY0 + 1);
  1246:         }
  1247:       } else {  //拡大あり
  1248:         int y0 = (crtDirtyY0 - 1) * XEiJ.pnlZoomRatioOutY >> 16;
  1249:         int y1 = (crtDirtyY1 + 2) * (XEiJ.pnlZoomRatioOutY + 1) >> 16;
  1250:         XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1 + y0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, y1 - y0);
  1251:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
  1252:           XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3 + y0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, y1 - y0);
  1253:         }
  1254:       }
  1255:       crtDirtyY0 = -1;
  1256:     }
  1257:   }
  1258: 
  1259:   //crtRepaint ()
  1260:   //  再描画
  1261:   //  MPUが止まっていても再描画する
  1262:   //  ダーティラスタのマークはそのままでMFPとのやりとりも行わない
  1263:   //  ラスタ割り込みを使用して作られている画面は再現できない
  1264:   public static void crtRepaint () {
  1265:     crtBeginningAllStamp = crtAllStamp;
  1266:     int l = Math.max (0, Math.min (1024, crtR07VDispEndCurr - crtR06VBackEndCurr));
  1267:     if (crtDuplication) {  //ラスタ2度読み
  1268:       for (int screenY = 0; screenY < l; screenY += 2) {
  1269:         if (SpriteScreen.SPR_THREE_STEPS) {
  1270:           SpriteScreen.sprStep1 (screenY >> 1);
  1271:           SpriteScreen.sprStep2 (screenY >> 1);
  1272:         }
  1273:         VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);  //スクリーンY座標へ描画
  1274:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  1275:           crtStereoscopicDrawRaster (screenY);
  1276:         }
  1277:         //偶数ラスタを奇数ラスタにコピーする
  1278:         System.arraycopy (XEiJ.pnlBM, screenY << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlBM, screenY + 1 << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlScreenWidth);
  1279:       }
  1280:     } else if (crtSlit) {  //スリット
  1281:       for (int screenY = 0; screenY < l; screenY += 2) {
  1282:         if (SpriteScreen.SPR_THREE_STEPS) {
  1283:           SpriteScreen.sprStep1 (screenY >> 1);
  1284:           SpriteScreen.sprStep2 (screenY >> 1);
  1285:         }
  1286:         VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);  //スクリーンY座標へ描画
  1287:         crtScanlineEffect.drawRaster (screenY + 1);  //走査線エフェクト
  1288:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  1289:           crtStereoscopicDrawRaster (screenY);
  1290:           crtStereoscopicDrawRaster (screenY + 1);
  1291:         }
  1292:       }
  1293:     } else if (crtDupExceptSp) {  //ラスタ2度読み(スプライトを除く)
  1294:       for (int screenY = 0; screenY < l; screenY++) {
  1295:         if (SpriteScreen.SPR_THREE_STEPS) {
  1296:           SpriteScreen.sprStep1 (screenY);
  1297:           SpriteScreen.sprStep2 (screenY);
  1298:         }
  1299:         VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);  //スクリーンY座標へ描画
  1300:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  1301:           crtStereoscopicDrawRaster (screenY);
  1302:         }
  1303:       }
  1304:     } else {  //ノーマル,インターレース
  1305:       for (int screenY = 0; screenY < l; screenY++) {
  1306:         if (SpriteScreen.SPR_THREE_STEPS) {
  1307:           SpriteScreen.sprStep1 (screenY);
  1308:           SpriteScreen.sprStep2 (screenY);
  1309:         }
  1310:         VideoController.vcnMode.drawRaster (screenY, screenY, false);  //スクリーンY座標へ描画
  1311:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  1312:           crtStereoscopicDrawRaster (screenY);
  1313:         }
  1314:       }
  1315:     }
  1316:     XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, l);
  1317:     if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
  1318:       XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, l);
  1319:     }
  1320:   }  //crtRepaint()
  1321: 
  1322:   //crtDoFrameTask ()
  1323:   //  垂直同期パルスに行う処理
  1324:   //  垂直同期パルスに入ったときXEiJ.mpuClockTime>=crtFrameTaskClockならば呼び出す
  1325:   //  コントラストの調整
  1326:   //  画面キャプチャ
  1327:   public static void crtDoFrameTask () {
  1328:     if (XEiJ.mpuClockTime >= crtContrastClock) {
  1329:       VideoController.vcnCurrentScaledContrast += VideoController.vcnCurrentScaledContrast < VideoController.vcnTargetScaledContrast ? 1 : -1;
  1330:       VideoController.vcnSetContrast (VideoController.vcnCurrentScaledContrast);
  1331:       if (VideoController.vcnCurrentScaledContrast == VideoController.vcnTargetScaledContrast) {
  1332:         crtContrastClock = XEiJ.FAR_FUTURE;
  1333:       } else {
  1334:         crtContrastClock += VideoController.VCN_CONTRAST_DELAY;
  1335:       }
  1336:     }
  1337:     if (XEiJ.mpuClockTime >= crtCaptureClock) {
  1338:       GIFAnimation.gifCaptureFrame ();
  1339:     }
  1340:     crtFrameTaskClock = Math.min (crtContrastClock, crtCaptureClock);
  1341:   }  //crtDoFrameTask()
  1342: 
  1343:   //crtSetMemoryMode (textStorage, graphicStorage, memoryMode)
  1344:   //  テキストストレージ(R20 12)
  1345:   //  グラフィックストレージ(R20 11)
  1346:   //  メモリモード(R20 10-8)を変更する
  1347:   public static void crtSetMemoryMode (int textStorage, int graphicStorage, int memoryMode) {
  1348:     boolean updateMemoryMap = false;  //メモリマップを更新するか
  1349:     textStorage &= 1;
  1350:     if (crtTextStorage != textStorage) {  //テキストストレージを変更する
  1351:       crtTextStorage = textStorage;
  1352:     }
  1353:     graphicStorage &= 1;
  1354:     if (crtGraphicStorage != graphicStorage) {  //グラフィックストレージを変更する
  1355:       crtGraphicStorage = graphicStorage;
  1356:       updateMemoryMap = true;  //メモリマップを更新する
  1357:     }
  1358:     memoryMode &= 7;
  1359:     crtMemoryModePort = memoryMode;
  1360:     int curr = crtMemoryModeMask == 0 ? crtMemoryModePort : crtMemoryModeTest;
  1361:     if (crtMemoryModeCurr != curr) {  //メモリモードを変更する
  1362:       crtMemoryModeCurr = curr;
  1363:       updateMemoryMap = true;  //メモリマップを更新する
  1364:     }
  1365:     if (updateMemoryMap) {  //メモリマップを更新する
  1366:       if (crtGraphicStorage != 0) {  //グラフィックストレージON
  1367:         if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn &&  //拡張グラフィック画面がONかつ
  1368:             (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7)) {  //メモリモード5または7のとき
  1369:           //メモリモード7相当
  1370:           XEiJ.busSuper (MemoryMappedDevice.MMD_GJ0, 0x00c00000, 0x00e00000);
  1371:         } else {
  1372:           //メモリモード3相当
  1373:           XEiJ.busSuper (MemoryMappedDevice.MMD_GG0, 0x00c00000, 0x00c80000);
  1374:           XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00c80000, 0x00e00000);
  1375:         }
  1376:       } else {  //グラフィックストレージOFF
  1377:         switch (crtMemoryModeCurr) {
  1378:         case 0:  //メモリモード0
  1379:           //512ドット16色
  1380:           XEiJ.busSuper (MemoryMappedDevice.MMD_GE0, 0x00c00000, 0x00c80000);
  1381:           XEiJ.busSuper (MemoryMappedDevice.MMD_GE1, 0x00c80000, 0x00d00000);
  1382:           XEiJ.busSuper (MemoryMappedDevice.MMD_GE2, 0x00d00000, 0x00d80000);
  1383:           XEiJ.busSuper (MemoryMappedDevice.MMD_GE3, 0x00d80000, 0x00e00000);
  1384:           break;
  1385:         case 1:  //メモリモード1
  1386:           //512ドット256色
  1387:           XEiJ.busSuper (MemoryMappedDevice.MMD_GF0, 0x00c00000, 0x00c80000);
  1388:           XEiJ.busSuper (MemoryMappedDevice.MMD_GF1, 0x00c80000, 0x00d00000);
  1389:           XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00d00000, 0x00e00000);
  1390:           break;
  1391:         case 2:  //メモリモード2
  1392:           //メモリモード2
  1393:           XEiJ.busSuper (MemoryMappedDevice.MMD_GM2, 0x00c00000, 0x00e00000);
  1394:           break;
  1395:         case 3:  //メモリモード3
  1396:           //512ドット65536色
  1397:           XEiJ.busSuper (MemoryMappedDevice.MMD_GG0, 0x00c00000, 0x00c80000);
  1398:           XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00c80000, 0x00e00000);
  1399:           break;
  1400:         case 4:  //メモリモード4
  1401:           //1024ドット16色
  1402:           XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
  1403:           break;
  1404:         case 5:  //メモリモード5
  1405:           if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn) {
  1406:             //1024ドット256色(拡張)
  1407:             XEiJ.busSuper (MemoryMappedDevice.MMD_GI0, 0x00c00000, 0x00e00000);
  1408:           } else {
  1409:             //1024ドット16色
  1410:             XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
  1411:           }
  1412:           break;
  1413:         case 6:  //メモリモード6
  1414:           //1024ドット16色
  1415:           XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
  1416:           break;
  1417:         case 7:  //メモリモード7
  1418:           if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn) {
  1419:             //1024ドット65536色(拡張)
  1420:             XEiJ.busSuper (MemoryMappedDevice.MMD_GJ0, 0x00c00000, 0x00e00000);
  1421:           } else {
  1422:             //1024ドット16色
  1423:             XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
  1424:           }
  1425:           break;
  1426:         }
  1427:       }
  1428:     }
  1429:   }  //crtSetMemoryMode
  1430: 
  1431:   //crtUpdateRasterHash ()
  1432:   //  crtRasterHashIdle,crtRasterHashDispを設定する
  1433:   //    crtRasterCopyOn
  1434:   //    RasterBreakPoint.rbpActiveBreakRaster
  1435:   //    crtR09IRQRasterCurr
  1436:   //    crtVDispStart
  1437:   //    crtR04VFrontEndCurr
  1438:   //    crtVIdleStart
  1439:   //  が更新されたときに呼び出す
  1440:   //  crtR04VFrontEndCurrがcrtRasterNumberよりも小さい値に変更されると通り過ぎてしまうので必ずcrtRasterNumber=0からリスタートさせること
  1441:   public static void crtUpdateRasterHash () {
  1442:     if (CRT_RASTER_HASH_ON) {
  1443:       long t = crtRasterCopyOn ? ~CRT_RASTER_HASH_ZERO : CRT_RASTER_HASH_ZERO;  //intまたはlong
  1444:       //int t = crtRasterCopyOn ? ~CRT_RASTER_HASH_ZERO : CRT_RASTER_HASH_ZERO;  //intまたはlong
  1445:       if (RasterBreakPoint.RBP_ON && RasterBreakPoint.rbpActiveBreakRaster >= 0) {
  1446:         t |= CRT_RASTER_HASH_MSB >>> RasterBreakPoint.rbpActiveBreakRaster;
  1447:       }
  1448:       if (crtR09IRQRasterCurr <= crtR04VFrontEndCurr) {
  1449:         t |= (CRT_RASTER_HASH_MSB >>> crtR09IRQRasterCurr |
  1450:               CRT_RASTER_HASH_MSB >>> (crtR09IRQRasterCurr < crtR04VFrontEndCurr ? crtR09IRQRasterCurr + 1 : 0));
  1451:       }
  1452:       crtRasterHashIdle = (t |
  1453:                            CRT_RASTER_HASH_MSB >>> crtVDispStart |
  1454:                            CRT_RASTER_HASH_MSB >>> crtR04VFrontEndCurr + 1);
  1455:       crtRasterHashDisp = (t |
  1456:                            CRT_RASTER_HASH_MSB >>> crtVIdleStart);
  1457:     }
  1458:   }  //crtUpdateRasterHash()
  1459: 
  1460:   //高速クリア
  1461:   //  手順
  1462:   //    (1)$00E8002Aを保存する
  1463:   //    (2)クリアページを設定する。$00E8002Aに#$000Fなどを書き込む
  1464:   //    (3)高速クリアを予約する。$00E80480に#$0002を書き込む
  1465:   //    (4)高速クリアの開始を待つ。$00E80480と#$0002のANDが#$0000でなくなるまで待つ
  1466:   //    (5)高速クリアの終了を待つ。$00E80480と#$0002のANDが#$0000になるまで待つ
  1467:   //    (6)$00E8002Aを復元する
  1468:   //  動作ポートのビット1
  1469:   //    書き込み
  1470:   //      0のとき1を書き込むと垂直映像開始の直前にラッチされて高速クリアが始まる
  1471:   //      0を書き込んでもキャンセルや中断はできない
  1472:   //    読み出し
  1473:   //      1を書き込んだ直後の垂直映像開始の直前に1になる
  1474:   //      次(インターレースのときは次の次)の垂直映像開始の直前(1ラスタ手前?)に自動的に0に戻る
  1475:   //      0に戻った直後に1を書き込んだとき次のフレームの高速クリアは(ほとんど?)失敗する
  1476:   //  ページ選択
  1477:   //    実画面サイズが512x512のとき
  1478:   //      高速クリアページセレクトの各ビットが4ビットページに対応する
  1479:   //      垂直映像期間の途中で変更できる
  1480:   //    実画面サイズが1024x1024のとき
  1481:   //      高速クリアページセレクトは無効で常にすべてのページが消去される
  1482:   //  範囲
  1483:   //    高速クリアされる範囲は、画面サイズ、実画面サイズ、ページ0のスクロール位置で決まる
  1484:   //      ページ0は表示されている範囲がクリアされるが、ページ1,2,3は表示されている範囲がクリアされるとは限らない
  1485:   //    水平方向のスクロール位置が奇数のときは偶数に切り捨てられる
  1486:   //      256x256で水平方向のスクロール位置が奇数のとき、画面の右端にクリアされないドットが残る
  1487:   //    クリアされる範囲の幅は画面の幅と512の小さい方
  1488:   //      x=512を跨ぐときx=0に戻る
  1489:   //      実画面サイズが1024ドットのとき2箇所クリアする
  1490:   //    クリアされる範囲の高さは画面の高さ
  1491:   //      画面の高さが256ドットのときラスタ2度読みでもクリアされる範囲の高さは256ドット
  1492: 
  1493:   //crtRapidClear (y)
  1494:   //  高速クリア実行
  1495:   public static void crtRapidClear (int y) {
  1496:     y += crtR13GrYZero[0];
  1497:     int x = crtR12GrXCurr[0] & -2;  //x座標開始位置
  1498:     int w = 8 * crtHDispColumn;  //画面の幅
  1499:     if (512 <= w) {
  1500:       x = 0;
  1501:       w = 512;
  1502:     }
  1503:     if (crtMemoryModeCurr < 4) {  //実画面サイズ512ドット
  1504:       int i = (y & 511) << 9;  //(0,y)のインデックス
  1505:       if (x + w <= 512) {  //x=512を跨がない
  1506:         //    i  i+x          i+x+w    i+512
  1507:         //    |   <------------->       |
  1508:         if (crtCCPlane0) {
  1509:           Arrays.fill (GraphicScreen.graM4,           i + x,           i + x + w, (byte) 0);
  1510:         }
  1511:         if (crtCCPlane1) {
  1512:           Arrays.fill (GraphicScreen.graM4, 0x40000 + i + x, 0x40000 + i + x + w, (byte) 0);
  1513:         }
  1514:         if (crtCCPlane2) {
  1515:           Arrays.fill (GraphicScreen.graM4, 0x80000 + i + x, 0x80000 + i + x + w, (byte) 0);
  1516:         }
  1517:         if (crtCCPlane3) {
  1518:           Arrays.fill (GraphicScreen.graM4, 0xc0000 + i + x, 0xc0000 + i + x + w, (byte) 0);
  1519:         }
  1520:       } else {  //x=512を跨ぐ
  1521:         //    i    i+x+w-512     i+x   i+512  i+x+w
  1522:         //    |------->           <-----|------->
  1523:         if (crtCCPlane0) {
  1524:           Arrays.fill (GraphicScreen.graM4,           i + x,           i +         512, (byte) 0);
  1525:           Arrays.fill (GraphicScreen.graM4,           i    ,           i + x + w - 512, (byte) 0);
  1526:         }
  1527:         if (crtCCPlane1) {
  1528:           Arrays.fill (GraphicScreen.graM4, 0x40000 + i + x, 0x40000 + i +         512, (byte) 0);
  1529:           Arrays.fill (GraphicScreen.graM4, 0x40000 + i    , 0x40000 + i + x + w - 512, (byte) 0);
  1530:         }
  1531:         if (crtCCPlane2) {
  1532:           Arrays.fill (GraphicScreen.graM4, 0x80000 + i + x, 0x80000 + i +         512, (byte) 0);
  1533:           Arrays.fill (GraphicScreen.graM4, 0x80000 + i    , 0x80000 + i + x + w - 512, (byte) 0);
  1534:         }
  1535:         if (crtCCPlane3) {
  1536:           Arrays.fill (GraphicScreen.graM4, 0xc0000 + i + x, 0xc0000 + i +         512, (byte) 0);
  1537:           Arrays.fill (GraphicScreen.graM4, 0xc0000 + i    , 0xc0000 + i + x + w - 512, (byte) 0);
  1538:         }
  1539:       }
  1540:     } else {  //実画面サイズ1024ドット
  1541:       int i = (y & 512) << 10 | (y & 511) << 9;  //(0,y)のインデックス
  1542:       if (x + w <= 512) {  //x=512を跨がない
  1543:         //    i  i+x          i+x+w    i+512
  1544:         //    |   <------------->       |
  1545:         for (int k = 0; k < 2; k++) {  //2箇所クリアする
  1546:           Arrays.fill (GraphicScreen.graM4,            i + x,            i + x + w, (byte) 0);
  1547:           if (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7) {
  1548:             Arrays.fill (GraphicScreen.graM4, 0x100000 + i + x, 0x100000 + i + x + w, (byte) 0);
  1549:             if (crtMemoryModeCurr == 7) {
  1550:               Arrays.fill (GraphicScreen.graM4, 0x200000 + i + x, 0x200000 + i + x + w, (byte) 0);
  1551:               Arrays.fill (GraphicScreen.graM4, 0x300000 + i + x, 0x300000 + i + x + w, (byte) 0);
  1552:             }
  1553:           }
  1554:           i += 512 << 9;  //(512,y)のインデックス
  1555:         }
  1556:       } else {  //x=512を跨ぐ
  1557:         //    i    i+x+w-512     i+x   i+512  i+x+w
  1558:         //    |------->           <-----|------->
  1559:         for (int k = 0; k < 2; k++) {  //2箇所クリアする
  1560:           Arrays.fill (GraphicScreen.graM4,            i + x,            i +         512, (byte) 0);
  1561:           Arrays.fill (GraphicScreen.graM4,            i    ,            i + x + w - 512, (byte) 0);
  1562:           if (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7) {
  1563:             Arrays.fill (GraphicScreen.graM4, 0x100000 + i + x, 0x100000 + i +         512, (byte) 0);
  1564:             Arrays.fill (GraphicScreen.graM4, 0x100000 + i    , 0x100000 + i + x + w - 512, (byte) 0);
  1565:             if (crtMemoryModeCurr == 7) {
  1566:               Arrays.fill (GraphicScreen.graM4, 0x200000 + i + x, 0x200000 + i +         512, (byte) 0);
  1567:               Arrays.fill (GraphicScreen.graM4, 0x200000 + i    , 0x200000 + i + x + w - 512, (byte) 0);
  1568:               Arrays.fill (GraphicScreen.graM4, 0x300000 + i + x, 0x300000 + i +         512, (byte) 0);
  1569:               Arrays.fill (GraphicScreen.graM4, 0x300000 + i    , 0x300000 + i + x + w - 512, (byte) 0);
  1570:             }
  1571:           }
  1572:           i += 512 << 9;  //(512,y)のインデックス
  1573:         }
  1574:       }
  1575:     }
  1576:   }  //crtRapidClear(int)
  1577: 
  1578:   //crtDoRasterCopy ()
  1579:   //  ラスタコピー実行
  1580:   public static void crtDoRasterCopy () {
  1581:     int srcOffset = crtR22SrcBlock << 9;
  1582:     int dstOffset = crtR22DstBlock << 9;
  1583:     if (crtCCPlane0) {
  1584:       System.arraycopy (MainMemory.mmrM8, 0x00e00000 + srcOffset, MainMemory.mmrM8, 0x00e00000 + dstOffset, 512);
  1585:     }
  1586:     if (crtCCPlane1) {
  1587:       System.arraycopy (MainMemory.mmrM8, 0x00e20000 + srcOffset, MainMemory.mmrM8, 0x00e20000 + dstOffset, 512);
  1588:     }
  1589:     if (crtCCPlane2) {
  1590:       System.arraycopy (MainMemory.mmrM8, 0x00e40000 + srcOffset, MainMemory.mmrM8, 0x00e40000 + dstOffset, 512);
  1591:     }
  1592:     if (crtCCPlane3) {
  1593:       System.arraycopy (MainMemory.mmrM8, 0x00e60000 + srcOffset, MainMemory.mmrM8, 0x00e60000 + dstOffset, 512);
  1594:     }
  1595:     int y = (dstOffset >> 7) - crtR11TxYZero;
  1596:     crtRasterStamp[y     & 1023] = 0;
  1597:     crtRasterStamp[y + 1 & 1023] = 0;
  1598:     crtRasterStamp[y + 2 & 1023] = 0;
  1599:     crtRasterStamp[y + 3 & 1023] = 0;
  1600:   }  //crtDoRasterCopy()
  1601: 
  1602: 
  1603: 
  1604:   //========================================================================================
  1605:   //
  1606:   //  CRTCのステージ
  1607:   //
  1608:   //    ラスタ(水平周期)
  1609:   //      水平フロントポーチと水平同期パルスと水平バックポーチと水平映像期間を合わせた期間
  1610:   //
  1611:   //    フレーム(垂直周期)
  1612:   //      垂直空白期間(垂直フロントポーチと垂直同期パルスと垂直バックポーチ)と垂直映像期間を合わせた期間
  1613:   //      垂直映像期間と垂直フロントポーチはそれぞれ少なくとも1ラスタ以上必要
  1614:   //        垂直フロントポーチが1ラスタ以上必要なのは垂直映像期間にラスタ番号のラップアラウンドを行なっていないため
  1615:   //        垂直映像期間にラスタ番号のラップアラウンドを行う場合でも垂直空白期間は少なくとも1ラスタ以上必要
  1616:   //
  1617:   //    ラスタ番号
  1618:   //      ラスタの番号。0からラスタ数-1まで。0は垂直同期パルス開始ラスタ、ラスタ数-1は垂直フロントポーチ終了ラスタ
  1619:   //      遷移とIRQ信号の生成に用いる
  1620:   //
  1621:   //    フレームパリティ
  1622:   //      フレーム番号の下位1bit。0または1
  1623:   //      インターレースのときにフレーム毎のデータY座標とスクリーンY座標の初期値として使う
  1624:   //      フレームの末尾で反転する
  1625:   //
  1626:   //    データY座標
  1627:   //      ラスタに供給されるデータのY座標
  1628:   //
  1629:   //    スクリーンY座標
  1630:   //      ラスタを表示するスクリーン上のY座標
  1631:   //
  1632:   //
  1633:   //    ノーマル
  1634:   //      フレームの先頭でデータY座標とスクリーンY座標を0で初期化する
  1635:   //      ラスタを描画してからスクリーンY座標を1増やす
  1636:   //      ラスタの末尾でデータY座標を1増やす
  1637:   //      垂直映像期間の先頭で高速クリアの要求があるとき高速クリアカウンタを1で初期化する
  1638:   //
  1639:   //    ラスタ2度読み
  1640:   //      フレームの先頭でデータY座標とスクリーンY座標を0で初期化する
  1641:   //      偶数ラスタを描画してからスクリーンY座標を1増やす
  1642:   //      偶数ラスタの末尾ではデータY座標を増やさない
  1643:   //      奇数ラスタを描画してからスクリーンY座標を1増やす
  1644:   //      奇数ラスタの末尾でデータY座標を1増やす
  1645:   //      垂直映像期間の先頭で高速クリアの要求があるとき高速クリアカウンタを1で初期化する
  1646:   //
  1647:   //    インターレース
  1648:   //      フレームの先頭でデータY座標とスクリーンY座標をフレームパリティで初期化する
  1649:   //      ラスタを描画してからスクリーンY座標を2増やす
  1650:   //      ラスタの末尾でデータY座標を2増やす
  1651:   //      (偶数フレームは偶数ラスタだけ、奇数フレームは奇数ラスタだけ描画する)
  1652:   //      垂直映像期間の先頭で高速クリアの要求があるとき高速クリアカウンタを2で初期化する
  1653:   //
  1654:   //    スリット
  1655:   //      フレームの先頭でデータY座標とスクリーンY座標を0で初期化する
  1656:   //      ラスタを描画してから輝度を落としてコピーし、スクリーンY座標を2増やす
  1657:   //      ラスタの末尾でデータY座標を1増やす
  1658:   //      垂直映像期間の先頭で高速クリアの要求があるとき高速クリアカウンタを1で初期化する
  1659:   //
  1660:   //
  1661:   //                                         データY座標     スクリーンY座標
  1662:   //    ───────────────────────────────────
  1663:   //        ノーマル          初期化               0                 0
  1664:   //                       ラスタ描画後           +1                +1
  1665:   //    ───────────────────────────────────
  1666:   //      ラスタ2度読み       初期化               0                 0
  1667:   //                     偶数ラスタ描画後         +0                +1
  1668:   //                     奇数ラスタ描画後         +1                +1
  1669:   //    ───────────────────────────────────
  1670:   //     インターレース       初期化       フレームパリティ  フレームパリティ
  1671:   //                       ラスタ描画後           +2                +2
  1672:   //    ───────────────────────────────────
  1673:   //        スリット          初期化               0                 0
  1674:   //                       ラスタ描画後           +1                +2
  1675:   //    ───────────────────────────────────
  1676:   //
  1677:   //
  1678:   //    水平フロントポーチ
  1679:   //      +水平フロントポーチの長さ
  1680:   //      ラスタ番号を1増やす
  1681:   //      [垂直空白期間のとき]
  1682:   //        ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  1683:   //          ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  1684:   //      ラスタコピースイッチがONのとき
  1685:   //        ラスタコピー実行
  1686:   //      ブレークラスタのとき
  1687:   //        ラスタブレークをかける
  1688:   //      IRQ信号を更新
  1689:   //      IRQ信号が変化したとき
  1690:   //        IRQ信号が0になったとき
  1691:   //        | IRQラスタでラスタブレークをかけるとき
  1692:   //        |   ブレークラスタではないとき(ブレークラスタとIRQラスタが同じときは既にラスタブレークがかかっている)
  1693:   //        |      ラスタブレークをかける
  1694:   //        | IRQ開始
  1695:   //        IRQ信号が0でなくなったとき
  1696:   //          IRQ終了
  1697:   //      [垂直空白期間のとき]
  1698:   //      | 垂直映像期間開始ラスタではないとき
  1699:   //      | | [描画フレーム(間欠カウンタ==0)のとき]
  1700:   //      | | | →描画フレームの垂直空白期間の水平同期パルス
  1701:   //      | | [省略フレーム(間欠カウンタ!=0)のとき]
  1702:   //      | |   →省略フレームの垂直空白期間の水平同期パルス
  1703:   //      | 垂直映像期間開始ラスタのとき
  1704:   //      |   垂直映像期間開始
  1705:   //      |   テキストY方向スクロールを保存
  1706:   //      |   グラフィックY方向スクロールを保存
  1707:   //      |   [インターレースではないとき]
  1708:   //      |   | データY座標を0で初期化
  1709:   //      |   [インターレースのとき]
  1710:   //      |     データY座標をフレームパリティで初期化
  1711:   //      |   高速クリアの要求があるとき
  1712:   //      |     [インターレースではないとき]
  1713:   //      |     | 高速クリアカウンタを1で初期化
  1714:   //      |     [インターレースのとき]
  1715:   //      |       高速クリアカウンタを2で初期化
  1716:   //      |   [描画フレーム(間欠カウンタ==0)のとき]
  1717:   //      |   | [インターレースではないとき]
  1718:   //      |   | | スクリーンY座標を0で初期化
  1719:   //      |   | [インターレースのとき]
  1720:   //      |   |   スクリーンY座標をフレームパリティで初期化
  1721:   //      |   | ダーティフラグをクリア
  1722:   //      |   | →描画フレームの垂直映像期間の水平同期パルス
  1723:   //      |   [省略フレーム(間欠カウンタ!=0)のとき]
  1724:   //      |     →省略フレームの垂直映像期間の水平同期パルス
  1725:   //      [垂直映像期間のとき]
  1726:   //        垂直空白期間開始ラスタではないとき
  1727:   //        | [描画フレーム(間欠カウンタ==0)のとき]
  1728:   //        | | [全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき]
  1729:   //        | | | データY座標からスクリーンY座標へ描画
  1730:   //        | | [ノーマルのとき]
  1731:   //        | | | データY座標を1増やす
  1732:   //        | | | スクリーンY座標を1増やす
  1733:   //        | | [ラスタ2度読みのとき]
  1734:   //        | | | スクリーンY座標を1増やす
  1735:   //        | | | [偶数ラスタのとき]
  1736:   //        | | |   データY座標を1増やす
  1737:   //        | | [インターレースのとき]
  1738:   //        | | | スクリーンY座標を2増やす
  1739:   //        | | | データY座標を2増やす
  1740:   //        | | [スリットのとき]
  1741:   //        | |   スクリーンY座標を2増やす
  1742:   //        | |   データY座標を1増やす
  1743:   //        | | →描画フレームの垂直映像期間の水平同期パルス
  1744:   //        | [省略フレーム(間欠カウンタ!=0)のとき]
  1745:   //        |   →省略フレームの垂直映像期間の水平同期パルス
  1746:   //        垂直空白期間開始ラスタのとき
  1747:   //          [全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき]
  1748:   //          | データY座標からスクリーンY座標へ描画
  1749:   //          垂直映像期間終了
  1750:   //          高速クリアカウンタが0ではないとき
  1751:   //            高速クリアカウンタを1減らす
  1752:   //          [描画フレーム(間欠カウンタ==0)のとき]
  1753:   //          | ダーティフラグがセットされているとき
  1754:   //          |   スクリーンを更新する
  1755:   //          |   間欠カウンタを間欠間隔に戻す
  1756:   //          [省略フレーム(間欠カウンタ!=0)のとき]
  1757:   //            間欠カウンタを1減らす
  1758:   //          [インターレースのとき]
  1759:   //            フレームパリティを反転
  1760:   //          フレームタスク(コントラスト調整など)
  1761:   //          書き込むビットマップを切り替える
  1762:   //          [描画フレーム(間欠カウンタ==0)のとき]
  1763:   //          | →描画フレームの垂直空白期間の水平同期パルス
  1764:   //          [省略フレーム(間欠カウンタ!=0)のとき]
  1765:   //            →省略フレームの垂直空白期間の水平同期パルス
  1766:   //
  1767:   //    水平同期パルス
  1768:   //      +水平同期パルスの長さ
  1769:   //      水平同期パルス開始
  1770:   //      [垂直空白期間のとき]
  1771:   //      | [描画フレーム(間欠カウンタ==0)のとき]
  1772:   //      | | →描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  1773:   //      | [省略フレーム(間欠カウンタ!=0)のとき]
  1774:   //      |   →省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  1775:   //      [垂直映像期間のとき]
  1776:   //        [ラスタ2度読みではないとき]
  1777:   //        | 高速クリアカウンタが0ではないとき
  1778:   //        |   データY座標を高速クリア
  1779:   //        [ラスタ2度読みのとき]
  1780:   //          [偶数ラスタのとき]
  1781:   //            高速クリアカウンタが0ではないとき
  1782:   //              データY座標を高速クリア
  1783:   //        [描画フレーム(間欠カウンタ==0)のとき]
  1784:   //        | →描画フレームの垂直映像期間の水平バックポーチ
  1785:   //        [省略フレーム(間欠カウンタ!=0)のとき]
  1786:   //          →省略フレームの垂直映像期間の水平バックポーチと水平映像期間
  1787:   //
  1788:   //    水平バックポーチ
  1789:   //      水平同期パルス終了
  1790:   //      [垂直空白期間のとき]
  1791:   //      | [描画フレーム(間欠カウンタ==0)のとき]
  1792:   //      | | +水平バックポーチと水平映像期間の長さ
  1793:   //      | | →描画フレームの垂直空白期間の水平フロントポーチ
  1794:   //      | [省略フレーム(間欠カウンタ!=0)のとき]
  1795:   //      |   +水平バックポーチと水平映像期間の長さ
  1796:   //      |   →省略フレームの垂直空白期間の水平フロントポーチ
  1797:   //      [垂直映像期間のとき]
  1798:   //        [描画フレーム(間欠カウンタ==0)のとき]
  1799:   //        | +水平バックポーチの長さ
  1800:   //        | →描画フレームの垂直映像期間の水平映像期間
  1801:   //        [省略フレーム(間欠カウンタ!=0)のとき]
  1802:   //          +水平バックポーチと水平映像期間の長さ
  1803:   //          →省略フレームの垂直映像期間の水平フロントポーチ
  1804:   //
  1805:   //    描画フレームの垂直映像期間の水平映像期間
  1806:   //      +水平水平映像期間の長さ
  1807:   //      ラスタの更新フラグがセットされているとき
  1808:   //        [ノーマルのとき]
  1809:   //        | ラスタの更新フラグをクリア
  1810:   //        [ラスタ2度読みのとき]
  1811:   //        | [奇数ラスタのとき]
  1812:   //        |   ラスタの更新フラグをクリア
  1813:   //        [インターレースのとき]
  1814:   //        | ラスタの更新フラグをクリア
  1815:   //        [スリットのとき]
  1816:   //          ラスタの更新フラグをクリア
  1817:   //        全再描画スタンプを水平映像期間開始時の全再描画スタンプにコピー
  1818:   //        データY座標からスクリーンY座標へ描画
  1819:   //        [スリットのとき]
  1820:   //          輝度を半分にしてコピーする
  1821:   //        ダーティフラグをセット
  1822:   //      →描画フレームの垂直映像期間の水平フロントポーチ
  1823:   //
  1824:   //
  1825:   //    描画フレーム(間欠カウンタ==0)
  1826:   //      描画フレームの垂直空白期間(垂直フロントポーチと垂直同期パルスと垂直バックポーチ)
  1827:   //        (0)開始(描画フレームの垂直空白期間開始ラスタの水平フロントポーチ)            Start
  1828:   //        (1)描画フレームの垂直空白期間の水平フロントポーチ                              DrawIdleFront
  1829:   //        (2)描画フレームの垂直空白期間の水平同期パルス                                  DrawIdleSync
  1830:   //        (3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間                  DrawIdleBackDisp
  1831:   //      描画フレームの垂直映像期間
  1832:   //        奇偶共通
  1833:   //          (4)描画フレームの垂直映像期間の水平フロントポーチ                            DrawDispFront
  1834:   //          (5)描画フレームの垂直映像期間の水平同期パルス                                DrawDispSync
  1835:   //          (6)描画フレームの垂直映像期間の水平バックポーチ                              DrawDispBack
  1836:   //          (7)描画フレームの垂直映像期間の水平映像期間                                  DrawDispDisp
  1837:   //        偶数ラスタ
  1838:   //          (4e)描画フレームの垂直映像期間の偶数ラスタの水平フロントポーチ               DrawDispEvenFront
  1839:   //          (5e)描画フレームの垂直映像期間の偶数ラスタの水平同期パルス                   DrawDispEvenSync
  1840:   //          (6e)描画フレームの垂直映像期間の偶数ラスタの水平バックポーチ                 DrawDispEvenBack
  1841:   //          (7e)描画フレームの垂直映像期間の偶数ラスタの水平映像期間                     DrawDispEvenDisp
  1842:   //        奇数ラスタ
  1843:   //          (4o)描画フレームの垂直映像期間の奇数ラスタの水平フロントポーチ               DrawDispOddFront
  1844:   //          (5o)描画フレームの垂直映像期間の奇数ラスタの水平同期パルス                   DrawDispOddSync
  1845:   //          (6o)描画フレームの垂直映像期間の奇数ラスタの水平バックポーチ                 DrawDispOddBack
  1846:   //          (7o)描画フレームの垂直映像期間の奇数ラスタの水平映像期間                     DrawDispOddDisp
  1847:   //    省略フレーム(間欠カウンタ!=0)
  1848:   //      省略フレームの垂直空白期間(垂直フロントポーチと垂直同期パルスと垂直バックポーチ)
  1849:   //        (8)省略フレームの垂直空白期間の水平フロントポーチ                              OmitIdleFront
  1850:   //        (9)省略フレームの垂直空白期間の水平同期パルス                                  OmitIdleSync
  1851:   //        (10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間                 OmitIdleBackDisp
  1852:   //      省略フレームの垂直映像期間
  1853:   //        奇偶共通
  1854:   //          (11)省略フレームの垂直映像期間の水平フロントポーチ                           OmitDispFront
  1855:   //          (12)省略フレームの垂直映像期間の水平同期パルス                               OmitDispSync
  1856:   //          (13)省略フレームの垂直映像期間の水平バックポーチと水平映像期間               OmitDispBackDisp
  1857:   //        偶数ラスタ
  1858:   //          (11e)省略フレームの垂直映像期間の偶数ラスタの水平フロントポーチ              OmitDispEvenFront
  1859:   //          (12e)省略フレームの垂直映像期間の偶数ラスタの水平同期パルス                  OmitDispEvenSync
  1860:   //          (13e)省略フレームの垂直映像期間の偶数ラスタの水平バックポーチと水平映像期間  OmitDispEvenBackDisp
  1861:   //        奇数ラスタ
  1862:   //          (11o)省略フレームの垂直映像期間の奇数ラスタの水平フロントポーチ              OmitDispOddFront
  1863:   //          (12o)省略フレームの垂直映像期間の奇数ラスタの水平同期パルス                  OmitDispOddSync
  1864:   //          (13o)省略フレームの垂直映像期間の奇数ラスタの水平バックポーチと水平映像期間  OmitDispOddBackDisp
  1865:   //
  1866: 
  1867:   public static void crtUpdateLength () {
  1868:     int k = crtHRLCurr << 3 | crtHighResoCurr << 2 | crtHResoCurr;
  1869:     double osc = (double) crtFreqs[CRT_OSCS[k]];  //オシレータ周波数
  1870:     int div = CRT_DIVS[k];  //分周比分母
  1871:     int vTotal = crtR04VFrontEndCurr + 1;
  1872:     double multiplier = 1.0;  //垂直同期周波数に掛ける数
  1873:     if (XEiJ.pnlAdjustVsync && XEiJ.pnlFixedRate != 0.0) {  //ホストのリフレッシュレートに合わせる、かつ、確定済み
  1874:       double hFreq = osc / (8 * div * crtHTotalColumn);  //水平同期周波数
  1875:       double vFreq = hFreq / vTotal;  //垂直同期周波数
  1876:       double rate = XEiJ.pnlFixedRate;  //ホストのリフレッシュレート
  1877:       if (vFreq * 0.75 <= rate && rate <= vFreq * 1.25) {  //ホストのリフレッシュレートが垂直同期周波数の0.75~1.25倍のとき
  1878:         multiplier = rate / vFreq;  //垂直同期周波数に掛ける数
  1879:       }
  1880:     }
  1881:     crtVsyncMultiplier = multiplier;
  1882:     crtColumnTime = (int) ((double) (XEiJ.TMR_FREQ * 8 * div) / (osc * multiplier) + 0.5);
  1883:     crtHSyncLength = crtColumnTime * crtHSyncColumn;
  1884:     crtHBackLength = crtColumnTime * crtHBackColumn;
  1885:     crtHDispLength = crtColumnTime * crtHDispColumn;
  1886:     crtHFrontLength = crtColumnTime * crtHFrontColumn;
  1887:     crtHBackDispLength = crtColumnTime * (crtHBackColumn + crtHDispColumn);
  1888:     long t = (long) crtColumnTime * (long) (crtHTotalColumn * vTotal);
  1889:     crtTotalLength = t / 1000000000L;  //ミリ
  1890:     crtTotalLengthMNP = t - 1000000000L * crtTotalLength;  //マイクロナノピコ
  1891:   }
  1892: 
  1893:   //----------------------------------------------------------------
  1894:   //  スクリーンの初期化
  1895:   public static final TickerQueue.Ticker InitialStage = new TickerQueue.Ticker () {
  1896:     @Override protected void tick () {
  1897:     ret:
  1898:       {
  1899:         //  水平映像期間は1カラム以上128カラム以下でなければならない
  1900:         //  垂直映像期間は1ラスタ以上1024ラスタ以下でなければならない
  1901:         //  垂直同期パルス、垂直バックポーチ、垂直フロントポーチはそれぞれ1ラスタ以上なければならない
  1902:         //  不正な値が設定されているときは停止して少し待つ
  1903:         //  同期信号が動かなくなるので不正な値を設定してから同期信号を待つようなプログラムは止まってしまう
  1904:         if (!(crtR02HBackEndCurr < crtR03HDispEndCurr && crtR03HDispEndCurr - crtR02HBackEndCurr <= 128 &&
  1905:               crtR07VDispEndCurr < crtR04VFrontEndCurr && crtR07VDispEndCurr - crtR06VBackEndCurr <= 1024 &&
  1906:               crtR05VSyncEndCurr < crtR06VBackEndCurr &&
  1907:               crtR06VBackEndCurr < crtR07VDispEndCurr)) {
  1908:           crtRestart ();
  1909:           break ret;
  1910:         }
  1911:         //
  1912:         if (CRT_RASTER_HASH_ON) {
  1913:           crtUpdateRasterHash ();
  1914:         }
  1915:         //  水平周期が水平映像期間よりも3カラム以上長くないとき
  1916:         //    水平周期を伸ばして水平同期パルスと水平バックポーチと水平フロントポーチをすべて1カラムにする
  1917:         //  水平周期が水平映像期間よりも3カラム以上長いとき
  1918:         //    必要ならば水平バックポーチと水平フロントポーチが1カラム以上なるように水平周期の中の水平映像期間の位置を調整する
  1919:         //    動作速度が変わってしまわないように、水平周期はなるべく変更しない
  1920:         //  調整するのは状態遷移の間隔だけで、CRTCの設定値は変更しない
  1921:         int hSync = crtR01HSyncEndCurr + 1;  //水平同期パルスカラム数。0以下は設定のしようがないので1以上
  1922:         int hBack = crtR02HBackEndCurr - crtR01HSyncEndCurr + 4;  //水平バックポーチカラム数。-1以上
  1923:         int hDisp = crtR03HDispEndCurr - crtR02HBackEndCurr;  //水平映像期間カラム数。0以下は除いてあるので1以上
  1924:         int hFront = crtR00HFrontEndCurr - crtR03HDispEndCurr - 4;  //水平フロントポーチカラム数。負数かも知れない
  1925:         if (hSync + hBack + hDisp + hFront < hDisp + 3) {  //水平周期が水平映像期間よりも3カラム以上長くないとき
  1926:           hSync = hBack = hFront = 1;  //水平周期を伸ばして水平同期パルスと水平バックポーチと水平フロントポーチをすべて1カラムにする
  1927:         } else {  //水平周期が水平映像期間よりも3カラム以上長いとき
  1928:           if (hBack <= 0) {  //左に寄り過ぎているとき
  1929:             hFront -= 1 - hBack;  //水平フロントポーチを削って
  1930:             hBack = 1;  //水平バックポーチを1にする
  1931:             if (hFront <= 0) {  //水平フロントポーチを削り過ぎたとき
  1932:               hSync -= 1 - hFront;  //水平同期パルスを削って
  1933:               hFront = 1;  //水平フロントポーチを1にする
  1934:             }
  1935:           } else if (hFront <= 0) {  //右に寄り過ぎているとき
  1936:             hBack -= 1 - hFront;  //水平バックポーチを削って
  1937:             hFront = 1;  //水平フロントポーチを1にする
  1938:             if (hBack <= 0) {  //水平バックポーチを削り過ぎたとき
  1939:               hSync -= 1 - hBack;  //水平同期パルスを削って
  1940:               hBack = 1;  //水平バックポーチを1にする
  1941:             }
  1942:           }
  1943:         }
  1944:         crtHSyncColumn = hSync;
  1945:         crtHBackColumn = hBack;
  1946:         crtHDispColumn = hDisp;
  1947:         crtHFrontColumn = hFront;
  1948:         crtHTotalColumn = hSync + hBack + hDisp + hFront;
  1949:         crtUpdateLength ();
  1950:         //
  1951:         crtDuplication = crtHighResoCurr == 1 && crtVResoCurr == 0 && ((SpriteScreen.sprReg8ResoCurr & 12) != 4);  //ラスタ2度読み
  1952:         crtInterlace = crtHighResoCurr + 1 <= crtVResoCurr;  //インターレース
  1953:         crtSlit = crtHighResoCurr == 0 && crtVResoCurr == 0;  //スリット
  1954:         crtDupExceptSp = crtHighResoCurr == 1 && crtVResoCurr == 0 && ((SpriteScreen.sprReg8ResoCurr & 12) == 4);  //ラスタ2度読み(スプライトを除く)
  1955:         //
  1956:         XEiJ.pnlUpdateArrangement ();
  1957:         //
  1958:         crtAllStamp += 2;
  1959:         (crtDuplication ? DuplicationStart :
  1960:          crtInterlace ? InterlaceStart :
  1961:          crtSlit ? SlitStart :
  1962:          crtDupExceptSp ? DupExceptSpStart :
  1963:          NormalStart).tick ();
  1964:       }  //ret
  1965:     }
  1966:   };
  1967: 
  1968:   //----------------------------------------------------------------
  1969:   //  ノーマル
  1970:   //    (0)開始(描画フレームの垂直空白期間開始ラスタの水平フロントポーチ)
  1971:   public static final TickerQueue.Ticker NormalStart = new TickerQueue.Ticker () {
  1972:     @Override protected void tick () {
  1973:       if (MC68901.mfpGpipHsync != 0) {
  1974:         MC68901.mfpHsyncFall ();  //水平同期パルス終了
  1975:       }
  1976:       int n = crtRasterNumber = crtVIdleStart;  //ラスタ番号は垂直空白期間開始ラスタ
  1977:       if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  1978:         crtDoRasterCopy ();  //ラスタコピー実行
  1979:       }
  1980:       if (RasterBreakPoint.RBP_ON) {
  1981:         if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  1982:           RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  1983:         }
  1984:       }
  1985:       int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  1986:       if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  1987:         if (irq == 0) {  //IRQ信号が0になったとき
  1988:           if (RasterBreakPoint.RBP_ON) {
  1989:             if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  1990:               RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  1991:             }
  1992:           }
  1993:           MC68901.mfpRintFall ();  //IRQ開始
  1994:         } else {  //IRQ信号が0でなくなったとき
  1995:           MC68901.mfpRintRise ();  //IRQ終了
  1996:         }
  1997:       }
  1998:       if (MC68901.mfpGpipVdisp != 0) {
  1999:         MC68901.mfpVdispFall ();  //垂直映像期間終了
  2000:       }
  2001:       crtClearFrames = 0;  //高速クリアカウンタを0で初期化
  2002:       if (CRT_ENABLE_INTERMITTENT) {
  2003:         crtIntermittentCounter = 0;  //間欠カウンタを0で初期化(描画フレーム)
  2004:       }
  2005:       if (!XEiJ.PNL_USE_THREAD) {
  2006:         if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  2007:           crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  2008:         }
  2009:       }
  2010:       TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  2011:     }
  2012:   };
  2013:   //    (1)描画フレームの垂直空白期間の水平フロントポーチ
  2014:   public static final TickerQueue.Ticker NormalDrawIdleFront = new TickerQueue.Ticker () {
  2015:     @Override protected void tick () {
  2016:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2017:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2018:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  2019:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  2020:         }
  2021:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2022:           crtDoRasterCopy ();  //ラスタコピー実行
  2023:         }
  2024:         if (RasterBreakPoint.RBP_ON) {
  2025:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2026:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2027:           }
  2028:         }
  2029:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2030:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2031:           if (irq == 0) {  //IRQ信号が0になったとき
  2032:             if (RasterBreakPoint.RBP_ON) {
  2033:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2034:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2035:               }
  2036:             }
  2037:             MC68901.mfpRintFall ();  //IRQ開始
  2038:           } else {  //IRQ信号が0でなくなったとき
  2039:             MC68901.mfpRintRise ();  //IRQ終了
  2040:           }
  2041:         }
  2042:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  2043:           TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  2044:         } else {  //垂直映像期間開始ラスタのとき
  2045:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  2046:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  2047:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  2048:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  2049:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  2050:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  2051:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  2052:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  2053:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  2054:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  2055:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  2056:             crtR11TxYZeroLast = crtR11TxYZero;
  2057:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  2058:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  2059:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  2060:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  2061:             crtAllStamp += 2;
  2062:           }
  2063:           crtDataY = 0;  //データY座標を0で初期化
  2064:           if (crtClearStandby) {  //高速クリアの要求があるとき
  2065:             crtClearStandby = false;
  2066:             crtClearFrames = 1;  //高速クリアカウンタを1で初期化
  2067:           }
  2068:           crtScreenY = 0;  //スクリーンY座標を0で初期化
  2069:           if (!XEiJ.PNL_USE_THREAD) {
  2070:             crtDirtyY0 = -1;  //ダーティフラグをクリア
  2071:           }
  2072:           if (XEiJ.PNL_USE_THREAD) {
  2073:             crtAllStamp += 2;
  2074:           }
  2075:           if (SpriteScreen.SPR_THREE_STEPS) {
  2076:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  2077:             if (SpriteScreen.sprActive) {
  2078:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  2079:                 SpriteScreen.sprLatched = false;
  2080:               }
  2081:               if (!XEiJ.PNL_USE_THREAD) {
  2082:                 crtAllStamp += 2;
  2083:               }
  2084:               //ラスタ(dst=-2,src=-2)
  2085:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  2086:               SpriteScreen.sprSwap ();  //表(0)と裏(-1)を入れ換える
  2087:               //ラスタ(dst=-1,src=-1)
  2088:               //表(-1)を表(1)として再利用する
  2089:               SpriteScreen.sprStep1 (1);  //表(1)にスプライト(1)を並べる
  2090:               SpriteScreen.sprSwap ();  //表(1)と裏(0)を入れ換える
  2091:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  2092:             }
  2093:           }
  2094:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2095:             crtStereoscopicStart ();
  2096:           }
  2097:           TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5)描画フレームの垂直映像期間の水平同期パルス
  2098:         }
  2099:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  2100:         //垂直映像期間開始ラスタではないとき
  2101:         TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  2102:       }
  2103:     }
  2104:   };
  2105:   //    (2)描画フレームの垂直空白期間の水平同期パルス
  2106:   public static final TickerQueue.Ticker NormalDrawIdleSync = new TickerQueue.Ticker () {
  2107:     @Override protected void tick () {
  2108:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  2109:       TickerQueue.tkqAdd (crtTicker = NormalDrawIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  2110:     }
  2111:   };
  2112:   //    (3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  2113:   public static final TickerQueue.Ticker NormalDrawIdleBackDisp = new TickerQueue.Ticker () {
  2114:     @Override protected void tick () {
  2115:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  2116:       TickerQueue.tkqAdd (crtTicker = NormalDrawIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(1)描画フレームの垂直空白期間の水平フロントポーチ
  2117:     }
  2118:   };
  2119:   //    (4)描画フレームの垂直映像期間の水平フロントポーチ
  2120:   public static final TickerQueue.Ticker NormalDrawDispFront = new TickerQueue.Ticker () {
  2121:     @Override protected void tick () {
  2122:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2123:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2124:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2125:           crtDoRasterCopy ();  //ラスタコピー実行
  2126:         }
  2127:         if (RasterBreakPoint.RBP_ON) {
  2128:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2129:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2130:           }
  2131:         }
  2132:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2133:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2134:           if (irq == 0) {  //IRQ信号が0になったとき
  2135:             if (RasterBreakPoint.RBP_ON) {
  2136:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2137:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2138:               }
  2139:             }
  2140:             MC68901.mfpRintFall ();  //IRQ開始
  2141:           } else {  //IRQ信号が0でなくなったとき
  2142:             MC68901.mfpRintRise ();  //IRQ終了
  2143:           }
  2144:         }
  2145:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  2146:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  2147:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  2148:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2149:               crtStereoscopicDrawRaster (crtScreenY);
  2150:             }
  2151:           }
  2152:           crtScreenY++;  //スクリーンY座標を1増やす
  2153:           crtDataY++;  //データY座標を1増やす
  2154:           TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5)描画フレームの垂直映像期間の水平同期パルス
  2155:         } else {  //垂直空白期間開始ラスタのとき
  2156:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  2157:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  2158:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2159:               crtStereoscopicDrawRaster (crtScreenY);
  2160:             }
  2161:           }
  2162:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  2163:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  2164:             crtClearFrames--;  //高速クリアカウンタを1減らす
  2165:           }
  2166:           if (!XEiJ.PNL_USE_THREAD) {
  2167:             if (crtDirtyY0 >= 0) {  //ダーティフラグがセットされているとき
  2168:               crtUpdateScreen ();  //スクリーンを更新する
  2169:               if (CRT_ENABLE_INTERMITTENT) {
  2170:                 crtIntermittentCounter = crtIntermittentInterval;  //間欠カウンタを間欠間隔に戻す
  2171:               }
  2172:             }
  2173:           }
  2174:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  2175:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  2176:           }
  2177:           if (XEiJ.PNL_USE_THREAD) {
  2178:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  2179:           }
  2180:           TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  2181:         }
  2182:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  2183:         //垂直空白期間開始ラスタではないとき
  2184:         if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  2185:           VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  2186:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2187:             crtStereoscopicDrawRaster (crtScreenY);
  2188:           }
  2189:         }
  2190:         crtScreenY++;  //スクリーンY座標を1増やす
  2191:         crtDataY++;  //データY座標を1増やす
  2192:         TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5)描画フレームの垂直映像期間の水平同期パルス
  2193:       }
  2194:     }
  2195:   };
  2196:   //    (5)描画フレームの垂直映像期間の水平同期パルス
  2197:   public static final TickerQueue.Ticker NormalDrawDispSync = new TickerQueue.Ticker () {
  2198:     @Override protected void tick () {
  2199:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  2200:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  2201:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  2202:         crtRasterStamp[crtDataY] = 0;
  2203:       }
  2204:       TickerQueue.tkqAdd (crtTicker = NormalDrawDispBack, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(6)描画フレームの垂直映像期間の水平バックポーチ
  2205:     }
  2206:   };
  2207:   //    (6)描画フレームの垂直映像期間の水平バックポーチ
  2208:   public static final TickerQueue.Ticker NormalDrawDispBack = new TickerQueue.Ticker () {
  2209:     @Override protected void tick () {
  2210:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  2211:       TickerQueue.tkqAdd (crtTicker = NormalDrawDispDisp, crtClock += crtHBackLength);  //+水平バックポーチの長さ→(7)描画フレームの垂直映像期間の水平映像期間
  2212:     }
  2213:   };
  2214:   //    (7)描画フレームの垂直映像期間の水平映像期間
  2215:   public static final TickerQueue.Ticker NormalDrawDispDisp = new TickerQueue.Ticker () {
  2216:     @Override protected void tick () {
  2217:       if (crtRasterStamp[crtDataY] != crtAllStamp) {  //ラスタの更新フラグがセットされているとき
  2218:         crtRasterStamp[crtDataY] = crtAllStamp;  //ラスタの更新フラグをクリア
  2219:         crtBeginningAllStamp = crtAllStamp;  //全再描画スタンプを水平映像期間開始時の全再描画スタンプにコピー
  2220:         VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);  //データY座標からスクリーンY座標へ描画
  2221:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2222:           crtStereoscopicDrawRaster (crtScreenY);
  2223:         }
  2224:         if (!XEiJ.PNL_USE_THREAD) {
  2225:           if (crtDirtyY0 < 0) {
  2226:             crtDirtyY0 = crtScreenY;  //ダーティフラグをセット
  2227:           }
  2228:           crtDirtyY1 = crtScreenY;
  2229:         }
  2230:       }
  2231:       if (SpriteScreen.SPR_THREE_STEPS) {
  2232:         if (SpriteScreen.sprActive) {
  2233:           //ラスタ(dst=src)
  2234:           //表(dst)を表(dst+2)として再利用する
  2235:           SpriteScreen.sprStep1 (crtDataY + 2);  //表(dst+2)にスプライト(src+2)を並べる
  2236:           SpriteScreen.sprSwap ();  //表(dst+2)と裏(dst+1)を入れ換える
  2237:           SpriteScreen.sprStep2 (crtDataY + 1);  //表(dst+1)にバックグラウンド(src+1)を並べる
  2238:         }
  2239:       }
  2240:       TickerQueue.tkqAdd (crtTicker = NormalDrawDispFront, crtClock += crtHDispLength);  //+水平水平映像期間の長さ→(4)描画フレームの垂直映像期間の水平フロントポーチ
  2241:     }
  2242:   };
  2243:   //    (8)省略フレームの垂直空白期間の水平フロントポーチ
  2244:   public static final TickerQueue.Ticker NormalOmitIdleFront = new TickerQueue.Ticker () {
  2245:     @Override protected void tick () {
  2246:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2247:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2248:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  2249:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  2250:         }
  2251:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2252:           crtDoRasterCopy ();  //ラスタコピー実行
  2253:         }
  2254:         if (RasterBreakPoint.RBP_ON) {
  2255:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2256:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2257:           }
  2258:         }
  2259:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2260:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2261:           if (irq == 0) {  //IRQ信号が0になったとき
  2262:             if (RasterBreakPoint.RBP_ON) {
  2263:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2264:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2265:               }
  2266:             }
  2267:             MC68901.mfpRintFall ();  //IRQ開始
  2268:           } else {  //IRQ信号が0でなくなったとき
  2269:             MC68901.mfpRintRise ();  //IRQ終了
  2270:           }
  2271:         }
  2272:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  2273:           TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  2274:         } else {  //垂直映像期間開始ラスタのとき
  2275:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  2276:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  2277:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  2278:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  2279:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  2280:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  2281:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  2282:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  2283:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  2284:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  2285:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  2286:             crtR11TxYZeroLast = crtR11TxYZero;
  2287:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  2288:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  2289:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  2290:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  2291:             crtAllStamp += 2;
  2292:           }
  2293:           crtDataY = 0;  //データY座標を0で初期化
  2294:           if (crtClearStandby) {  //高速クリアの要求があるとき
  2295:             crtClearStandby = false;
  2296:             crtClearFrames = 1;  //高速クリアカウンタを1で初期化
  2297:           }
  2298:           if (XEiJ.PNL_USE_THREAD) {
  2299:             crtAllStamp += 2;
  2300:           }
  2301:           if (SpriteScreen.SPR_THREE_STEPS) {
  2302:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  2303:             if (SpriteScreen.sprActive) {
  2304:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  2305:                 SpriteScreen.sprLatched = false;
  2306:               }
  2307:               if (!XEiJ.PNL_USE_THREAD) {
  2308:                 crtAllStamp += 2;
  2309:               }
  2310:               //ラスタ(dst=-2,src=-2)
  2311:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  2312:               SpriteScreen.sprSwap ();  //表(0)と裏(-1)を入れ換える
  2313:               //ラスタ(dst=-1,src=-1)
  2314:               //表(-1)を表(1)として再利用する
  2315:               SpriteScreen.sprStep1 (1);  //表(1)にスプライト(1)を並べる
  2316:               SpriteScreen.sprSwap ();  //表(1)と裏(0)を入れ換える
  2317:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  2318:             }
  2319:           }
  2320:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2321:             crtStereoscopicStart ();
  2322:           }
  2323:           TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12)省略フレームの垂直映像期間の水平同期パルス
  2324:         }
  2325:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  2326:         //垂直映像期間開始ラスタではないとき
  2327:         TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  2328:       }
  2329:     }
  2330:   };
  2331:   //    (9)省略フレームの垂直空白期間の水平同期パルス
  2332:   public static final TickerQueue.Ticker NormalOmitIdleSync = new TickerQueue.Ticker () {
  2333:     @Override protected void tick () {
  2334:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  2335:       TickerQueue.tkqAdd (crtTicker = NormalOmitIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  2336:     }
  2337:   };
  2338:   //    (10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  2339:   public static final TickerQueue.Ticker NormalOmitIdleBackDisp = new TickerQueue.Ticker () {
  2340:     @Override protected void tick () {
  2341:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  2342:       TickerQueue.tkqAdd (crtTicker = NormalOmitIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(8)省略フレームの垂直空白期間の水平フロントポーチ
  2343:     }
  2344:   };
  2345:   //    (11)省略フレームの垂直映像期間の水平フロントポーチ
  2346:   public static final TickerQueue.Ticker NormalOmitDispFront = new TickerQueue.Ticker () {
  2347:     @Override protected void tick () {
  2348:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2349:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2350:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2351:           crtDoRasterCopy ();  //ラスタコピー実行
  2352:         }
  2353:         if (RasterBreakPoint.RBP_ON) {
  2354:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2355:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2356:           }
  2357:         }
  2358:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2359:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2360:           if (irq == 0) {  //IRQ信号が0になったとき
  2361:             if (RasterBreakPoint.RBP_ON) {
  2362:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2363:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2364:               }
  2365:             }
  2366:             MC68901.mfpRintFall ();  //IRQ開始
  2367:           } else {  //IRQ信号が0でなくなったとき
  2368:             MC68901.mfpRintRise ();  //IRQ終了
  2369:           }
  2370:         }
  2371:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  2372:           TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12)省略フレームの垂直映像期間の水平同期パルス
  2373:         } else {  //垂直空白期間開始ラスタのとき
  2374:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  2375:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  2376:             crtClearFrames--;  //高速クリアカウンタを1減らす
  2377:           }
  2378:           if (CRT_ENABLE_INTERMITTENT) {
  2379:             crtIntermittentCounter--;  //間欠カウンタを1減らす
  2380:           }
  2381:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  2382:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  2383:           }
  2384:           if (XEiJ.PNL_USE_THREAD) {
  2385:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  2386:           }
  2387:           TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  2388:         }
  2389:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  2390:         //垂直空白期間開始ラスタではないとき
  2391:         TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12)省略フレームの垂直映像期間の水平同期パルス
  2392:       }
  2393:     }
  2394:   };
  2395:   //    (12)省略フレームの垂直映像期間の水平同期パルス
  2396:   public static final TickerQueue.Ticker NormalOmitDispSync = new TickerQueue.Ticker () {
  2397:     @Override protected void tick () {
  2398:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  2399:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  2400:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  2401:         crtRasterStamp[crtDataY] = 0;
  2402:       }
  2403:       TickerQueue.tkqAdd (crtTicker = NormalOmitDispBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(13)省略フレームの垂直映像期間の水平バックポーチと水平映像期間
  2404:     }
  2405:   };
  2406:   //    (13)省略フレームの垂直映像期間の水平バックポーチと水平映像期間
  2407:   public static final TickerQueue.Ticker NormalOmitDispBackDisp = new TickerQueue.Ticker () {
  2408:     @Override protected void tick () {
  2409:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  2410:       TickerQueue.tkqAdd (crtTicker = NormalOmitDispFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(11)省略フレームの垂直映像期間の水平フロントポーチ
  2411:     }
  2412:   };
  2413: 
  2414:   //----------------------------------------------------------------
  2415:   //  ラスタ2度読み
  2416:   //    (0)開始(描画フレームの垂直空白期間開始ラスタの水平フロントポーチ)
  2417:   public static final TickerQueue.Ticker DuplicationStart = new TickerQueue.Ticker () {
  2418:     @Override protected void tick () {
  2419:       if (MC68901.mfpGpipHsync != 0) {
  2420:         MC68901.mfpHsyncFall ();  //水平同期パルス終了
  2421:       }
  2422:       int n = crtRasterNumber = crtVIdleStart;  //ラスタ番号は垂直空白期間開始ラスタ
  2423:       if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2424:         crtDoRasterCopy ();  //ラスタコピー実行
  2425:       }
  2426:       if (RasterBreakPoint.RBP_ON) {
  2427:         if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2428:           RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2429:         }
  2430:       }
  2431:       int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2432:       if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2433:         if (irq == 0) {  //IRQ信号が0になったとき
  2434:           if (RasterBreakPoint.RBP_ON) {
  2435:             if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2436:               RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2437:             }
  2438:           }
  2439:           MC68901.mfpRintFall ();  //IRQ開始
  2440:         } else {  //IRQ信号が0でなくなったとき
  2441:           MC68901.mfpRintRise ();  //IRQ終了
  2442:         }
  2443:       }
  2444:       if (MC68901.mfpGpipVdisp != 0) {
  2445:         MC68901.mfpVdispFall ();  //垂直映像期間終了
  2446:       }
  2447:       crtClearFrames = 0;  //高速クリアカウンタを0で初期化
  2448:       if (CRT_ENABLE_INTERMITTENT) {
  2449:         crtIntermittentCounter = 0;  //間欠カウンタを0で初期化(描画フレーム)
  2450:       }
  2451:       if (!XEiJ.PNL_USE_THREAD) {
  2452:         if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  2453:           crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  2454:         }
  2455:       }
  2456:       TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  2457:     }
  2458:   };
  2459:   //    (1)描画フレームの垂直空白期間の水平フロントポーチ
  2460:   public static final TickerQueue.Ticker DuplicationDrawIdleFront = new TickerQueue.Ticker () {
  2461:     @Override protected void tick () {
  2462:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2463:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2464:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  2465:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  2466:         }
  2467:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2468:           crtDoRasterCopy ();  //ラスタコピー実行
  2469:         }
  2470:         if (RasterBreakPoint.RBP_ON) {
  2471:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2472:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2473:           }
  2474:         }
  2475:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2476:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2477:           if (irq == 0) {  //IRQ信号が0になったとき
  2478:             if (RasterBreakPoint.RBP_ON) {
  2479:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2480:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2481:               }
  2482:             }
  2483:             MC68901.mfpRintFall ();  //IRQ開始
  2484:           } else {  //IRQ信号が0でなくなったとき
  2485:             MC68901.mfpRintRise ();  //IRQ終了
  2486:           }
  2487:         }
  2488:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  2489:           TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  2490:         } else {  //垂直映像期間開始ラスタのとき
  2491:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  2492:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  2493:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  2494:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  2495:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  2496:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  2497:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  2498:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  2499:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  2500:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  2501:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  2502:             crtR11TxYZeroLast = crtR11TxYZero;
  2503:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  2504:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  2505:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  2506:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  2507:             crtAllStamp += 2;
  2508:           }
  2509:           crtDataY = 0;  //データY座標を0で初期化
  2510:           if (crtClearStandby) {  //高速クリアの要求があるとき
  2511:             crtClearStandby = false;
  2512:             crtClearFrames = 1;  //高速クリアカウンタを1で初期化
  2513:           }
  2514:           crtScreenY = 0;  //スクリーンY座標を0で初期化
  2515:           if (!XEiJ.PNL_USE_THREAD) {
  2516:             crtDirtyY0 = -1;  //ダーティフラグをクリア
  2517:           }
  2518:           if (XEiJ.PNL_USE_THREAD) {
  2519:             crtAllStamp += 2;
  2520:           }
  2521:           if (SpriteScreen.SPR_THREE_STEPS) {
  2522:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  2523:             if (SpriteScreen.sprActive) {
  2524:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  2525:                 SpriteScreen.sprLatched = false;
  2526:               }
  2527:               if (!XEiJ.PNL_USE_THREAD) {
  2528:                 crtAllStamp += 2;
  2529:               }
  2530:               //偶数ラスタ(dst=-2,src=-1)
  2531:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  2532:               SpriteScreen.sprSwap ();  //表(0)と裏(-1)を入れ換える
  2533:               //奇数ラスタ(dst=-1,src=-1)
  2534:               //表(-1)を表(1)として再利用する
  2535:               SpriteScreen.sprStep1 (0);  //表(1)にスプライト(0)を並べる
  2536:               SpriteScreen.sprSwap ();  //表(1)と裏(0)を入れ換える
  2537:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  2538:             }
  2539:           }
  2540:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2541:             crtStereoscopicStart ();
  2542:           }
  2543:           TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5e)描画フレームの垂直映像期間の偶数ラスタの水平同期パルス
  2544:         }
  2545:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  2546:         //垂直映像期間開始ラスタではないとき
  2547:         TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  2548:       }
  2549:     }
  2550:   };
  2551:   //    (2)描画フレームの垂直空白期間の水平同期パルス
  2552:   public static final TickerQueue.Ticker DuplicationDrawIdleSync = new TickerQueue.Ticker () {
  2553:     @Override protected void tick () {
  2554:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  2555:       TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  2556:     }
  2557:   };
  2558:   //    (3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  2559:   public static final TickerQueue.Ticker DuplicationDrawIdleBackDisp = new TickerQueue.Ticker () {
  2560:     @Override protected void tick () {
  2561:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  2562:       TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(1)描画フレームの垂直空白期間の水平フロントポーチ
  2563:     }
  2564:   };
  2565:   //    (4e)描画フレームの垂直映像期間の偶数ラスタの水平フロントポーチ
  2566:   public static final TickerQueue.Ticker DuplicationDrawDispEvenFront = new TickerQueue.Ticker () {
  2567:     @Override protected void tick () {
  2568:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2569:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2570:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2571:           crtDoRasterCopy ();  //ラスタコピー実行
  2572:         }
  2573:         if (RasterBreakPoint.RBP_ON) {
  2574:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2575:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2576:           }
  2577:         }
  2578:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2579:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2580:           if (irq == 0) {  //IRQ信号が0になったとき
  2581:             if (RasterBreakPoint.RBP_ON) {
  2582:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2583:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2584:               }
  2585:             }
  2586:             MC68901.mfpRintFall ();  //IRQ開始
  2587:           } else {  //IRQ信号が0でなくなったとき
  2588:             MC68901.mfpRintRise ();  //IRQ終了
  2589:           }
  2590:         }
  2591:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  2592:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  2593:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  2594:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2595:               crtStereoscopicDrawRaster (crtScreenY);
  2596:             }
  2597:           }
  2598:           crtScreenY++;  //スクリーンY座標を1増やす
  2599:           crtDataY++;  //データY座標を1増やす
  2600:           TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5e)描画フレームの垂直映像期間の偶数ラスタの水平同期パルス
  2601:         } else {  //垂直空白期間開始ラスタのとき
  2602:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  2603:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  2604:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2605:               crtStereoscopicDrawRaster (crtScreenY);
  2606:             }
  2607:           }
  2608:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  2609:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  2610:             crtClearFrames--;  //高速クリアカウンタを1減らす
  2611:           }
  2612:           if (!XEiJ.PNL_USE_THREAD) {
  2613:             if (crtDirtyY0 >= 0) {  //ダーティフラグがセットされているとき
  2614:               crtUpdateScreen ();  //スクリーンを更新する
  2615:               if (CRT_ENABLE_INTERMITTENT) {
  2616:                 crtIntermittentCounter = crtIntermittentInterval;  //間欠カウンタを間欠間隔に戻す
  2617:               }
  2618:             }
  2619:           }
  2620:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  2621:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  2622:           }
  2623:           if (XEiJ.PNL_USE_THREAD) {
  2624:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  2625:           }
  2626:           TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  2627:         }
  2628:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  2629:         //垂直空白期間開始ラスタではないとき
  2630:         if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  2631:           VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  2632:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2633:             crtStereoscopicDrawRaster (crtScreenY);
  2634:           }
  2635:         }
  2636:         crtScreenY++;  //スクリーンY座標を1増やす
  2637:         crtDataY++;  //データY座標を1増やす
  2638:         TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5e)描画フレームの垂直映像期間の偶数ラスタの水平同期パルス
  2639:       }
  2640:     }
  2641:   };
  2642:   //    (4o)描画フレームの垂直映像期間の奇数ラスタの水平フロントポーチ
  2643:   public static final TickerQueue.Ticker DuplicationDrawDispOddFront = new TickerQueue.Ticker () {
  2644:     @Override protected void tick () {
  2645:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2646:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2647:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2648:           crtDoRasterCopy ();  //ラスタコピー実行
  2649:         }
  2650:         if (RasterBreakPoint.RBP_ON) {
  2651:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2652:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2653:           }
  2654:         }
  2655:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2656:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2657:           if (irq == 0) {  //IRQ信号が0になったとき
  2658:             if (RasterBreakPoint.RBP_ON) {
  2659:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2660:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2661:               }
  2662:             }
  2663:             MC68901.mfpRintFall ();  //IRQ開始
  2664:           } else {  //IRQ信号が0でなくなったとき
  2665:             MC68901.mfpRintRise ();  //IRQ終了
  2666:           }
  2667:         }
  2668:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  2669:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  2670:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  2671:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2672:               crtStereoscopicDrawRaster (crtScreenY);
  2673:             }
  2674:           }
  2675:           crtScreenY++;  //スクリーンY座標を1増やす
  2676:           TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5o)描画フレームの垂直映像期間の奇数ラスタの水平同期パルス
  2677:         } else {  //垂直空白期間開始ラスタのとき
  2678:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  2679:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  2680:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2681:               crtStereoscopicDrawRaster (crtScreenY);
  2682:             }
  2683:           }
  2684:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  2685:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  2686:             crtClearFrames--;  //高速クリアカウンタを1減らす
  2687:           }
  2688:           if (!XEiJ.PNL_USE_THREAD) {
  2689:             if (crtDirtyY0 >= 0) {  //ダーティフラグがセットされているとき
  2690:               crtUpdateScreen ();  //スクリーンを更新する
  2691:               if (CRT_ENABLE_INTERMITTENT) {
  2692:                 crtIntermittentCounter = crtIntermittentInterval;  //間欠カウンタを間欠間隔に戻す
  2693:               }
  2694:             }
  2695:           }
  2696:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  2697:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  2698:           }
  2699:           if (XEiJ.PNL_USE_THREAD) {
  2700:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  2701:           }
  2702:           TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  2703:         }
  2704:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  2705:         //垂直空白期間開始ラスタではないとき
  2706:         if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  2707:           VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  2708:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2709:             crtStereoscopicDrawRaster (crtScreenY);
  2710:           }
  2711:         }
  2712:         crtScreenY++;  //スクリーンY座標を1増やす
  2713:         TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5o)描画フレームの垂直映像期間の奇数ラスタの水平同期パルス
  2714:       }
  2715:     }
  2716:   };
  2717:   //    (5e)描画フレームの垂直映像期間の偶数ラスタの水平同期パルス
  2718:   public static final TickerQueue.Ticker DuplicationDrawDispEvenSync = new TickerQueue.Ticker () {
  2719:     @Override protected void tick () {
  2720:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  2721:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  2722:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  2723:         crtRasterStamp[crtDataY] = 0;
  2724:       }
  2725:       TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenBack, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(6e)描画フレームの垂直映像期間の偶数ラスタの水平バックポーチ
  2726:     }
  2727:   };
  2728:   //    (5o)描画フレームの垂直映像期間の奇数ラスタの水平同期パルス
  2729:   public static final TickerQueue.Ticker DuplicationDrawDispOddSync = new TickerQueue.Ticker () {
  2730:     @Override protected void tick () {
  2731:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  2732:       TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddBack, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(6o)描画フレームの垂直映像期間の奇数ラスタの水平バックポーチ
  2733:     }
  2734:   };
  2735:   //    (6e)描画フレームの垂直映像期間の偶数ラスタの水平バックポーチ
  2736:   public static final TickerQueue.Ticker DuplicationDrawDispEvenBack = new TickerQueue.Ticker () {
  2737:     @Override protected void tick () {
  2738:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  2739:       TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenDisp, crtClock += crtHBackLength);  //+水平バックポーチの長さ→(7e)描画フレームの垂直映像期間の偶数ラスタの水平映像期間
  2740:     }
  2741:   };
  2742:   //    (6o)描画フレームの垂直映像期間の奇数ラスタの水平バックポーチ
  2743:   public static final TickerQueue.Ticker DuplicationDrawDispOddBack = new TickerQueue.Ticker () {
  2744:     @Override protected void tick () {
  2745:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  2746:       TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddDisp, crtClock += crtHBackLength);  //+水平バックポーチの長さ→(7o)描画フレームの垂直映像期間の奇数ラスタの水平映像期間
  2747:     }
  2748:   };
  2749:   //    (7e)描画フレームの垂直映像期間の偶数ラスタの水平映像期間
  2750:   public static final TickerQueue.Ticker DuplicationDrawDispEvenDisp = new TickerQueue.Ticker () {
  2751:     @Override protected void tick () {
  2752:       if (crtRasterStamp[crtDataY] != crtAllStamp) {  //ラスタの更新フラグがセットされているとき
  2753:         crtBeginningAllStamp = crtAllStamp;  //全再描画スタンプを水平映像期間開始時の全再描画スタンプにコピー
  2754:         VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);  //データY座標からスクリーンY座標へ描画
  2755:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2756:           crtStereoscopicDrawRaster (crtScreenY);
  2757:         }
  2758:         if (!XEiJ.PNL_USE_THREAD) {
  2759:           if (crtDirtyY0 < 0) {
  2760:             crtDirtyY0 = crtScreenY;  //ダーティフラグをセット
  2761:           }
  2762:           crtDirtyY1 = crtScreenY;  //偶数ラスタで終了する可能性があるので偶数ラスタでもcrtDirtyY1を更新する
  2763:         }
  2764:       }
  2765:       if (SpriteScreen.SPR_THREE_STEPS) {
  2766:         if (SpriteScreen.sprActive) {
  2767:           //偶数ラスタ(dst=src*2)
  2768:           //表(dst)を表(dst+2)として再利用する
  2769:           SpriteScreen.sprStep1 (crtDataY + 1);  //表(dst+2)にスプライト(src+1)を並べる
  2770:           SpriteScreen.sprSwap ();  //表(dst+2)と裏(dst+1)を入れ換える
  2771:           SpriteScreen.sprStep2 (crtDataY);  //表(dst+1)にバックグラウンド(src)を並べる
  2772:         }
  2773:       }
  2774:       TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddFront, crtClock += crtHDispLength);  //+水平水平映像期間の長さ→(4o)描画フレームの垂直映像期間の奇数ラスタの水平フロントポーチ
  2775:     }
  2776:   };
  2777:   //    (7o)描画フレームの垂直映像期間の奇数ラスタの水平映像期間
  2778:   public static final TickerQueue.Ticker DuplicationDrawDispOddDisp = new TickerQueue.Ticker () {
  2779:     @Override protected void tick () {
  2780:       if (crtRasterStamp[crtDataY] != crtAllStamp) {  //ラスタの更新フラグがセットされているとき
  2781:         crtRasterStamp[crtDataY] = crtAllStamp;  //ラスタの更新フラグをクリア
  2782:         crtBeginningAllStamp = crtAllStamp;  //全再描画スタンプを水平映像期間開始時の全再描画スタンプにコピー
  2783:         VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);  //データY座標からスクリーンY座標へ描画
  2784:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2785:           crtStereoscopicDrawRaster (crtScreenY);
  2786:         }
  2787:         if (!XEiJ.PNL_USE_THREAD) {
  2788:           if (crtDirtyY0 < 0) {
  2789:             crtDirtyY0 = crtScreenY;  //ダーティフラグをセット。奇数ラスタの直前でパレットやスクロール位置が変化したとき偶数ラスタでcrtDirtyY0が更新されていない可能性があるので奇数ラスタでもcrtDirtyY0を更新する
  2790:           }
  2791:           crtDirtyY1 = crtScreenY;
  2792:         }
  2793:       }
  2794:       if (SpriteScreen.SPR_THREE_STEPS) {
  2795:         if (SpriteScreen.sprActive) {
  2796:           //奇数ラスタ(dst=src*2+1)
  2797:           //表(dst)を表(dst+2)として再利用する
  2798:           SpriteScreen.sprStep1 (crtDataY + 1);  //表(dst+2)にスプライト(src+1)を並べる
  2799:           SpriteScreen.sprSwap ();  //表(dst+2)と裏(dst+1)を入れ換える
  2800:           SpriteScreen.sprStep2 (crtDataY + 1);  //表(dst+1)にバックグラウンド(src+1)を並べる
  2801:         }
  2802:       }
  2803:       TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenFront, crtClock += crtHDispLength);  //+水平水平映像期間の長さ→(4e)描画フレームの垂直映像期間の偶数ラスタの水平フロントポーチ
  2804:     }
  2805:   };
  2806:   //    (8)省略フレームの垂直空白期間の水平フロントポーチ
  2807:   public static final TickerQueue.Ticker DuplicationOmitIdleFront = new TickerQueue.Ticker () {
  2808:     @Override protected void tick () {
  2809:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2810:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2811:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  2812:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  2813:         }
  2814:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2815:           crtDoRasterCopy ();  //ラスタコピー実行
  2816:         }
  2817:         if (RasterBreakPoint.RBP_ON) {
  2818:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2819:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2820:           }
  2821:         }
  2822:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2823:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2824:           if (irq == 0) {  //IRQ信号が0になったとき
  2825:             if (RasterBreakPoint.RBP_ON) {
  2826:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2827:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2828:               }
  2829:             }
  2830:             MC68901.mfpRintFall ();  //IRQ開始
  2831:           } else {  //IRQ信号が0でなくなったとき
  2832:             MC68901.mfpRintRise ();  //IRQ終了
  2833:           }
  2834:         }
  2835:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  2836:           TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  2837:         } else {  //垂直映像期間開始ラスタのとき
  2838:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  2839:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  2840:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  2841:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  2842:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  2843:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  2844:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  2845:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  2846:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  2847:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  2848:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  2849:             crtR11TxYZeroLast = crtR11TxYZero;
  2850:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  2851:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  2852:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  2853:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  2854:             crtAllStamp += 2;
  2855:           }
  2856:           crtDataY = 0;  //データY座標を0で初期化
  2857:           if (crtClearStandby) {  //高速クリアの要求があるとき
  2858:             crtClearStandby = false;
  2859:             crtClearFrames = 1;  //高速クリアカウンタを1で初期化
  2860:           }
  2861:           if (XEiJ.PNL_USE_THREAD) {
  2862:             crtAllStamp += 2;
  2863:           }
  2864:           if (SpriteScreen.SPR_THREE_STEPS) {
  2865:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  2866:             if (SpriteScreen.sprActive) {
  2867:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  2868:                 SpriteScreen.sprLatched = false;
  2869:               }
  2870:               if (!XEiJ.PNL_USE_THREAD) {
  2871:                 crtAllStamp += 2;
  2872:               }
  2873:               //偶数ラスタ(dst=-2,src=-1)
  2874:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  2875:               SpriteScreen.sprSwap ();  //表(0)と裏(-1)を入れ換える
  2876:               //奇数ラスタ(dst=-1,src=-1)
  2877:               //表(-1)を表(1)として再利用する
  2878:               SpriteScreen.sprStep1 (0);  //表(1)にスプライト(0)を並べる
  2879:               SpriteScreen.sprSwap ();  //表(1)と裏(0)を入れ換える
  2880:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  2881:             }
  2882:           }
  2883:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  2884:             crtStereoscopicStart ();
  2885:           }
  2886:           TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12e)省略フレームの垂直映像期間の偶数ラスタの水平同期パルス
  2887:         }
  2888:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  2889:         //垂直映像期間開始ラスタではないとき
  2890:         TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  2891:       }
  2892:     }
  2893:   };
  2894:   //    (9)省略フレームの垂直空白期間の水平同期パルス
  2895:   public static final TickerQueue.Ticker DuplicationOmitIdleSync = new TickerQueue.Ticker () {
  2896:     @Override protected void tick () {
  2897:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  2898:       TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  2899:     }
  2900:   };
  2901:   //    (10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  2902:   public static final TickerQueue.Ticker DuplicationOmitIdleBackDisp = new TickerQueue.Ticker () {
  2903:     @Override protected void tick () {
  2904:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  2905:       TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(8)省略フレームの垂直空白期間の水平フロントポーチ
  2906:     }
  2907:   };
  2908:   //    (11e)省略フレームの垂直映像期間の偶数ラスタの水平フロントポーチ
  2909:   public static final TickerQueue.Ticker DuplicationOmitDispEvenFront = new TickerQueue.Ticker () {
  2910:     @Override protected void tick () {
  2911:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2912:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2913:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2914:           crtDoRasterCopy ();  //ラスタコピー実行
  2915:         }
  2916:         if (RasterBreakPoint.RBP_ON) {
  2917:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2918:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2919:           }
  2920:         }
  2921:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2922:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2923:           if (irq == 0) {  //IRQ信号が0になったとき
  2924:             if (RasterBreakPoint.RBP_ON) {
  2925:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2926:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2927:               }
  2928:             }
  2929:             MC68901.mfpRintFall ();  //IRQ開始
  2930:           } else {  //IRQ信号が0でなくなったとき
  2931:             MC68901.mfpRintRise ();  //IRQ終了
  2932:           }
  2933:         }
  2934:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  2935:           TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12e)省略フレームの垂直映像期間の偶数ラスタの水平同期パルス
  2936:         } else {  //垂直空白期間開始ラスタのとき
  2937:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  2938:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  2939:             crtClearFrames--;  //高速クリアカウンタを1減らす
  2940:           }
  2941:           if (CRT_ENABLE_INTERMITTENT) {
  2942:             crtIntermittentCounter--;  //間欠カウンタを1減らす
  2943:           }
  2944:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  2945:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  2946:           }
  2947:           if (XEiJ.PNL_USE_THREAD) {
  2948:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  2949:           }
  2950:           TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  2951:         }
  2952:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  2953:         //垂直空白期間開始ラスタではないとき
  2954:         TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12e)省略フレームの垂直映像期間の偶数ラスタの水平同期パルス
  2955:       }
  2956:     }
  2957:   };
  2958:   //    (11o)省略フレームの垂直映像期間の奇数ラスタの水平フロントポーチ
  2959:   public static final TickerQueue.Ticker DuplicationOmitDispOddFront = new TickerQueue.Ticker () {
  2960:     @Override protected void tick () {
  2961:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  2962:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  2963:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  2964:           crtDoRasterCopy ();  //ラスタコピー実行
  2965:         }
  2966:         if (RasterBreakPoint.RBP_ON) {
  2967:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  2968:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2969:           }
  2970:         }
  2971:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  2972:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  2973:           if (irq == 0) {  //IRQ信号が0になったとき
  2974:             if (RasterBreakPoint.RBP_ON) {
  2975:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  2976:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  2977:               }
  2978:             }
  2979:             MC68901.mfpRintFall ();  //IRQ開始
  2980:           } else {  //IRQ信号が0でなくなったとき
  2981:             MC68901.mfpRintRise ();  //IRQ終了
  2982:           }
  2983:         }
  2984:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  2985:           TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12o)省略フレームの垂直映像期間の奇数ラスタの水平同期パルス
  2986:         } else {  //垂直空白期間開始ラスタのとき
  2987:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  2988:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  2989:             crtClearFrames--;  //高速クリアカウンタを1減らす
  2990:           }
  2991:           if (CRT_ENABLE_INTERMITTENT) {
  2992:             crtIntermittentCounter--;  //間欠カウンタを1減らす
  2993:           }
  2994:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  2995:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  2996:           }
  2997:           if (XEiJ.PNL_USE_THREAD) {
  2998:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  2999:           }
  3000:           TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  3001:         }
  3002:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  3003:         //垂直空白期間開始ラスタではないとき
  3004:         TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12o)省略フレームの垂直映像期間の奇数ラスタの水平同期パルス
  3005:       }
  3006:     }
  3007:   };
  3008:   //    (12e)省略フレームの垂直映像期間の偶数ラスタの水平同期パルス
  3009:   public static final TickerQueue.Ticker DuplicationOmitDispEvenSync = new TickerQueue.Ticker () {
  3010:     @Override protected void tick () {
  3011:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3012:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  3013:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  3014:         crtRasterStamp[crtDataY] = 0;
  3015:       }
  3016:       TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(13e)省略フレームの垂直映像期間の偶数ラスタの水平バックポーチと水平映像期間
  3017:     }
  3018:   };
  3019:   //    (12o)省略フレームの垂直映像期間の奇数ラスタの水平同期パルス
  3020:   public static final TickerQueue.Ticker DuplicationOmitDispOddSync = new TickerQueue.Ticker () {
  3021:     @Override protected void tick () {
  3022:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3023:       TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(13o)省略フレームの垂直映像期間の奇数ラスタの水平バックポーチと水平映像期間
  3024:     }
  3025:   };
  3026:   //    (13e)省略フレームの垂直映像期間の偶数ラスタの水平バックポーチと水平映像期間
  3027:   public static final TickerQueue.Ticker DuplicationOmitDispEvenBackDisp = new TickerQueue.Ticker () {
  3028:     @Override protected void tick () {
  3029:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3030:       TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(11o)省略フレームの垂直映像期間の奇数ラスタの水平フロントポーチ
  3031:     }
  3032:   };
  3033:   //    (13o)省略フレームの垂直映像期間の奇数ラスタの水平バックポーチと水平映像期間
  3034:   public static final TickerQueue.Ticker DuplicationOmitDispOddBackDisp = new TickerQueue.Ticker () {
  3035:     @Override protected void tick () {
  3036:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3037:       TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(11e)省略フレームの垂直映像期間の偶数ラスタの水平フロントポーチ
  3038:     }
  3039:   };
  3040: 
  3041:   //----------------------------------------------------------------
  3042:   //  インターレース
  3043:   //    (0)開始(描画フレームの垂直空白期間開始ラスタの水平フロントポーチ)
  3044:   public static final TickerQueue.Ticker InterlaceStart = new TickerQueue.Ticker () {
  3045:     @Override protected void tick () {
  3046:       if (MC68901.mfpGpipHsync != 0) {
  3047:         MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3048:       }
  3049:       int n = crtRasterNumber = crtVIdleStart;  //ラスタ番号は垂直空白期間開始ラスタ
  3050:       if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3051:         crtDoRasterCopy ();  //ラスタコピー実行
  3052:       }
  3053:       if (RasterBreakPoint.RBP_ON) {
  3054:         if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3055:           RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3056:         }
  3057:       }
  3058:       int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3059:       if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3060:         if (irq == 0) {  //IRQ信号が0になったとき
  3061:           if (RasterBreakPoint.RBP_ON) {
  3062:             if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3063:               RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3064:             }
  3065:           }
  3066:           MC68901.mfpRintFall ();  //IRQ開始
  3067:         } else {  //IRQ信号が0でなくなったとき
  3068:           MC68901.mfpRintRise ();  //IRQ終了
  3069:         }
  3070:       }
  3071:       if (MC68901.mfpGpipVdisp != 0) {
  3072:         MC68901.mfpVdispFall ();  //垂直映像期間終了
  3073:       }
  3074:       crtFrameParity = 0;  //フレームパリティを0で初期化
  3075:       crtClearFrames = 0;  //高速クリアカウンタを0で初期化
  3076:       if (CRT_ENABLE_INTERMITTENT) {
  3077:         crtIntermittentCounter = 0;  //間欠カウンタを0で初期化(描画フレーム)
  3078:       }
  3079:       if (!XEiJ.PNL_USE_THREAD) {
  3080:         if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  3081:           crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  3082:         }
  3083:       }
  3084:       TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  3085:     }
  3086:   };
  3087:   //    (1)描画フレームの垂直空白期間の水平フロントポーチ
  3088:   public static final TickerQueue.Ticker InterlaceDrawIdleFront = new TickerQueue.Ticker () {
  3089:     @Override protected void tick () {
  3090:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  3091:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  3092:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  3093:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  3094:         }
  3095:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3096:           crtDoRasterCopy ();  //ラスタコピー実行
  3097:         }
  3098:         if (RasterBreakPoint.RBP_ON) {
  3099:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3100:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3101:           }
  3102:         }
  3103:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3104:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3105:           if (irq == 0) {  //IRQ信号が0になったとき
  3106:             if (RasterBreakPoint.RBP_ON) {
  3107:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3108:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3109:               }
  3110:             }
  3111:             MC68901.mfpRintFall ();  //IRQ開始
  3112:           } else {  //IRQ信号が0でなくなったとき
  3113:             MC68901.mfpRintRise ();  //IRQ終了
  3114:           }
  3115:         }
  3116:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  3117:           TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  3118:         } else {  //垂直映像期間開始ラスタのとき
  3119:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  3120:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  3121:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  3122:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  3123:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  3124:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  3125:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  3126:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  3127:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  3128:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  3129:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  3130:             crtR11TxYZeroLast = crtR11TxYZero;
  3131:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  3132:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  3133:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  3134:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  3135:             crtAllStamp += 2;
  3136:           }
  3137:           crtDataY = crtFrameParity;  //データY座標をフレームパリティで初期化
  3138:           if (crtClearStandby) {  //高速クリアの要求があるとき
  3139:             crtClearStandby = false;
  3140:             crtClearFrames = 2;  //高速クリアカウンタを2で初期化
  3141:           }
  3142:           crtScreenY = crtFrameParity;  //スクリーンY座標をフレームパリティで初期化
  3143:           if (!XEiJ.PNL_USE_THREAD) {
  3144:             crtDirtyY0 = -1;  //ダーティフラグをクリア
  3145:           }
  3146:           if (XEiJ.PNL_USE_THREAD) {
  3147:             crtAllStamp += 2;
  3148:           }
  3149:           if (SpriteScreen.SPR_THREE_STEPS) {
  3150:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  3151:             if (SpriteScreen.sprActive) {
  3152:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  3153:                 SpriteScreen.sprLatched = false;
  3154:               }
  3155:               if (!XEiJ.PNL_USE_THREAD) {
  3156:                 crtAllStamp += 2;
  3157:               }
  3158:               //ラスタ(dst=-4,src=-4)
  3159:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  3160:               SpriteScreen.sprSwap ();  //表(0)と裏(-2)を入れ換える
  3161:               //ラスタ(dst=-2,src=-2)
  3162:               //表(-2)を表(2)として再利用する
  3163:               SpriteScreen.sprStep1 (2);  //表(2)にスプライト(2)を並べる
  3164:               SpriteScreen.sprSwap ();  //表(2)と裏(0)を入れ換える
  3165:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  3166:             }
  3167:           }
  3168:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3169:             crtStereoscopicStart ();
  3170:           }
  3171:           TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5)描画フレームの垂直映像期間の水平同期パルス
  3172:         }
  3173:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  3174:         //垂直映像期間開始ラスタではないとき
  3175:         TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  3176:       }
  3177:     }
  3178:   };
  3179:   //    (2)描画フレームの垂直空白期間の水平同期パルス
  3180:   public static final TickerQueue.Ticker InterlaceDrawIdleSync = new TickerQueue.Ticker () {
  3181:     @Override protected void tick () {
  3182:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3183:       TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  3184:     }
  3185:   };
  3186:   //    (3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  3187:   public static final TickerQueue.Ticker InterlaceDrawIdleBackDisp = new TickerQueue.Ticker () {
  3188:     @Override protected void tick () {
  3189:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3190:       TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(1)描画フレームの垂直空白期間の水平フロントポーチ
  3191:     }
  3192:   };
  3193:   //    (4)描画フレームの垂直映像期間の水平フロントポーチ
  3194:   public static final TickerQueue.Ticker InterlaceDrawDispFront = new TickerQueue.Ticker () {
  3195:     @Override protected void tick () {
  3196:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  3197:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  3198:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3199:           crtDoRasterCopy ();  //ラスタコピー実行
  3200:         }
  3201:         if (RasterBreakPoint.RBP_ON) {
  3202:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3203:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3204:           }
  3205:         }
  3206:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3207:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3208:           if (irq == 0) {  //IRQ信号が0になったとき
  3209:             if (RasterBreakPoint.RBP_ON) {
  3210:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3211:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3212:               }
  3213:             }
  3214:             MC68901.mfpRintFall ();  //IRQ開始
  3215:           } else {  //IRQ信号が0でなくなったとき
  3216:             MC68901.mfpRintRise ();  //IRQ終了
  3217:           }
  3218:         }
  3219:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  3220:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  3221:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  3222:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3223:               crtStereoscopicDrawRaster (crtScreenY);
  3224:               if (XEiJ.PNL_USE_THREAD) {
  3225:                 crtStereoscopicDrawRaster (crtScreenY ^ 1);
  3226:               }
  3227:             }
  3228:           }
  3229:           crtScreenY += 2;  //スクリーンY座標を2増やす
  3230:           crtDataY += 2;  //データY座標を2増やす
  3231:           TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5)描画フレームの垂直映像期間の水平同期パルス
  3232:         } else {  //垂直空白期間開始ラスタのとき
  3233:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  3234:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  3235:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3236:               crtStereoscopicDrawRaster (crtScreenY);
  3237:               if (XEiJ.PNL_USE_THREAD) {
  3238:                 crtStereoscopicDrawRaster (crtScreenY ^ 1);
  3239:               }
  3240:             }
  3241:           }
  3242:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  3243:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  3244:             crtClearFrames--;  //高速クリアカウンタを1減らす
  3245:           }
  3246:           if (!XEiJ.PNL_USE_THREAD) {
  3247:             if (crtDirtyY0 >= 0) {  //ダーティフラグがセットされているとき
  3248:               crtUpdateScreen ();  //スクリーンを更新する
  3249:               if (CRT_ENABLE_INTERMITTENT) {
  3250:                 crtIntermittentCounter = crtIntermittentInterval;  //間欠カウンタを間欠間隔に戻す
  3251:               }
  3252:             }
  3253:           }
  3254:           crtFrameParity ^= 1;  //フレームパリティを反転
  3255:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  3256:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  3257:           }
  3258:           if (XEiJ.PNL_USE_THREAD) {
  3259:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  3260:           }
  3261:           TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  3262:         }
  3263:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  3264:         //垂直空白期間開始ラスタではないとき
  3265:         if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  3266:           VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  3267:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3268:             crtStereoscopicDrawRaster (crtScreenY);
  3269:             if (XEiJ.PNL_USE_THREAD) {
  3270:               crtStereoscopicDrawRaster (crtScreenY ^ 1);
  3271:             }
  3272:           }
  3273:         }
  3274:         crtScreenY += 2;  //スクリーンY座標を2増やす
  3275:         crtDataY += 2;  //データY座標を2増やす
  3276:         TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5)描画フレームの垂直映像期間の水平同期パルス
  3277:       }
  3278:     }
  3279:   };
  3280:   //    (5)描画フレームの垂直映像期間の水平同期パルス
  3281:   public static final TickerQueue.Ticker InterlaceDrawDispSync = new TickerQueue.Ticker () {
  3282:     @Override protected void tick () {
  3283:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3284:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  3285:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  3286:         crtRasterStamp[crtDataY] = 0;
  3287:       }
  3288:       TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispBack, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(6)描画フレームの垂直映像期間の水平バックポーチ
  3289:     }
  3290:   };
  3291:   //    (6)描画フレームの垂直映像期間の水平バックポーチ
  3292:   public static final TickerQueue.Ticker InterlaceDrawDispBack = new TickerQueue.Ticker () {
  3293:     @Override protected void tick () {
  3294:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3295:       TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispDisp, crtClock += crtHBackLength);  //+水平バックポーチの長さ→(7)描画フレームの垂直映像期間の水平映像期間
  3296:     }
  3297:   };
  3298:   //    (7)描画フレームの垂直映像期間の水平映像期間
  3299:   public static final TickerQueue.Ticker InterlaceDrawDispDisp = new TickerQueue.Ticker () {
  3300:     @Override protected void tick () {
  3301:       if (crtRasterStamp[crtDataY] != crtAllStamp) {  //ラスタの更新フラグがセットされているとき
  3302:         crtRasterStamp[crtDataY] = crtAllStamp;  //ラスタの更新フラグをクリア
  3303:         crtBeginningAllStamp = crtAllStamp;  //全再描画スタンプを水平映像期間開始時の全再描画スタンプにコピー
  3304:         VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);  //データY座標からスクリーンY座標へ描画
  3305:         if (XEiJ.PNL_USE_THREAD) {
  3306:           int[] prevBM = XEiJ.pnlBMLeftArray[(XEiJ.pnlBMWrite - 1) & 3];  //直前のフレームのビットマップ
  3307:           int da = (crtScreenY ^ 1) << XEiJ.PNL_BM_OFFSET_BITS;  //コピーするラスタの先頭
  3308:           System.arraycopy (prevBM, da,  //from
  3309:                             XEiJ.pnlBM, da,  //to
  3310:                             XEiJ.pnlScreenWidth);  //length
  3311:         }
  3312:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3313:           crtStereoscopicDrawRaster (crtScreenY);
  3314:           if (XEiJ.PNL_USE_THREAD) {
  3315:             crtStereoscopicDrawRaster (crtScreenY ^ 1);
  3316:           }
  3317:         }
  3318:         if (!XEiJ.PNL_USE_THREAD) {
  3319:           if (crtDirtyY0 < 0) {
  3320:             crtDirtyY0 = crtScreenY;  //ダーティフラグをセット
  3321:           }
  3322:           crtDirtyY1 = crtScreenY;
  3323:         }
  3324:       }
  3325:       if (SpriteScreen.SPR_THREE_STEPS) {
  3326:         if (SpriteScreen.sprActive) {
  3327:           //ラスタ(dst=src)
  3328:           //表(dst)を表(dst+4)として再利用する
  3329:           SpriteScreen.sprStep1 (crtDataY + 4);  //表(dst+4)にスプライト(src+4)を並べる
  3330:           SpriteScreen.sprSwap ();  //表(dst+4)と裏(dst+2)を入れ換える
  3331:           SpriteScreen.sprStep2 (crtDataY + 2);  //表(dst+2)にバックグラウンド(src+2)を並べる
  3332:         }
  3333:       }
  3334:       TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispFront, crtClock += crtHDispLength);  //+水平水平映像期間の長さ→(4)描画フレームの垂直映像期間の水平フロントポーチ
  3335:     }
  3336:   };
  3337:   //    (8)省略フレームの垂直空白期間の水平フロントポーチ
  3338:   public static final TickerQueue.Ticker InterlaceOmitIdleFront = new TickerQueue.Ticker () {
  3339:     @Override protected void tick () {
  3340:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  3341:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  3342:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  3343:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  3344:         }
  3345:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3346:           crtDoRasterCopy ();  //ラスタコピー実行
  3347:         }
  3348:         if (RasterBreakPoint.RBP_ON) {
  3349:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3350:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3351:           }
  3352:         }
  3353:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3354:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3355:           if (irq == 0) {  //IRQ信号が0になったとき
  3356:             if (RasterBreakPoint.RBP_ON) {
  3357:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3358:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3359:               }
  3360:             }
  3361:             MC68901.mfpRintFall ();  //IRQ開始
  3362:           } else {  //IRQ信号が0でなくなったとき
  3363:             MC68901.mfpRintRise ();  //IRQ終了
  3364:           }
  3365:         }
  3366:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  3367:           TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  3368:         } else {  //垂直映像期間開始ラスタのとき
  3369:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  3370:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  3371:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  3372:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  3373:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  3374:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  3375:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  3376:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  3377:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  3378:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  3379:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  3380:             crtR11TxYZeroLast = crtR11TxYZero;
  3381:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  3382:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  3383:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  3384:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  3385:             crtAllStamp += 2;
  3386:           }
  3387:           crtDataY = crtFrameParity;  //データY座標をフレームパリティで初期化
  3388:           if (crtClearStandby) {  //高速クリアの要求があるとき
  3389:             crtClearStandby = false;
  3390:             crtClearFrames = 2;  //高速クリアカウンタを2で初期化
  3391:           }
  3392:           if (XEiJ.PNL_USE_THREAD) {
  3393:             crtAllStamp += 2;
  3394:           }
  3395:           if (SpriteScreen.SPR_THREE_STEPS) {
  3396:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  3397:             if (SpriteScreen.sprActive) {
  3398:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  3399:                 SpriteScreen.sprLatched = false;
  3400:               }
  3401:               if (!XEiJ.PNL_USE_THREAD) {
  3402:                 crtAllStamp += 2;
  3403:               }
  3404:               //ラスタ(dst=-4,src=-4)
  3405:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  3406:               SpriteScreen.sprSwap ();  //表(0)と裏(-2)を入れ換える
  3407:               //ラスタ(dst=-2,src=-2)
  3408:               //表(-2)を表(2)として再利用する
  3409:               SpriteScreen.sprStep1 (2);  //表(2)にスプライト(2)を並べる
  3410:               SpriteScreen.sprSwap ();  //表(2)と裏(0)を入れ換える
  3411:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  3412:             }
  3413:           }
  3414:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3415:             crtStereoscopicStart ();
  3416:           }
  3417:           TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12)省略フレームの垂直映像期間の水平同期パルス
  3418:         }
  3419:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  3420:         //垂直映像期間開始ラスタではないとき
  3421:         TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  3422:       }
  3423:     }
  3424:   };
  3425:   //    (9)省略フレームの垂直空白期間の水平同期パルス
  3426:   public static final TickerQueue.Ticker InterlaceOmitIdleSync = new TickerQueue.Ticker () {
  3427:     @Override protected void tick () {
  3428:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3429:       TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  3430:     }
  3431:   };
  3432:   //    (10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  3433:   public static final TickerQueue.Ticker InterlaceOmitIdleBackDisp = new TickerQueue.Ticker () {
  3434:     @Override protected void tick () {
  3435:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3436:       TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(8)省略フレームの垂直空白期間の水平フロントポーチ
  3437:     }
  3438:   };
  3439:   //    (11)省略フレームの垂直映像期間の水平フロントポーチ
  3440:   public static final TickerQueue.Ticker InterlaceOmitDispFront = new TickerQueue.Ticker () {
  3441:     @Override protected void tick () {
  3442:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  3443:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  3444:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3445:           crtDoRasterCopy ();  //ラスタコピー実行
  3446:         }
  3447:         if (RasterBreakPoint.RBP_ON) {
  3448:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3449:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3450:           }
  3451:         }
  3452:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3453:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3454:           if (irq == 0) {  //IRQ信号が0になったとき
  3455:             if (RasterBreakPoint.RBP_ON) {
  3456:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3457:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3458:               }
  3459:             }
  3460:             MC68901.mfpRintFall ();  //IRQ開始
  3461:           } else {  //IRQ信号が0でなくなったとき
  3462:             MC68901.mfpRintRise ();  //IRQ終了
  3463:           }
  3464:         }
  3465:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  3466:           TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12)省略フレームの垂直映像期間の水平同期パルス
  3467:         } else {  //垂直空白期間開始ラスタのとき
  3468:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  3469:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  3470:             crtClearFrames--;  //高速クリアカウンタを1減らす
  3471:           }
  3472:           if (CRT_ENABLE_INTERMITTENT) {
  3473:             crtIntermittentCounter--;  //間欠カウンタを1減らす
  3474:           }
  3475:           crtFrameParity ^= 1;  //フレームパリティを反転
  3476:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  3477:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  3478:           }
  3479:           if (XEiJ.PNL_USE_THREAD) {
  3480:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  3481:           }
  3482:           TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  3483:         }
  3484:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  3485:         //垂直空白期間開始ラスタではないとき
  3486:         TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12)省略フレームの垂直映像期間の水平同期パルス
  3487:       }
  3488:     }
  3489:   };
  3490:   //    (12)省略フレームの垂直映像期間の水平同期パルス
  3491:   public static final TickerQueue.Ticker InterlaceOmitDispSync = new TickerQueue.Ticker () {
  3492:     @Override protected void tick () {
  3493:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3494:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  3495:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  3496:         crtRasterStamp[crtDataY] = 0;
  3497:       }
  3498:       TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(13)省略フレームの垂直映像期間の水平バックポーチと水平映像期間
  3499:     }
  3500:   };
  3501:   //    (13)省略フレームの垂直映像期間の水平バックポーチと水平映像期間
  3502:   public static final TickerQueue.Ticker InterlaceOmitDispBackDisp = new TickerQueue.Ticker () {
  3503:     @Override protected void tick () {
  3504:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3505:       TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(11)省略フレームの垂直映像期間の水平フロントポーチ
  3506:     }
  3507:   };
  3508: 
  3509:   //----------------------------------------------------------------
  3510:   //  スリット
  3511:   //    (0)開始(描画フレームの垂直空白期間開始ラスタの水平フロントポーチ)
  3512:   public static final TickerQueue.Ticker SlitStart = new TickerQueue.Ticker () {
  3513:     @Override protected void tick () {
  3514:       if (MC68901.mfpGpipHsync != 0) {
  3515:         MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3516:       }
  3517:       int n = crtRasterNumber = crtVIdleStart;  //ラスタ番号は垂直空白期間開始ラスタ
  3518:       if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3519:         crtDoRasterCopy ();  //ラスタコピー実行
  3520:       }
  3521:       if (RasterBreakPoint.RBP_ON) {
  3522:         if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3523:           RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3524:         }
  3525:       }
  3526:       int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3527:       if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3528:         if (irq == 0) {  //IRQ信号が0になったとき
  3529:           if (RasterBreakPoint.RBP_ON) {
  3530:             if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3531:               RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3532:             }
  3533:           }
  3534:           MC68901.mfpRintFall ();  //IRQ開始
  3535:         } else {  //IRQ信号が0でなくなったとき
  3536:           MC68901.mfpRintRise ();  //IRQ終了
  3537:         }
  3538:       }
  3539:       if (MC68901.mfpGpipVdisp != 0) {
  3540:         MC68901.mfpVdispFall ();  //垂直映像期間終了
  3541:       }
  3542:       crtClearFrames = 0;  //高速クリアカウンタを0で初期化
  3543:       if (CRT_ENABLE_INTERMITTENT) {
  3544:         crtIntermittentCounter = 0;  //間欠カウンタを0で初期化(描画フレーム)
  3545:       }
  3546:       if (!XEiJ.PNL_USE_THREAD) {
  3547:         if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  3548:           crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  3549:         }
  3550:       }
  3551:       TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  3552:     }
  3553:   };
  3554:   //    (1)描画フレームの垂直空白期間の水平フロントポーチ
  3555:   public static final TickerQueue.Ticker SlitDrawIdleFront = new TickerQueue.Ticker () {
  3556:     @Override protected void tick () {
  3557:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  3558:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  3559:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  3560:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  3561:         }
  3562:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3563:           crtDoRasterCopy ();  //ラスタコピー実行
  3564:         }
  3565:         if (RasterBreakPoint.RBP_ON) {
  3566:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3567:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3568:           }
  3569:         }
  3570:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3571:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3572:           if (irq == 0) {  //IRQ信号が0になったとき
  3573:             if (RasterBreakPoint.RBP_ON) {
  3574:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3575:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3576:               }
  3577:             }
  3578:             MC68901.mfpRintFall ();  //IRQ開始
  3579:           } else {  //IRQ信号が0でなくなったとき
  3580:             MC68901.mfpRintRise ();  //IRQ終了
  3581:           }
  3582:         }
  3583:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  3584:           TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  3585:         } else {  //垂直映像期間開始ラスタのとき
  3586:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  3587:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  3588:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  3589:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  3590:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  3591:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  3592:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  3593:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  3594:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  3595:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  3596:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  3597:             crtR11TxYZeroLast = crtR11TxYZero;
  3598:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  3599:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  3600:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  3601:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  3602:             crtAllStamp += 2;
  3603:           }
  3604:           crtDataY = 0;  //データY座標を0で初期化
  3605:           if (crtClearStandby) {  //高速クリアの要求があるとき
  3606:             crtClearStandby = false;
  3607:             crtClearFrames = 1;  //高速クリアカウンタを1で初期化
  3608:           }
  3609:           crtScreenY = 0;  //スクリーンY座標を0で初期化
  3610:           if (!XEiJ.PNL_USE_THREAD) {
  3611:             crtDirtyY0 = -1;  //ダーティフラグをクリア
  3612:           }
  3613:           if (XEiJ.PNL_USE_THREAD) {
  3614:             crtAllStamp += 2;
  3615:           }
  3616:           if (SpriteScreen.SPR_THREE_STEPS) {
  3617:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  3618:             if (SpriteScreen.sprActive) {
  3619:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  3620:                 SpriteScreen.sprLatched = false;
  3621:               }
  3622:               if (!XEiJ.PNL_USE_THREAD) {
  3623:                 crtAllStamp += 2;
  3624:               }
  3625:               //ラスタ(dst=-4,src=-2)
  3626:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  3627:               SpriteScreen.sprSwap ();  //表(0)と裏(-2)を入れ換える
  3628:               //ラスタ(dst=-2,src=-1)
  3629:               //表(-2)を表(2)として再利用する
  3630:               SpriteScreen.sprStep1 (1);  //表(2)にスプライト(1)を並べる
  3631:               SpriteScreen.sprSwap ();  //表(2)と裏(0)を入れ換える
  3632:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  3633:             }
  3634:           }
  3635:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3636:             crtStereoscopicStart ();
  3637:           }
  3638:           TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5)描画フレームの垂直映像期間の水平同期パルス
  3639:         }
  3640:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  3641:         //垂直映像期間開始ラスタではないとき
  3642:         TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  3643:       }
  3644:     }
  3645:   };
  3646:   //    (2)描画フレームの垂直空白期間の水平同期パルス
  3647:   public static final TickerQueue.Ticker SlitDrawIdleSync = new TickerQueue.Ticker () {
  3648:     @Override protected void tick () {
  3649:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3650:       TickerQueue.tkqAdd (crtTicker = SlitDrawIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  3651:     }
  3652:   };
  3653:   //    (3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  3654:   public static final TickerQueue.Ticker SlitDrawIdleBackDisp = new TickerQueue.Ticker () {
  3655:     @Override protected void tick () {
  3656:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3657:       TickerQueue.tkqAdd (crtTicker = SlitDrawIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(1)描画フレームの垂直空白期間の水平フロントポーチ
  3658:     }
  3659:   };
  3660:   //    (4)描画フレームの垂直映像期間の水平フロントポーチ
  3661:   public static final TickerQueue.Ticker SlitDrawDispFront = new TickerQueue.Ticker () {
  3662:     @Override protected void tick () {
  3663:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  3664:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  3665:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3666:           crtDoRasterCopy ();  //ラスタコピー実行
  3667:         }
  3668:         if (RasterBreakPoint.RBP_ON) {
  3669:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3670:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3671:           }
  3672:         }
  3673:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3674:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3675:           if (irq == 0) {  //IRQ信号が0になったとき
  3676:             if (RasterBreakPoint.RBP_ON) {
  3677:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3678:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3679:               }
  3680:             }
  3681:             MC68901.mfpRintFall ();  //IRQ開始
  3682:           } else {  //IRQ信号が0でなくなったとき
  3683:             MC68901.mfpRintRise ();  //IRQ終了
  3684:           }
  3685:         }
  3686:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  3687:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  3688:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  3689:             crtScanlineEffect.drawRaster (crtScreenY + 1);  //走査線エフェクト
  3690:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3691:               crtStereoscopicDrawRaster (crtScreenY);
  3692:               crtStereoscopicDrawRaster (crtScreenY + 1);
  3693:             }
  3694:           }
  3695:           crtScreenY += 2;  //スクリーンY座標を2増やす
  3696:           crtDataY++;  //データY座標を1増やす
  3697:           TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5)描画フレームの垂直映像期間の水平同期パルス
  3698:         } else {  //垂直空白期間開始ラスタのとき
  3699:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  3700:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  3701:             crtScanlineEffect.drawRaster (crtScreenY + 1);  //走査線エフェクト
  3702:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3703:               crtStereoscopicDrawRaster (crtScreenY);
  3704:               crtStereoscopicDrawRaster (crtScreenY + 1);
  3705:             }
  3706:           }
  3707:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  3708:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  3709:             crtClearFrames--;  //高速クリアカウンタを1減らす
  3710:           }
  3711:           if (!XEiJ.PNL_USE_THREAD) {
  3712:             if (crtDirtyY0 >= 0) {  //ダーティフラグがセットされているとき
  3713:               crtUpdateScreen ();  //スクリーンを更新する
  3714:               if (CRT_ENABLE_INTERMITTENT) {
  3715:                 crtIntermittentCounter = crtIntermittentInterval;  //間欠カウンタを間欠間隔に戻す
  3716:               }
  3717:             }
  3718:           }
  3719:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  3720:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  3721:           }
  3722:           if (XEiJ.PNL_USE_THREAD) {
  3723:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  3724:           }
  3725:           TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  3726:         }
  3727:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  3728:         //垂直空白期間開始ラスタではないとき
  3729:         if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  3730:           VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  3731:           crtScanlineEffect.drawRaster (crtScreenY + 1);  //走査線エフェクト
  3732:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3733:             crtStereoscopicDrawRaster (crtScreenY);
  3734:             crtStereoscopicDrawRaster (crtScreenY + 1);
  3735:           }
  3736:         }
  3737:         crtScreenY += 2;  //スクリーンY座標を2増やす
  3738:         crtDataY++;  //データY座標を1増やす
  3739:         TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5)描画フレームの垂直映像期間の水平同期パルス
  3740:       }
  3741:     }
  3742:   };
  3743:   //    (5)描画フレームの垂直映像期間の水平同期パルス
  3744:   public static final TickerQueue.Ticker SlitDrawDispSync = new TickerQueue.Ticker () {
  3745:     @Override protected void tick () {
  3746:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3747:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  3748:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  3749:         crtRasterStamp[crtDataY] = 0;
  3750:       }
  3751:       TickerQueue.tkqAdd (crtTicker = SlitDrawDispBack, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(6)描画フレームの垂直映像期間の水平バックポーチ
  3752:     }
  3753:   };
  3754:   //    (6)描画フレームの垂直映像期間の水平バックポーチ
  3755:   public static final TickerQueue.Ticker SlitDrawDispBack = new TickerQueue.Ticker () {
  3756:     @Override protected void tick () {
  3757:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3758:       TickerQueue.tkqAdd (crtTicker = SlitDrawDispDisp, crtClock += crtHBackLength);  //+水平バックポーチの長さ→(7)描画フレームの垂直映像期間の水平映像期間
  3759:     }
  3760:   };
  3761:   //    (7)描画フレームの垂直映像期間の水平映像期間
  3762:   public static final TickerQueue.Ticker SlitDrawDispDisp = new TickerQueue.Ticker () {
  3763:     @Override protected void tick () {
  3764:       if (crtRasterStamp[crtDataY] != crtAllStamp) {  //ラスタの更新フラグがセットされているとき
  3765:         crtRasterStamp[crtDataY] = crtAllStamp;  //ラスタの更新フラグをクリア
  3766:         crtBeginningAllStamp = crtAllStamp;  //全再描画スタンプを水平映像期間開始時の全再描画スタンプにコピー
  3767:         VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);  //データY座標からスクリーンY座標へ描画
  3768:         crtScanlineEffect.drawRaster (crtScreenY + 1);  //走査線エフェクト
  3769:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3770:           crtStereoscopicDrawRaster (crtScreenY);
  3771:           crtStereoscopicDrawRaster (crtScreenY + 1);
  3772:         }
  3773:         if (!XEiJ.PNL_USE_THREAD) {
  3774:           if (crtDirtyY0 < 0) {
  3775:             crtDirtyY0 = crtScreenY;  //ダーティフラグをセット
  3776:           }
  3777:           crtDirtyY1 = crtScreenY + 1;
  3778:         }
  3779:       }
  3780:       if (SpriteScreen.SPR_THREE_STEPS) {
  3781:         if (SpriteScreen.sprActive) {
  3782:           //ラスタ(dst=src*2)
  3783:           //表(dst)を表(dst+4)として再利用する
  3784:           SpriteScreen.sprStep1 (crtDataY + 2);  //表(dst+4)にスプライト(src+2)を並べる
  3785:           SpriteScreen.sprSwap ();  //表(dst+4)と裏(dst+2)を入れ換える
  3786:           SpriteScreen.sprStep2 (crtDataY + 1);  //表(dst+2)にバックグラウンド(src+1)を並べる
  3787:         }
  3788:       }
  3789:       TickerQueue.tkqAdd (crtTicker = SlitDrawDispFront, crtClock += crtHDispLength);  //+水平水平映像期間の長さ→(4)描画フレームの垂直映像期間の水平フロントポーチ
  3790:     }
  3791:   };
  3792:   //    (8)省略フレームの垂直空白期間の水平フロントポーチ
  3793:   public static final TickerQueue.Ticker SlitOmitIdleFront = new TickerQueue.Ticker () {
  3794:     @Override protected void tick () {
  3795:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  3796:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  3797:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  3798:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  3799:         }
  3800:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3801:           crtDoRasterCopy ();  //ラスタコピー実行
  3802:         }
  3803:         if (RasterBreakPoint.RBP_ON) {
  3804:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3805:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3806:           }
  3807:         }
  3808:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3809:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3810:           if (irq == 0) {  //IRQ信号が0になったとき
  3811:             if (RasterBreakPoint.RBP_ON) {
  3812:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3813:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3814:               }
  3815:             }
  3816:             MC68901.mfpRintFall ();  //IRQ開始
  3817:           } else {  //IRQ信号が0でなくなったとき
  3818:             MC68901.mfpRintRise ();  //IRQ終了
  3819:           }
  3820:         }
  3821:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  3822:           TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  3823:         } else {  //垂直映像期間開始ラスタのとき
  3824:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  3825:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  3826:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  3827:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  3828:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  3829:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  3830:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  3831:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  3832:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  3833:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  3834:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  3835:             crtR11TxYZeroLast = crtR11TxYZero;
  3836:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  3837:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  3838:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  3839:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  3840:             crtAllStamp += 2;
  3841:           }
  3842:           crtDataY = 0;  //データY座標を0で初期化
  3843:           if (crtClearStandby) {  //高速クリアの要求があるとき
  3844:             crtClearStandby = false;
  3845:             crtClearFrames = 1;  //高速クリアカウンタを1で初期化
  3846:           }
  3847:           if (XEiJ.PNL_USE_THREAD) {
  3848:             crtAllStamp += 2;
  3849:           }
  3850:           if (SpriteScreen.SPR_THREE_STEPS) {
  3851:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  3852:             if (SpriteScreen.sprActive) {
  3853:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  3854:                 SpriteScreen.sprLatched = false;
  3855:               }
  3856:               if (!XEiJ.PNL_USE_THREAD) {
  3857:                 crtAllStamp += 2;
  3858:               }
  3859:               //ラスタ(dst=-4,src=-2)
  3860:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  3861:               SpriteScreen.sprSwap ();  //表(0)と裏(-2)を入れ換える
  3862:               //ラスタ(dst=-2,src=-1)
  3863:               //表(-2)を表(2)として再利用する
  3864:               SpriteScreen.sprStep1 (1);  //表(2)にスプライト(1)を並べる
  3865:               SpriteScreen.sprSwap ();  //表(2)と裏(0)を入れ換える
  3866:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  3867:             }
  3868:           }
  3869:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  3870:             crtStereoscopicStart ();
  3871:           }
  3872:           TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12)省略フレームの垂直映像期間の水平同期パルス
  3873:         }
  3874:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  3875:         //垂直映像期間開始ラスタではないとき
  3876:         TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  3877:       }
  3878:     }
  3879:   };
  3880:   //    (9)省略フレームの垂直空白期間の水平同期パルス
  3881:   public static final TickerQueue.Ticker SlitOmitIdleSync = new TickerQueue.Ticker () {
  3882:     @Override protected void tick () {
  3883:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3884:       TickerQueue.tkqAdd (crtTicker = SlitOmitIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  3885:     }
  3886:   };
  3887:   //    (10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  3888:   public static final TickerQueue.Ticker SlitOmitIdleBackDisp = new TickerQueue.Ticker () {
  3889:     @Override protected void tick () {
  3890:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3891:       TickerQueue.tkqAdd (crtTicker = SlitOmitIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(8)省略フレームの垂直空白期間の水平フロントポーチ
  3892:     }
  3893:   };
  3894:   //    (11)省略フレームの垂直映像期間の水平フロントポーチ
  3895:   public static final TickerQueue.Ticker SlitOmitDispFront = new TickerQueue.Ticker () {
  3896:     @Override protected void tick () {
  3897:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  3898:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  3899:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3900:           crtDoRasterCopy ();  //ラスタコピー実行
  3901:         }
  3902:         if (RasterBreakPoint.RBP_ON) {
  3903:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3904:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3905:           }
  3906:         }
  3907:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3908:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3909:           if (irq == 0) {  //IRQ信号が0になったとき
  3910:             if (RasterBreakPoint.RBP_ON) {
  3911:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3912:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3913:               }
  3914:             }
  3915:             MC68901.mfpRintFall ();  //IRQ開始
  3916:           } else {  //IRQ信号が0でなくなったとき
  3917:             MC68901.mfpRintRise ();  //IRQ終了
  3918:           }
  3919:         }
  3920:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  3921:           TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12)省略フレームの垂直映像期間の水平同期パルス
  3922:         } else {  //垂直空白期間開始ラスタのとき
  3923:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  3924:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  3925:             crtClearFrames--;  //高速クリアカウンタを1減らす
  3926:           }
  3927:           if (CRT_ENABLE_INTERMITTENT) {
  3928:             crtIntermittentCounter--;  //間欠カウンタを1減らす
  3929:           }
  3930:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  3931:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  3932:           }
  3933:           if (XEiJ.PNL_USE_THREAD) {
  3934:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  3935:           }
  3936:           TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  3937:         }
  3938:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  3939:         //垂直空白期間開始ラスタではないとき
  3940:         TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12)省略フレームの垂直映像期間の水平同期パルス
  3941:       }
  3942:     }
  3943:   };
  3944:   //    (12)省略フレームの垂直映像期間の水平同期パルス
  3945:   public static final TickerQueue.Ticker SlitOmitDispSync = new TickerQueue.Ticker () {
  3946:     @Override protected void tick () {
  3947:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  3948:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  3949:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  3950:         crtRasterStamp[crtDataY] = 0;
  3951:       }
  3952:       TickerQueue.tkqAdd (crtTicker = SlitOmitDispBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(13)省略フレームの垂直映像期間の水平バックポーチと水平映像期間
  3953:     }
  3954:   };
  3955:   //    (13)省略フレームの垂直映像期間の水平バックポーチと水平映像期間
  3956:   public static final TickerQueue.Ticker SlitOmitDispBackDisp = new TickerQueue.Ticker () {
  3957:     @Override protected void tick () {
  3958:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3959:       TickerQueue.tkqAdd (crtTicker = SlitOmitDispFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(11)省略フレームの垂直映像期間の水平フロントポーチ
  3960:     }
  3961:   };
  3962: 
  3963:   //----------------------------------------------------------------
  3964:   //  ラスタ2度読み(スプライトを除く)
  3965:   //    (0)開始(描画フレームの垂直空白期間開始ラスタの水平フロントポーチ)
  3966:   public static final TickerQueue.Ticker DupExceptSpStart = new TickerQueue.Ticker () {
  3967:     @Override protected void tick () {
  3968:       if (MC68901.mfpGpipHsync != 0) {
  3969:         MC68901.mfpHsyncFall ();  //水平同期パルス終了
  3970:       }
  3971:       int n = crtRasterNumber = crtVIdleStart;  //ラスタ番号は垂直空白期間開始ラスタ
  3972:       if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  3973:         crtDoRasterCopy ();  //ラスタコピー実行
  3974:       }
  3975:       if (RasterBreakPoint.RBP_ON) {
  3976:         if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  3977:           RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3978:         }
  3979:       }
  3980:       int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  3981:       if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  3982:         if (irq == 0) {  //IRQ信号が0になったとき
  3983:           if (RasterBreakPoint.RBP_ON) {
  3984:             if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  3985:               RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  3986:             }
  3987:           }
  3988:           MC68901.mfpRintFall ();  //IRQ開始
  3989:         } else {  //IRQ信号が0でなくなったとき
  3990:           MC68901.mfpRintRise ();  //IRQ終了
  3991:         }
  3992:       }
  3993:       if (MC68901.mfpGpipVdisp != 0) {
  3994:         MC68901.mfpVdispFall ();  //垂直映像期間終了
  3995:       }
  3996:       crtClearFrames = 0;  //高速クリアカウンタを0で初期化
  3997:       if (CRT_ENABLE_INTERMITTENT) {
  3998:         crtIntermittentCounter = 0;  //間欠カウンタを0で初期化(描画フレーム)
  3999:       }
  4000:       if (!XEiJ.PNL_USE_THREAD) {
  4001:         if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  4002:           crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  4003:         }
  4004:       }
  4005:       TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  4006:     }
  4007:   };
  4008:   //    (1)描画フレームの垂直空白期間の水平フロントポーチ
  4009:   public static final TickerQueue.Ticker DupExceptSpDrawIdleFront = new TickerQueue.Ticker () {
  4010:     @Override protected void tick () {
  4011:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  4012:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  4013:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  4014:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  4015:         }
  4016:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  4017:           crtDoRasterCopy ();  //ラスタコピー実行
  4018:         }
  4019:         if (RasterBreakPoint.RBP_ON) {
  4020:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  4021:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4022:           }
  4023:         }
  4024:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  4025:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  4026:           if (irq == 0) {  //IRQ信号が0になったとき
  4027:             if (RasterBreakPoint.RBP_ON) {
  4028:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  4029:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4030:               }
  4031:             }
  4032:             MC68901.mfpRintFall ();  //IRQ開始
  4033:           } else {  //IRQ信号が0でなくなったとき
  4034:             MC68901.mfpRintRise ();  //IRQ終了
  4035:           }
  4036:         }
  4037:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  4038:           TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  4039:         } else {  //垂直映像期間開始ラスタのとき
  4040:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  4041:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  4042:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  4043:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  4044:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  4045:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  4046:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  4047:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  4048:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  4049:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  4050:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  4051:             crtR11TxYZeroLast = crtR11TxYZero;
  4052:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  4053:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  4054:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  4055:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  4056:             crtAllStamp += 2;
  4057:           }
  4058:           crtDataY = 0;  //データY座標を0で初期化
  4059:           if (crtClearStandby) {  //高速クリアの要求があるとき
  4060:             crtClearStandby = false;
  4061:             crtClearFrames = 1;  //高速クリアカウンタを1で初期化
  4062:           }
  4063:           crtScreenY = 0;  //スクリーンY座標を0で初期化
  4064:           if (!XEiJ.PNL_USE_THREAD) {
  4065:             crtDirtyY0 = -1;  //ダーティフラグをクリア
  4066:           }
  4067:           if (XEiJ.PNL_USE_THREAD) {
  4068:             crtAllStamp += 2;
  4069:           }
  4070:           if (SpriteScreen.SPR_THREE_STEPS) {
  4071:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  4072:             if (SpriteScreen.sprActive) {
  4073:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  4074:                 SpriteScreen.sprLatched = false;
  4075:               }
  4076:               if (!XEiJ.PNL_USE_THREAD) {
  4077:                 crtAllStamp += 2;
  4078:               }
  4079:               //ラスタ(dst=-2,src=-2)
  4080:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  4081:               SpriteScreen.sprSwap ();  //表(0)と裏(-1)を入れ換える
  4082:               //ラスタ(dst=-1,src=-1)
  4083:               //表(-1)を表(1)として再利用する
  4084:               SpriteScreen.sprStep1 (1);  //表(1)にスプライト(1)を並べる
  4085:               SpriteScreen.sprSwap ();  //表(1)と裏(0)を入れ換える
  4086:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  4087:             }
  4088:           }
  4089:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4090:             crtStereoscopicStart ();
  4091:           }
  4092:           TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5e)描画フレームの垂直映像期間の偶数ラスタの水平同期パルス
  4093:         }
  4094:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  4095:         //垂直映像期間開始ラスタではないとき
  4096:         TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  4097:       }
  4098:     }
  4099:   };
  4100:   //    (2)描画フレームの垂直空白期間の水平同期パルス
  4101:   public static final TickerQueue.Ticker DupExceptSpDrawIdleSync = new TickerQueue.Ticker () {
  4102:     @Override protected void tick () {
  4103:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  4104:       TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  4105:     }
  4106:   };
  4107:   //    (3)描画フレームの垂直空白期間の水平バックポーチと水平映像期間
  4108:   public static final TickerQueue.Ticker DupExceptSpDrawIdleBackDisp = new TickerQueue.Ticker () {
  4109:     @Override protected void tick () {
  4110:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  4111:       TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(1)描画フレームの垂直空白期間の水平フロントポーチ
  4112:     }
  4113:   };
  4114:   //    (4e)描画フレームの垂直映像期間の偶数ラスタの水平フロントポーチ
  4115:   public static final TickerQueue.Ticker DupExceptSpDrawDispEvenFront = new TickerQueue.Ticker () {
  4116:     @Override protected void tick () {
  4117:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  4118:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  4119:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  4120:           crtDoRasterCopy ();  //ラスタコピー実行
  4121:         }
  4122:         if (RasterBreakPoint.RBP_ON) {
  4123:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  4124:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4125:           }
  4126:         }
  4127:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  4128:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  4129:           if (irq == 0) {  //IRQ信号が0になったとき
  4130:             if (RasterBreakPoint.RBP_ON) {
  4131:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  4132:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4133:               }
  4134:             }
  4135:             MC68901.mfpRintFall ();  //IRQ開始
  4136:           } else {  //IRQ信号が0でなくなったとき
  4137:             MC68901.mfpRintRise ();  //IRQ終了
  4138:           }
  4139:         }
  4140:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  4141:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  4142:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  4143:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4144:               crtStereoscopicDrawRaster (crtScreenY);
  4145:             }
  4146:           }
  4147:           crtScreenY++;  //スクリーンY座標を1増やす
  4148:           crtDataY++;  //データY座標を1増やす
  4149:           TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5e)描画フレームの垂直映像期間の偶数ラスタの水平同期パルス
  4150:         } else {  //垂直空白期間開始ラスタのとき
  4151:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  4152:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  4153:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4154:               crtStereoscopicDrawRaster (crtScreenY);
  4155:             }
  4156:           }
  4157:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  4158:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  4159:             crtClearFrames--;  //高速クリアカウンタを1減らす
  4160:           }
  4161:           if (!XEiJ.PNL_USE_THREAD) {
  4162:             if (crtDirtyY0 >= 0) {  //ダーティフラグがセットされているとき
  4163:               crtUpdateScreen ();  //スクリーンを更新する
  4164:               if (CRT_ENABLE_INTERMITTENT) {
  4165:                 crtIntermittentCounter = crtIntermittentInterval;  //間欠カウンタを間欠間隔に戻す
  4166:               }
  4167:             }
  4168:           }
  4169:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  4170:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  4171:           }
  4172:           if (XEiJ.PNL_USE_THREAD) {
  4173:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  4174:           }
  4175:           TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  4176:         }
  4177:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  4178:         //垂直空白期間開始ラスタではないとき
  4179:         if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  4180:           VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  4181:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4182:             crtStereoscopicDrawRaster (crtScreenY);
  4183:           }
  4184:         }
  4185:         crtScreenY++;  //スクリーンY座標を1増やす
  4186:         crtDataY++;  //データY座標を1増やす
  4187:         TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5e)描画フレームの垂直映像期間の偶数ラスタの水平同期パルス
  4188:       }
  4189:     }
  4190:   };
  4191:   //    (4o)描画フレームの垂直映像期間の奇数ラスタの水平フロントポーチ
  4192:   public static final TickerQueue.Ticker DupExceptSpDrawDispOddFront = new TickerQueue.Ticker () {
  4193:     @Override protected void tick () {
  4194:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  4195:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  4196:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  4197:           crtDoRasterCopy ();  //ラスタコピー実行
  4198:         }
  4199:         if (RasterBreakPoint.RBP_ON) {
  4200:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  4201:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4202:           }
  4203:         }
  4204:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  4205:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  4206:           if (irq == 0) {  //IRQ信号が0になったとき
  4207:             if (RasterBreakPoint.RBP_ON) {
  4208:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  4209:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4210:               }
  4211:             }
  4212:             MC68901.mfpRintFall ();  //IRQ開始
  4213:           } else {  //IRQ信号が0でなくなったとき
  4214:             MC68901.mfpRintRise ();  //IRQ終了
  4215:           }
  4216:         }
  4217:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  4218:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  4219:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  4220:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4221:               crtStereoscopicDrawRaster (crtScreenY);
  4222:             }
  4223:           }
  4224:           crtScreenY++;  //スクリーンY座標を1増やす
  4225:           TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5o)描画フレームの垂直映像期間の奇数ラスタの水平同期パルス
  4226:         } else {  //垂直空白期間開始ラスタのとき
  4227:           if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  4228:             VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  4229:             if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4230:               crtStereoscopicDrawRaster (crtScreenY);
  4231:             }
  4232:           }
  4233:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  4234:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  4235:             crtClearFrames--;  //高速クリアカウンタを1減らす
  4236:           }
  4237:           if (!XEiJ.PNL_USE_THREAD) {
  4238:             if (crtDirtyY0 >= 0) {  //ダーティフラグがセットされているとき
  4239:               crtUpdateScreen ();  //スクリーンを更新する
  4240:               if (CRT_ENABLE_INTERMITTENT) {
  4241:                 crtIntermittentCounter = crtIntermittentInterval;  //間欠カウンタを間欠間隔に戻す
  4242:               }
  4243:             }
  4244:           }
  4245:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  4246:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  4247:           }
  4248:           if (XEiJ.PNL_USE_THREAD) {
  4249:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  4250:           }
  4251:           TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(2)描画フレームの垂直空白期間の水平同期パルス
  4252:         }
  4253:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  4254:         //垂直空白期間開始ラスタではないとき
  4255:         if (crtBeginningAllStamp != crtAllStamp) {  //全再描画スタンプが水平映像期間開始時の全再描画スタンプと異なるとき
  4256:           VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);  //データY座標からスクリーンY座標へ描画
  4257:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4258:             crtStereoscopicDrawRaster (crtScreenY);
  4259:           }
  4260:         }
  4261:         crtScreenY++;  //スクリーンY座標を1増やす
  4262:         TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(5o)描画フレームの垂直映像期間の奇数ラスタの水平同期パルス
  4263:       }
  4264:     }
  4265:   };
  4266:   //    (5e)描画フレームの垂直映像期間の偶数ラスタの水平同期パルス
  4267:   public static final TickerQueue.Ticker DupExceptSpDrawDispEvenSync = new TickerQueue.Ticker () {
  4268:     @Override protected void tick () {
  4269:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  4270:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  4271:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  4272:         crtRasterStamp[crtDataY] = 0;
  4273:       }
  4274:       TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenBack, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(6e)描画フレームの垂直映像期間の偶数ラスタの水平バックポーチ
  4275:     }
  4276:   };
  4277:   //    (5o)描画フレームの垂直映像期間の奇数ラスタの水平同期パルス
  4278:   public static final TickerQueue.Ticker DupExceptSpDrawDispOddSync = new TickerQueue.Ticker () {
  4279:     @Override protected void tick () {
  4280:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  4281:       TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddBack, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(6o)描画フレームの垂直映像期間の奇数ラスタの水平バックポーチ
  4282:     }
  4283:   };
  4284:   //    (6e)描画フレームの垂直映像期間の偶数ラスタの水平バックポーチ
  4285:   public static final TickerQueue.Ticker DupExceptSpDrawDispEvenBack = new TickerQueue.Ticker () {
  4286:     @Override protected void tick () {
  4287:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  4288:       TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenDisp, crtClock += crtHBackLength);  //+水平バックポーチの長さ→(7e)描画フレームの垂直映像期間の偶数ラスタの水平映像期間
  4289:     }
  4290:   };
  4291:   //    (6o)描画フレームの垂直映像期間の奇数ラスタの水平バックポーチ
  4292:   public static final TickerQueue.Ticker DupExceptSpDrawDispOddBack = new TickerQueue.Ticker () {
  4293:     @Override protected void tick () {
  4294:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  4295:       TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddDisp, crtClock += crtHBackLength);  //+水平バックポーチの長さ→(7o)描画フレームの垂直映像期間の奇数ラスタの水平映像期間
  4296:     }
  4297:   };
  4298:   //    (7e)描画フレームの垂直映像期間の偶数ラスタの水平映像期間
  4299:   public static final TickerQueue.Ticker DupExceptSpDrawDispEvenDisp = new TickerQueue.Ticker () {
  4300:     @Override protected void tick () {
  4301:       if (crtRasterStamp[crtDataY] != crtAllStamp) {  //ラスタの更新フラグがセットされているとき
  4302:         crtBeginningAllStamp = crtAllStamp;  //全再描画スタンプを水平映像期間開始時の全再描画スタンプにコピー
  4303:         VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);  //データY座標からスクリーンY座標へ描画
  4304:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4305:           crtStereoscopicDrawRaster (crtScreenY);
  4306:         }
  4307:         if (!XEiJ.PNL_USE_THREAD) {
  4308:           if (crtDirtyY0 < 0) {
  4309:             crtDirtyY0 = crtScreenY;  //ダーティフラグをセット
  4310:           }
  4311:           crtDirtyY1 = crtScreenY;  //偶数ラスタで終了する可能性があるので偶数ラスタでもcrtDirtyY1を更新する
  4312:         }
  4313:       }
  4314:       if (SpriteScreen.SPR_THREE_STEPS) {
  4315:         if (SpriteScreen.sprActive) {
  4316:           //ラスタ(dst=src)
  4317:           //表(dst)を表(dst+2)として再利用する
  4318:           SpriteScreen.sprStep1 (crtScreenY + 2);  //表(dst+2)にスプライト(src+2)を並べる
  4319:           SpriteScreen.sprSwap ();  //表(dst+2)と裏(dst+1)を入れ換える
  4320:           SpriteScreen.sprStep2 (crtScreenY + 1);  //表(dst+1)にバックグラウンド(src+1)を並べる
  4321:         }
  4322:       }
  4323:       TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddFront, crtClock += crtHDispLength);  //+水平水平映像期間の長さ→(4o)描画フレームの垂直映像期間の奇数ラスタの水平フロントポーチ
  4324:     }
  4325:   };
  4326:   //    (7o)描画フレームの垂直映像期間の奇数ラスタの水平映像期間
  4327:   public static final TickerQueue.Ticker DupExceptSpDrawDispOddDisp = new TickerQueue.Ticker () {
  4328:     @Override protected void tick () {
  4329:       if (crtRasterStamp[crtDataY] != crtAllStamp) {  //ラスタの更新フラグがセットされているとき
  4330:         crtRasterStamp[crtDataY] = crtAllStamp;  //ラスタの更新フラグをクリア
  4331:         crtBeginningAllStamp = crtAllStamp;  //全再描画スタンプを水平映像期間開始時の全再描画スタンプにコピー
  4332:         VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);  //データY座標からスクリーンY座標へ描画
  4333:         if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4334:           crtStereoscopicDrawRaster (crtScreenY);
  4335:         }
  4336:         if (!XEiJ.PNL_USE_THREAD) {
  4337:           if (crtDirtyY0 < 0) {
  4338:             crtDirtyY0 = crtScreenY;  //ダーティフラグをセット。奇数ラスタの直前でパレットやスクロール位置が変化したとき偶数ラスタでcrtDirtyY0が更新されていない可能性があるので奇数ラスタでもcrtDirtyY0を更新する
  4339:           }
  4340:           crtDirtyY1 = crtScreenY;
  4341:         }
  4342:       }
  4343:       if (SpriteScreen.SPR_THREE_STEPS) {
  4344:         if (SpriteScreen.sprActive) {
  4345:           //ラスタ(dst=src)
  4346:           //表(dst)を表(dst+2)として再利用する
  4347:           SpriteScreen.sprStep1 (crtScreenY + 2);  //表(dst+2)にスプライト(src+2)を並べる
  4348:           SpriteScreen.sprSwap ();  //表(dst+2)と裏(dst+1)を入れ換える
  4349:           SpriteScreen.sprStep2 (crtScreenY + 1);  //表(dst+1)にバックグラウンド(src+1)を並べる
  4350:         }
  4351:       }
  4352:       TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenFront, crtClock += crtHDispLength);  //+水平水平映像期間の長さ→(4e)描画フレームの垂直映像期間の偶数ラスタの水平フロントポーチ
  4353:     }
  4354:   };
  4355:   //    (8)省略フレームの垂直空白期間の水平フロントポーチ
  4356:   public static final TickerQueue.Ticker DupExceptSpOmitIdleFront = new TickerQueue.Ticker () {
  4357:     @Override protected void tick () {
  4358:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  4359:       if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  4360:         if (crtR04VFrontEndCurr < n) {  //ラスタ番号が垂直フロントポーチ終了ラスタを超えたとき
  4361:           n = crtRasterNumber = 0;  //ラスタ番号を0に戻す(垂直空白期間は0を跨ぐ)
  4362:         }
  4363:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  4364:           crtDoRasterCopy ();  //ラスタコピー実行
  4365:         }
  4366:         if (RasterBreakPoint.RBP_ON) {
  4367:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  4368:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4369:           }
  4370:         }
  4371:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  4372:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  4373:           if (irq == 0) {  //IRQ信号が0になったとき
  4374:             if (RasterBreakPoint.RBP_ON) {
  4375:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  4376:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4377:               }
  4378:             }
  4379:             MC68901.mfpRintFall ();  //IRQ開始
  4380:           } else {  //IRQ信号が0でなくなったとき
  4381:             MC68901.mfpRintRise ();  //IRQ終了
  4382:           }
  4383:         }
  4384:         if (n != crtVDispStart) {  //垂直映像期間開始ラスタではないとき
  4385:           TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  4386:         } else {  //垂直映像期間開始ラスタのとき
  4387:           MC68901.mfpVdispRise ();  //垂直映像期間開始
  4388:           crtR11TxYZero = crtR11TxYCurr;  //テキストY方向スクロールを保存
  4389:           crtR13GrYZero[0] = crtR13GrYCurr[0];  //グラフィックY方向スクロールを保存
  4390:           crtR13GrYZero[1] = crtR13GrYCurr[1];
  4391:           crtR13GrYZero[2] = crtR13GrYCurr[2];
  4392:           crtR13GrYZero[3] = crtR13GrYCurr[3];
  4393:           if (crtR11TxYZeroLast != crtR11TxYZero ||
  4394:               crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
  4395:               crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
  4396:               crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
  4397:               crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
  4398:             crtR11TxYZeroLast = crtR11TxYZero;
  4399:             crtR13GrYZeroLast[0] = crtR13GrYZero[0];
  4400:             crtR13GrYZeroLast[1] = crtR13GrYZero[1];
  4401:             crtR13GrYZeroLast[2] = crtR13GrYZero[2];
  4402:             crtR13GrYZeroLast[3] = crtR13GrYZero[3];
  4403:             crtAllStamp += 2;
  4404:           }
  4405:           crtDataY = 0;  //データY座標を0で初期化
  4406:           if (crtClearStandby) {  //高速クリアの要求があるとき
  4407:             crtClearStandby = false;
  4408:             crtClearFrames = 1;  //高速クリアカウンタを1で初期化
  4409:           }
  4410:           if (XEiJ.PNL_USE_THREAD) {
  4411:             crtAllStamp += 2;
  4412:           }
  4413:           if (SpriteScreen.SPR_THREE_STEPS) {
  4414:             SpriteScreen.sprActive = SpriteScreen.sprLatched;
  4415:             if (SpriteScreen.sprActive) {
  4416:               if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
  4417:                 SpriteScreen.sprLatched = false;
  4418:               }
  4419:               if (!XEiJ.PNL_USE_THREAD) {
  4420:                 crtAllStamp += 2;
  4421:               }
  4422:               //ラスタ(dst=-2,src=-2)
  4423:               SpriteScreen.sprStep1 (0);  //表(0)にスプライト(0)を並べる
  4424:               SpriteScreen.sprSwap ();  //表(0)と裏(-1)を入れ換える
  4425:               //ラスタ(dst=-1,src=-1)
  4426:               //表(-1)を表(1)として再利用する
  4427:               SpriteScreen.sprStep1 (1);  //表(1)にスプライト(1)を並べる
  4428:               SpriteScreen.sprSwap ();  //表(1)と裏(0)を入れ換える
  4429:               SpriteScreen.sprStep2 (0);  //表(0)にバックグラウンド(0)を並べる
  4430:             }
  4431:           }
  4432:           if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
  4433:             crtStereoscopicStart ();
  4434:           }
  4435:           TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12e)省略フレームの垂直映像期間の偶数ラスタの水平同期パルス
  4436:         }
  4437:       } else {  //垂直空白期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  4438:         //垂直映像期間開始ラスタではないとき
  4439:         TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  4440:       }
  4441:     }
  4442:   };
  4443:   //    (9)省略フレームの垂直空白期間の水平同期パルス
  4444:   public static final TickerQueue.Ticker DupExceptSpOmitIdleSync = new TickerQueue.Ticker () {
  4445:     @Override protected void tick () {
  4446:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  4447:       TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  4448:     }
  4449:   };
  4450:   //    (10)省略フレームの垂直空白期間の水平バックポーチと水平映像期間
  4451:   public static final TickerQueue.Ticker DupExceptSpOmitIdleBackDisp = new TickerQueue.Ticker () {
  4452:     @Override protected void tick () {
  4453:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  4454:       TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(8)省略フレームの垂直空白期間の水平フロントポーチ
  4455:     }
  4456:   };
  4457:   //    (11e)省略フレームの垂直映像期間の偶数ラスタの水平フロントポーチ
  4458:   public static final TickerQueue.Ticker DupExceptSpOmitDispEvenFront = new TickerQueue.Ticker () {
  4459:     @Override protected void tick () {
  4460:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  4461:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  4462:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  4463:           crtDoRasterCopy ();  //ラスタコピー実行
  4464:         }
  4465:         if (RasterBreakPoint.RBP_ON) {
  4466:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  4467:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4468:           }
  4469:         }
  4470:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  4471:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  4472:           if (irq == 0) {  //IRQ信号が0になったとき
  4473:             if (RasterBreakPoint.RBP_ON) {
  4474:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  4475:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4476:               }
  4477:             }
  4478:             MC68901.mfpRintFall ();  //IRQ開始
  4479:           } else {  //IRQ信号が0でなくなったとき
  4480:             MC68901.mfpRintRise ();  //IRQ終了
  4481:           }
  4482:         }
  4483:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  4484:           TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12e)省略フレームの垂直映像期間の偶数ラスタの水平同期パルス
  4485:         } else {  //垂直空白期間開始ラスタのとき
  4486:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  4487:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  4488:             crtClearFrames--;  //高速クリアカウンタを1減らす
  4489:           }
  4490:           if (CRT_ENABLE_INTERMITTENT) {
  4491:             crtIntermittentCounter--;  //間欠カウンタを1減らす
  4492:           }
  4493:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  4494:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  4495:           }
  4496:           if (XEiJ.PNL_USE_THREAD) {
  4497:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  4498:           }
  4499:           TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  4500:         }
  4501:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  4502:         //垂直空白期間開始ラスタではないとき
  4503:         TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12e)省略フレームの垂直映像期間の偶数ラスタの水平同期パルス
  4504:       }
  4505:     }
  4506:   };
  4507:   //    (11o)省略フレームの垂直映像期間の奇数ラスタの水平フロントポーチ
  4508:   public static final TickerQueue.Ticker DupExceptSpOmitDispOddFront = new TickerQueue.Ticker () {
  4509:     @Override protected void tick () {
  4510:       int n = ++crtRasterNumber;  //ラスタ番号を1増やす
  4511:       if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性があるとき
  4512:         if (crtRasterCopyOn) {  //ラスタコピースイッチがONのとき
  4513:           crtDoRasterCopy ();  //ラスタコピー実行
  4514:         }
  4515:         if (RasterBreakPoint.RBP_ON) {
  4516:           if (n == RasterBreakPoint.rbpActiveBreakRaster) {  //ブレークラスタのとき
  4517:             RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4518:           }
  4519:         }
  4520:         int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;  //IRQ信号を更新
  4521:         if (irq != MC68901.mfpGpipRint) {  //IRQ信号が変化したとき
  4522:           if (irq == 0) {  //IRQ信号が0になったとき
  4523:             if (RasterBreakPoint.RBP_ON) {
  4524:               if (RasterBreakPoint.rbpIRQBreakEnabled) {  //IRQラスタでラスタブレークをかけるとき
  4525:                 RasterBreakPoint.rbpFire ();  //ラスタブレークをかける
  4526:               }
  4527:             }
  4528:             MC68901.mfpRintFall ();  //IRQ開始
  4529:           } else {  //IRQ信号が0でなくなったとき
  4530:             MC68901.mfpRintRise ();  //IRQ終了
  4531:           }
  4532:         }
  4533:         if (n != crtVIdleStart) {  //垂直空白期間開始ラスタではないとき
  4534:           TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12o)省略フレームの垂直映像期間の奇数ラスタの水平同期パルス
  4535:         } else {  //垂直空白期間開始ラスタのとき
  4536:           MC68901.mfpVdispFall ();  //垂直映像期間終了
  4537:           if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  4538:             crtClearFrames--;  //高速クリアカウンタを1減らす
  4539:           }
  4540:           if (CRT_ENABLE_INTERMITTENT) {
  4541:             crtIntermittentCounter--;  //間欠カウンタを1減らす
  4542:           }
  4543:           if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
  4544:             crtDoFrameTask ();  //フレームタスク(コントラスト調整など)
  4545:           }
  4546:           if (XEiJ.PNL_USE_THREAD) {
  4547:             XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];  //書き込むビットマップを切り替える
  4548:           }
  4549:           TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(9)省略フレームの垂直空白期間の水平同期パルス
  4550:         }
  4551:       } else {  //垂直映像期間の水平フロントポーチでアクションを起こすべきラスタの可能性がないとき
  4552:         //垂直空白期間開始ラスタではないとき
  4553:         TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddSync, crtClock += crtHFrontLength);  //+水平フロントポーチの長さ→(12o)省略フレームの垂直映像期間の奇数ラスタの水平同期パルス
  4554:       }
  4555:     }
  4556:   };
  4557:   //    (12e)省略フレームの垂直映像期間の偶数ラスタの水平同期パルス
  4558:   public static final TickerQueue.Ticker DupExceptSpOmitDispEvenSync = new TickerQueue.Ticker () {
  4559:     @Override protected void tick () {
  4560:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  4561:       if (crtClearFrames != 0) {  //高速クリアカウンタが0ではないとき
  4562:         crtRapidClear (crtDataY);  //データY座標を高速クリア
  4563:         crtRasterStamp[crtDataY] = 0;
  4564:       }
  4565:       TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(13e)省略フレームの垂直映像期間の偶数ラスタの水平バックポーチと水平映像期間
  4566:     }
  4567:   };
  4568:   //    (12o)省略フレームの垂直映像期間の奇数ラスタの水平同期パルス
  4569:   public static final TickerQueue.Ticker DupExceptSpOmitDispOddSync = new TickerQueue.Ticker () {
  4570:     @Override protected void tick () {
  4571:       MC68901.mfpHsyncRise ();  //水平同期パルス開始
  4572:       TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddBackDisp, crtClock += crtHSyncLength);  //+水平同期パルスの長さ→(13o)省略フレームの垂直映像期間の奇数ラスタの水平バックポーチと水平映像期間
  4573:     }
  4574:   };
  4575:   //    (13e)省略フレームの垂直映像期間の偶数ラスタの水平バックポーチと水平映像期間
  4576:   public static final TickerQueue.Ticker DupExceptSpOmitDispEvenBackDisp = new TickerQueue.Ticker () {
  4577:     @Override protected void tick () {
  4578:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  4579:       TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(11o)省略フレームの垂直映像期間の奇数ラスタの水平フロントポーチ
  4580:     }
  4581:   };
  4582:   //    (13o)省略フレームの垂直映像期間の奇数ラスタの水平バックポーチと水平映像期間
  4583:   public static final TickerQueue.Ticker DupExceptSpOmitDispOddBackDisp = new TickerQueue.Ticker () {
  4584:     @Override protected void tick () {
  4585:       MC68901.mfpHsyncFall ();  //水平同期パルス終了
  4586:       TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenFront, crtClock += crtHBackDispLength);  //+水平バックポーチと水平映像期間の長さ→(11e)省略フレームの垂直映像期間の偶数ラスタの水平フロントポーチ
  4587:     }
  4588:   };
  4589: 
  4590: 
  4591: 
  4592: }  //class CRTC
  4593: 
  4594: 
  4595: