CRTC.java
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414: package xeij;
415:
416: import java.lang.*;
417: import java.util.*;
418:
419: public class CRTC {
420:
421:
422:
423:
424: public static final boolean CRT_EXTENDED_GRAPHIC = true;
425: public static boolean crtExtendedGraphicRequest;
426: public static boolean crtExtendedGraphicOn;
427:
428:
429: public static final long CRT_RESTART_DELAY = XEiJ.TMR_FREQ / 5;
430:
431:
432:
433:
434:
435: public static final int CRT_R00_H_FRONT_END = 0x00e80000;
436: public static final int CRT_R01_H_SYNC_END = 0x00e80002;
437: public static final int CRT_R02_H_BACK_END = 0x00e80004;
438: public static final int CRT_R03_H_DISP_END = 0x00e80006;
439: public static final int CRT_R04_V_FRONT_END = 0x00e80008;
440: public static final int CRT_R05_V_SYNC_END = 0x00e8000a;
441: public static final int CRT_R06_V_BACK_END = 0x00e8000c;
442: public static final int CRT_R07_V_DISP_END = 0x00e8000e;
443: public static final int CRT_R08_ADJUST = 0x00e80010;
444: public static final int CRT_R09_IRQ_RASTER = 0x00e80012;
445: public static final int CRT_R10_TX_X = 0x00e80014;
446: public static final int CRT_R11_TX_Y = 0x00e80016;
447: public static final int CRT_R12_GR_X_0 = 0x00e80018;
448: public static final int CRT_R13_GR_Y_0 = 0x00e8001a;
449: public static final int CRT_R14_GR_X_1 = 0x00e8001c;
450: public static final int CRT_R15_GR_Y_1 = 0x00e8001e;
451: public static final int CRT_R16_GR_X_2 = 0x00e80020;
452: public static final int CRT_R17_GR_Y_2 = 0x00e80022;
453: public static final int CRT_R18_GR_X_3 = 0x00e80024;
454: public static final int CRT_R19_GR_Y_3 = 0x00e80026;
455: public static final int CRT_R20_MODE = 0x00e80028;
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468: public static final int CRT_R21_SELECT = 0x00e8002a;
469:
470:
471:
472:
473:
474:
475:
476:
477:
478: public static final int CRT_R22_BLOCK = 0x00e8002c;
479:
480: public static final int CRT_R23_MASK = 0x00e8002e;
481: public static final int CRT_R24 = 0x00e80030;
482: public static final int CRT_ACTION = 0x00e80480;
483:
484:
485:
486:
487:
488:
489:
490: public static final int[] CRT_OSCS = { 0, 0, 0, 0, 1, 1, 1, 2, 0, 0, 0, 0, 1, 1, 1, 2 };
491: public static final int[] CRT_DIVS = { 8, 4, 8, 8, 6, 3, 2, 2, 8, 4, 8, 8, 8, 4, 2, 2 };
492: public static final int CRT_MIN_FREQ = 10000000;
493: public static final int CRT_MAX_FREQ = 400000000;
494: public static final int[] CRT_DEFAULT_FREQS = { 38863632, 69551900, 50349800 };
495: public static final int[] crtFreqsRequest = new int[3];
496: public static final int[] crtFreqs = new int[3];
497:
498:
499:
500: public static int crtR00HFrontEndPort;
501: public static int crtR00HFrontEndMask;
502: public static int crtR00HFrontEndTest;
503: public static int crtR00HFrontEndCurr;
504: public static int crtR01HSyncEndPort;
505: public static int crtR01HSyncEndMask;
506: public static int crtR01HSyncEndTest;
507: public static int crtR01HSyncEndCurr;
508: public static int crtR02HBackEndPort;
509: public static int crtR02HBackEndMask;
510: public static int crtR02HBackEndTest;
511: public static int crtR02HBackEndCurr;
512: public static int crtR03HDispEndPort;
513: public static int crtR03HDispEndMask;
514: public static int crtR03HDispEndTest;
515: public static int crtR03HDispEndCurr;
516: public static int crtR04VFrontEndPort;
517: public static int crtR04VFrontEndMask;
518: public static int crtR04VFrontEndTest;
519: public static int crtR04VFrontEndCurr;
520: public static int crtR05VSyncEndPort;
521: public static int crtR05VSyncEndMask;
522: public static int crtR05VSyncEndTest;
523: public static int crtR05VSyncEndCurr;
524: public static int crtR06VBackEndPort;
525: public static int crtR06VBackEndMask;
526: public static int crtR06VBackEndTest;
527: public static int crtR06VBackEndCurr;
528: public static int crtVDispStart;
529: public static int crtR07VDispEndPort;
530: public static int crtR07VDispEndMask;
531: public static int crtR07VDispEndTest;
532: public static int crtR07VDispEndCurr;
533: public static int crtVIdleStart;
534: public static int crtR08Adjust;
535: public static int crtR09IRQRasterPort;
536: public static int crtR09IRQRasterMask;
537: public static int crtR09IRQRasterTest;
538: public static int crtR09IRQRasterCurr;
539: public static int crtR10TxXPort;
540: public static int crtR10TxXMask;
541: public static int crtR10TxXTest;
542: public static int crtR10TxXCurr;
543: public static int crtR11TxYPort;
544: public static int crtR11TxYMask;
545: public static int crtR11TxYTest;
546: public static int crtR11TxYCurr;
547: public static int crtR11TxYZero;
548: public static int crtR11TxYZeroLast;
549: public static final int[] crtR12GrXPort = new int[4];
550:
551:
552:
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];
557:
558:
559:
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];
564: public static final int[] crtR13GrYZeroLast = new int[4];
565: public static int crtTextStorage;
566: public static int crtGraphicStorage;
567: public static int crtMemoryModePort;
568: public static int crtMemoryModeMask;
569: public static int crtMemoryModeTest;
570: public static int crtMemoryModeCurr;
571: public static int crtHighResoPort;
572: public static int crtHighResoMask;
573: public static int crtHighResoTest;
574: public static int crtHighResoCurr;
575: public static int crtVResoPort;
576: public static int crtVResoMask;
577: public static int crtVResoTest;
578: public static int crtVResoCurr;
579: public static int crtHResoPort;
580: public static int crtHResoMask;
581: public static int crtHResoTest;
582: public static int crtHResoCurr;
583: public static boolean crtCCPlane0;
584: public static boolean crtCCPlane1;
585: public static boolean crtCCPlane2;
586: public static boolean crtCCPlane3;
587: public static boolean crtSimPlane0;
588: public static boolean crtSimPlane1;
589: public static boolean crtSimPlane2;
590: public static boolean crtSimPlane3;
591: public static boolean crtSimAccess;
592: public static boolean crtBitMask;
593: public static int crtR22SrcBlock;
594: public static int crtR22DstBlock;
595: public static int crtR23Mask;
596: public static boolean crtRasterCopyOn;
597: public static boolean crtClearStandby;
598: public static int crtClearFrames;
599:
600: public static int crtHRLPort;
601: public static int crtHRLMask;
602: public static int crtHRLTest;
603: public static int crtHRLCurr;
604:
605: public static boolean crtDuplication;
606: public static boolean crtInterlace;
607: public static boolean crtSlit;
608: public static boolean crtDupExceptSp;
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;
616: public static int crtHSyncLength;
617: public static int crtHBackLength;
618: public static int crtHDispLength;
619: public static int crtHFrontLength;
620: public static int crtHBackDispLength;
621: public static long crtTotalLength;
622: public static long crtTotalLengthMNP;
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645:
646:
647:
648:
649:
650:
651:
652:
653:
654: public static int crtDirtyY0;
655: public static int crtDirtyY1;
656:
657: public static final int[] crtRasterStamp = new int[1024 + 15];
658: public static int crtAllStamp;
659:
660:
661:
662:
663:
664:
665:
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691:
692:
693:
694:
695:
696:
697:
698:
699:
700:
701:
702:
703:
704:
705:
706: public static int crtBeginningAllStamp;
707:
708: public static int crtRasterNumber;
709: public static int crtDataY;
710: public static int crtScreenY;
711: public static int crtFrameParity;
712:
713:
714:
715:
716:
717:
718:
719:
720:
721:
722:
723:
724:
725:
726:
727:
728:
729:
730:
731:
732:
733: public static final boolean CRT_RASTER_HASH_ON = true;
734: public static final long CRT_RASTER_HASH_ZERO = 0x0000000000000000L;
735: public static final long CRT_RASTER_HASH_MSB = 0x8000000000000000L;
736: public static long crtRasterHashIdle;
737: public static long crtRasterHashDisp;
738:
739:
740:
741:
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;
749:
750:
751:
752:
753:
754:
755:
756:
757:
758:
759:
760:
761:
762:
763:
764:
765:
766:
767:
768:
769:
770:
771:
772:
773:
774:
775:
776: public static final boolean CRT_ENABLE_INTERMITTENT = false;
777: public static int crtIntermittentInterval;
778: public static int crtIntermittentCounter;
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,
786: XEiJ.pnlBM, da,
787: XEiJ.pnlScreenWidth);
788: }
789: },
790: WEAK {
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 {
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 {
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,
864: da,
865: db,
866: 0xff000000);
867: }
868: };
869: public abstract void drawRaster (int screenY);
870: }
871: public static ScanlineEffect crtScanlineEffect;
872:
873:
874:
875:
876: public static boolean crtEleventhBitRequest;
877: public static boolean crtEleventhBit;
878: public static int crtVerticalMask;
879:
880:
881:
882:
883:
884:
885: public static boolean crtSphericalScrolling;
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;
892: crtMaskMinus4 = ~crtMask3;
893: crtMask511 = crtMask3 << 7 | 127;
894: crtAllStamp += 2;
895: }
896:
897:
898: public static boolean crtR00Bit0Zero;
899:
900:
901:
902: public static void crtInit () {
903:
904:
905:
906:
907:
908:
909:
910:
911:
912:
913:
914:
915:
916:
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:
951: crtEleventhBitRequest = Settings.sgsGetOnOff ("eleventhbit");
952:
953:
954: crtSphericalScrolling = Settings.sgsGetOnOff ("sphericalscrolling");
955: crtMask3 = 3;
956: crtMaskMinus4 = -4;
957: crtMask511 = 511;
958:
959:
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: }
976:
977:
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:
1005: Settings.sgsPutOnOff ("eleventhbit", crtEleventhBitRequest);
1006:
1007:
1008: Settings.sgsPutOnOff ("sphericalscrolling", crtSphericalScrolling);
1009:
1010:
1011: Settings.sgsPutOnOff ("r00bit0zero", crtR00Bit0Zero);
1012:
1013: }
1014:
1015:
1016:
1017:
1018:
1019:
1020:
1021:
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:
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;
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:
1188: crtIntermittentCounter = 0;
1189: }
1190:
1191: if (crtTicker != null) {
1192: TickerQueue.tkqRemove (crtTicker);
1193: crtTicker = null;
1194: }
1195: crtClock = XEiJ.FAR_FUTURE;
1196:
1197: }
1198:
1199:
1200:
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: }
1207:
1208:
1209:
1210: public static void crtStereoscopicStart () {
1211: if (XEiJ.PNL_USE_THREAD) {
1212: XEiJ.pnlBM = (XEiJ.pnlStereoscopicShutter != 1 ? XEiJ.pnlBMLeftArray[XEiJ.pnlBMWrite & 3] :
1213: XEiJ.pnlBMRightArray[XEiJ.pnlBMWrite & 3]);
1214: } else {
1215: XEiJ.pnlBM = (XEiJ.pnlStereoscopicShutter != 1 ? XEiJ.pnlBMLeft :
1216: XEiJ.pnlBMRight);
1217: }
1218: crtAllStamp += 2;
1219: }
1220:
1221:
1222:
1223: public static void crtStereoscopicDrawRaster (int screenY) {
1224: if (XEiJ.pnlStereoscopicShutter == 0 ||
1225: XEiJ.pnlStereoscopicShutter == 3) {
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:
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:
1260:
1261:
1262:
1263:
1264: public static void crtRepaint () {
1265: crtBeginningAllStamp = crtAllStamp;
1266: int l = Math.max (0, Math.min (1024, crtR07VDispEndCurr - crtR06VBackEndCurr));
1267: if (crtDuplication) {
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: if (Malfunction.MLF_ON) {
1274: Malfunction.mlfRaster (screenY >> 1);
1275: }
1276: VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);
1277: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1278: crtStereoscopicDrawRaster (screenY);
1279: }
1280:
1281: System.arraycopy (XEiJ.pnlBM, screenY << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlBM, screenY + 1 << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlScreenWidth);
1282: }
1283: } else if (crtSlit) {
1284: for (int screenY = 0; screenY < l; screenY += 2) {
1285: if (SpriteScreen.SPR_THREE_STEPS) {
1286: SpriteScreen.sprStep1 (screenY >> 1);
1287: SpriteScreen.sprStep2 (screenY >> 1);
1288: }
1289: if (Malfunction.MLF_ON) {
1290: Malfunction.mlfRaster (screenY >> 1);
1291: }
1292: VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);
1293: crtScanlineEffect.drawRaster (screenY + 1);
1294: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1295: crtStereoscopicDrawRaster (screenY);
1296: crtStereoscopicDrawRaster (screenY + 1);
1297: }
1298: }
1299: } else if (crtDupExceptSp) {
1300: for (int screenY = 0; screenY < l; screenY++) {
1301: if (SpriteScreen.SPR_THREE_STEPS) {
1302: SpriteScreen.sprStep1 (screenY);
1303: SpriteScreen.sprStep2 (screenY);
1304: }
1305: if (Malfunction.MLF_ON) {
1306: Malfunction.mlfRaster (screenY >> 1);
1307: }
1308: VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);
1309: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1310: crtStereoscopicDrawRaster (screenY);
1311: }
1312: }
1313: } else {
1314: for (int screenY = 0; screenY < l; screenY++) {
1315: if (SpriteScreen.SPR_THREE_STEPS) {
1316: SpriteScreen.sprStep1 (screenY);
1317: SpriteScreen.sprStep2 (screenY);
1318: }
1319: if (Malfunction.MLF_ON) {
1320: Malfunction.mlfRaster (screenY);
1321: }
1322: VideoController.vcnMode.drawRaster (screenY, screenY, false);
1323: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1324: crtStereoscopicDrawRaster (screenY);
1325: }
1326: }
1327: }
1328: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, l);
1329: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
1330: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, l);
1331: }
1332: }
1333:
1334:
1335:
1336:
1337:
1338:
1339: public static void crtDoFrameTask () {
1340: if (XEiJ.mpuClockTime >= crtContrastClock) {
1341: VideoController.vcnCurrentScaledContrast += VideoController.vcnCurrentScaledContrast < VideoController.vcnTargetScaledContrast ? 1 : -1;
1342: VideoController.vcnSetContrast (VideoController.vcnCurrentScaledContrast);
1343: if (VideoController.vcnCurrentScaledContrast == VideoController.vcnTargetScaledContrast) {
1344: crtContrastClock = XEiJ.FAR_FUTURE;
1345: } else {
1346: crtContrastClock += VideoController.VCN_CONTRAST_DELAY;
1347: }
1348: }
1349: if (XEiJ.mpuClockTime >= crtCaptureClock) {
1350: GIFAnimation.gifCaptureFrame ();
1351: }
1352: crtFrameTaskClock = Math.min (crtContrastClock, crtCaptureClock);
1353: }
1354:
1355:
1356:
1357:
1358:
1359: public static void crtSetMemoryMode (int textStorage, int graphicStorage, int memoryMode) {
1360: boolean updateMemoryMap = false;
1361: textStorage &= 1;
1362: if (crtTextStorage != textStorage) {
1363: crtTextStorage = textStorage;
1364: }
1365: graphicStorage &= 1;
1366: if (crtGraphicStorage != graphicStorage) {
1367: crtGraphicStorage = graphicStorage;
1368: updateMemoryMap = true;
1369: }
1370: memoryMode &= 7;
1371: crtMemoryModePort = memoryMode;
1372: int curr = crtMemoryModeMask == 0 ? crtMemoryModePort : crtMemoryModeTest;
1373: if (crtMemoryModeCurr != curr) {
1374: crtMemoryModeCurr = curr;
1375: updateMemoryMap = true;
1376: }
1377: if (updateMemoryMap) {
1378: if (crtGraphicStorage != 0) {
1379: if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn &&
1380: (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7)) {
1381:
1382: XEiJ.busSuper (MemoryMappedDevice.MMD_GJ0, 0x00c00000, 0x00e00000);
1383: } else {
1384:
1385: XEiJ.busSuper (MemoryMappedDevice.MMD_GG0, 0x00c00000, 0x00c80000);
1386: XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00c80000, 0x00e00000);
1387: }
1388: } else {
1389: switch (crtMemoryModeCurr) {
1390: case 0:
1391:
1392: XEiJ.busSuper (MemoryMappedDevice.MMD_GE0, 0x00c00000, 0x00c80000);
1393: XEiJ.busSuper (MemoryMappedDevice.MMD_GE1, 0x00c80000, 0x00d00000);
1394: XEiJ.busSuper (MemoryMappedDevice.MMD_GE2, 0x00d00000, 0x00d80000);
1395: XEiJ.busSuper (MemoryMappedDevice.MMD_GE3, 0x00d80000, 0x00e00000);
1396: break;
1397: case 1:
1398:
1399: XEiJ.busSuper (MemoryMappedDevice.MMD_GF0, 0x00c00000, 0x00c80000);
1400: XEiJ.busSuper (MemoryMappedDevice.MMD_GF1, 0x00c80000, 0x00d00000);
1401: XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00d00000, 0x00e00000);
1402: break;
1403: case 2:
1404:
1405: XEiJ.busSuper (MemoryMappedDevice.MMD_GM2, 0x00c00000, 0x00e00000);
1406: break;
1407: case 3:
1408:
1409: XEiJ.busSuper (MemoryMappedDevice.MMD_GG0, 0x00c00000, 0x00c80000);
1410: XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00c80000, 0x00e00000);
1411: break;
1412: case 4:
1413:
1414: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1415: break;
1416: case 5:
1417: if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn) {
1418:
1419: XEiJ.busSuper (MemoryMappedDevice.MMD_GI0, 0x00c00000, 0x00e00000);
1420: } else {
1421:
1422: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1423: }
1424: break;
1425: case 6:
1426:
1427: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1428: break;
1429: case 7:
1430: if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn) {
1431:
1432: XEiJ.busSuper (MemoryMappedDevice.MMD_GJ0, 0x00c00000, 0x00e00000);
1433: } else {
1434:
1435: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1436: }
1437: break;
1438: }
1439: }
1440: }
1441: }
1442:
1443:
1444:
1445:
1446:
1447:
1448:
1449:
1450:
1451:
1452:
1453: public static void crtUpdateRasterHash () {
1454: if (CRT_RASTER_HASH_ON) {
1455: long t = crtRasterCopyOn ? ~CRT_RASTER_HASH_ZERO : CRT_RASTER_HASH_ZERO;
1456:
1457: if (RasterBreakPoint.RBP_ON && RasterBreakPoint.rbpActiveBreakRaster >= 0) {
1458: t |= CRT_RASTER_HASH_MSB >>> RasterBreakPoint.rbpActiveBreakRaster;
1459: }
1460: if (crtR09IRQRasterCurr <= crtR04VFrontEndCurr) {
1461: t |= (CRT_RASTER_HASH_MSB >>> crtR09IRQRasterCurr |
1462: CRT_RASTER_HASH_MSB >>> (crtR09IRQRasterCurr < crtR04VFrontEndCurr ? crtR09IRQRasterCurr + 1 : 0));
1463: }
1464: crtRasterHashIdle = (t |
1465: CRT_RASTER_HASH_MSB >>> crtVDispStart |
1466: CRT_RASTER_HASH_MSB >>> crtR04VFrontEndCurr + 1);
1467: crtRasterHashDisp = (t |
1468: CRT_RASTER_HASH_MSB >>> crtVIdleStart);
1469: }
1470: }
1471:
1472:
1473:
1474:
1475:
1476:
1477:
1478:
1479:
1480:
1481:
1482:
1483:
1484:
1485:
1486:
1487:
1488:
1489:
1490:
1491:
1492:
1493:
1494:
1495:
1496:
1497:
1498:
1499:
1500:
1501:
1502:
1503:
1504:
1505:
1506:
1507: public static void crtRapidClear (int y) {
1508: y += crtR13GrYZero[0];
1509: int x = crtR12GrXCurr[0] & (512 - 2);
1510: int w = 8 * crtHDispColumn;
1511: if (512 <= w) {
1512: x = 0;
1513: w = 512;
1514: }
1515: if (crtMemoryModeCurr < 4) {
1516: int i = (y & 511) << 9;
1517: if (x + w <= 512) {
1518:
1519:
1520: if (crtCCPlane0) {
1521: Arrays.fill (GraphicScreen.graM4, i + x, i + x + w, (byte) 0);
1522: }
1523: if (crtCCPlane1) {
1524: Arrays.fill (GraphicScreen.graM4, 0x40000 + i + x, 0x40000 + i + x + w, (byte) 0);
1525: }
1526: if (crtCCPlane2) {
1527: Arrays.fill (GraphicScreen.graM4, 0x80000 + i + x, 0x80000 + i + x + w, (byte) 0);
1528: }
1529: if (crtCCPlane3) {
1530: Arrays.fill (GraphicScreen.graM4, 0xc0000 + i + x, 0xc0000 + i + x + w, (byte) 0);
1531: }
1532: } else {
1533:
1534:
1535: if (crtCCPlane0) {
1536: Arrays.fill (GraphicScreen.graM4, i + x, i + 512, (byte) 0);
1537: Arrays.fill (GraphicScreen.graM4, i , i + x + w - 512, (byte) 0);
1538: }
1539: if (crtCCPlane1) {
1540: Arrays.fill (GraphicScreen.graM4, 0x40000 + i + x, 0x40000 + i + 512, (byte) 0);
1541: Arrays.fill (GraphicScreen.graM4, 0x40000 + i , 0x40000 + i + x + w - 512, (byte) 0);
1542: }
1543: if (crtCCPlane2) {
1544: Arrays.fill (GraphicScreen.graM4, 0x80000 + i + x, 0x80000 + i + 512, (byte) 0);
1545: Arrays.fill (GraphicScreen.graM4, 0x80000 + i , 0x80000 + i + x + w - 512, (byte) 0);
1546: }
1547: if (crtCCPlane3) {
1548: Arrays.fill (GraphicScreen.graM4, 0xc0000 + i + x, 0xc0000 + i + 512, (byte) 0);
1549: Arrays.fill (GraphicScreen.graM4, 0xc0000 + i , 0xc0000 + i + x + w - 512, (byte) 0);
1550: }
1551: }
1552: } else {
1553: int i = (y & 512) << 10 | (y & 511) << 9;
1554: if (x + w <= 512) {
1555:
1556:
1557: for (int k = 0; k < 2; k++) {
1558: Arrays.fill (GraphicScreen.graM4, i + x, i + x + w, (byte) 0);
1559: if (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7) {
1560: Arrays.fill (GraphicScreen.graM4, 0x100000 + i + x, 0x100000 + i + x + w, (byte) 0);
1561: if (crtMemoryModeCurr == 7) {
1562: Arrays.fill (GraphicScreen.graM4, 0x200000 + i + x, 0x200000 + i + x + w, (byte) 0);
1563: Arrays.fill (GraphicScreen.graM4, 0x300000 + i + x, 0x300000 + i + x + w, (byte) 0);
1564: }
1565: }
1566: i += 512 << 9;
1567: }
1568: } else {
1569:
1570:
1571: for (int k = 0; k < 2; k++) {
1572: Arrays.fill (GraphicScreen.graM4, i + x, i + 512, (byte) 0);
1573: Arrays.fill (GraphicScreen.graM4, i , i + x + w - 512, (byte) 0);
1574: if (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7) {
1575: Arrays.fill (GraphicScreen.graM4, 0x100000 + i + x, 0x100000 + i + 512, (byte) 0);
1576: Arrays.fill (GraphicScreen.graM4, 0x100000 + i , 0x100000 + i + x + w - 512, (byte) 0);
1577: if (crtMemoryModeCurr == 7) {
1578: Arrays.fill (GraphicScreen.graM4, 0x200000 + i + x, 0x200000 + i + 512, (byte) 0);
1579: Arrays.fill (GraphicScreen.graM4, 0x200000 + i , 0x200000 + i + x + w - 512, (byte) 0);
1580: Arrays.fill (GraphicScreen.graM4, 0x300000 + i + x, 0x300000 + i + 512, (byte) 0);
1581: Arrays.fill (GraphicScreen.graM4, 0x300000 + i , 0x300000 + i + x + w - 512, (byte) 0);
1582: }
1583: }
1584: i += 512 << 9;
1585: }
1586: }
1587: }
1588: }
1589:
1590:
1591:
1592: public static void crtDoRasterCopy () {
1593: int srcOffset = crtR22SrcBlock << 9;
1594: int dstOffset = crtR22DstBlock << 9;
1595: if (crtCCPlane0) {
1596: System.arraycopy (MainMemory.mmrM8, 0x00e00000 + srcOffset, MainMemory.mmrM8, 0x00e00000 + dstOffset, 512);
1597: }
1598: if (crtCCPlane1) {
1599: System.arraycopy (MainMemory.mmrM8, 0x00e20000 + srcOffset, MainMemory.mmrM8, 0x00e20000 + dstOffset, 512);
1600: }
1601: if (crtCCPlane2) {
1602: System.arraycopy (MainMemory.mmrM8, 0x00e40000 + srcOffset, MainMemory.mmrM8, 0x00e40000 + dstOffset, 512);
1603: }
1604: if (crtCCPlane3) {
1605: System.arraycopy (MainMemory.mmrM8, 0x00e60000 + srcOffset, MainMemory.mmrM8, 0x00e60000 + dstOffset, 512);
1606: }
1607: int y = (dstOffset >> 7) - crtR11TxYZero;
1608: crtRasterStamp[y & 1023] = 0;
1609: crtRasterStamp[y + 1 & 1023] = 0;
1610: crtRasterStamp[y + 2 & 1023] = 0;
1611: crtRasterStamp[y + 3 & 1023] = 0;
1612: }
1613:
1614:
1615:
1616:
1617:
1618:
1619:
1620:
1621:
1622:
1623:
1624:
1625:
1626:
1627:
1628:
1629:
1630:
1631:
1632:
1633:
1634:
1635:
1636:
1637:
1638:
1639:
1640:
1641:
1642:
1643:
1644:
1645:
1646:
1647:
1648:
1649:
1650:
1651:
1652:
1653:
1654:
1655:
1656:
1657:
1658:
1659:
1660:
1661:
1662:
1663:
1664:
1665:
1666:
1667:
1668:
1669:
1670:
1671:
1672:
1673:
1674:
1675:
1676:
1677:
1678:
1679:
1680:
1681:
1682:
1683:
1684:
1685:
1686:
1687:
1688:
1689:
1690:
1691:
1692:
1693:
1694:
1695:
1696:
1697:
1698:
1699:
1700:
1701:
1702:
1703:
1704:
1705:
1706:
1707:
1708:
1709:
1710:
1711:
1712:
1713:
1714:
1715:
1716:
1717:
1718:
1719:
1720:
1721:
1722:
1723:
1724:
1725:
1726:
1727:
1728:
1729:
1730:
1731:
1732:
1733:
1734:
1735:
1736:
1737:
1738:
1739:
1740:
1741:
1742:
1743:
1744:
1745:
1746:
1747:
1748:
1749:
1750:
1751:
1752:
1753:
1754:
1755:
1756:
1757:
1758:
1759:
1760:
1761:
1762:
1763:
1764:
1765:
1766:
1767:
1768:
1769:
1770:
1771:
1772:
1773:
1774:
1775:
1776:
1777:
1778:
1779:
1780:
1781:
1782:
1783:
1784:
1785:
1786:
1787:
1788:
1789:
1790:
1791:
1792:
1793:
1794:
1795:
1796:
1797:
1798:
1799:
1800:
1801:
1802:
1803:
1804:
1805:
1806:
1807:
1808:
1809:
1810:
1811:
1812:
1813:
1814:
1815:
1816:
1817:
1818:
1819:
1820:
1821:
1822:
1823:
1824:
1825:
1826:
1827:
1828:
1829:
1830:
1831:
1832:
1833:
1834:
1835:
1836:
1837:
1838:
1839:
1840:
1841:
1842:
1843:
1844:
1845:
1846:
1847:
1848:
1849:
1850:
1851:
1852:
1853:
1854:
1855:
1856:
1857:
1858:
1859:
1860:
1861:
1862:
1863:
1864:
1865:
1866:
1867:
1868:
1869:
1870:
1871:
1872:
1873:
1874:
1875:
1876:
1877:
1878:
1879:
1880: public static void crtUpdateLength () {
1881: int k = crtHRLCurr << 3 | crtHighResoCurr << 2 | crtHResoCurr;
1882: double osc = (double) crtFreqs[CRT_OSCS[k]];
1883: int div = CRT_DIVS[k];
1884: int vTotal = crtR04VFrontEndCurr + 1;
1885: double multiplier = 1.0;
1886: if (XEiJ.pnlAdjustVsync && XEiJ.pnlFixedRate != 0.0) {
1887: double hFreq = osc / (8 * div * crtHTotalColumn);
1888: double vFreq = hFreq / vTotal;
1889: double rate = XEiJ.pnlFixedRate;
1890: if (vFreq * 0.75 <= rate && rate <= vFreq * 1.25) {
1891: multiplier = rate / vFreq;
1892: }
1893: }
1894: crtVsyncMultiplier = multiplier;
1895: crtColumnTime = (int) ((double) (XEiJ.TMR_FREQ * 8 * div) / (osc * multiplier) + 0.5);
1896: crtHSyncLength = crtColumnTime * crtHSyncColumn;
1897: crtHBackLength = crtColumnTime * crtHBackColumn;
1898: crtHDispLength = crtColumnTime * crtHDispColumn;
1899: crtHFrontLength = crtColumnTime * crtHFrontColumn;
1900: crtHBackDispLength = crtColumnTime * (crtHBackColumn + crtHDispColumn);
1901: long t = (long) crtColumnTime * (long) (crtHTotalColumn * vTotal);
1902: crtTotalLength = t / 1000000000L;
1903: crtTotalLengthMNP = t - 1000000000L * crtTotalLength;
1904: }
1905:
1906:
1907:
1908: public static final TickerQueue.Ticker InitialStage = new TickerQueue.Ticker () {
1909: @Override protected void tick () {
1910: ret:
1911: {
1912:
1913:
1914:
1915:
1916:
1917: if (!(crtR02HBackEndCurr < crtR03HDispEndCurr && crtR03HDispEndCurr - crtR02HBackEndCurr <= 128 &&
1918: crtR07VDispEndCurr < crtR04VFrontEndCurr && crtR07VDispEndCurr - crtR06VBackEndCurr <= 1024 &&
1919: crtR05VSyncEndCurr < crtR06VBackEndCurr &&
1920: crtR06VBackEndCurr < crtR07VDispEndCurr)) {
1921: crtRestart ();
1922: break ret;
1923: }
1924:
1925: if (CRT_RASTER_HASH_ON) {
1926: crtUpdateRasterHash ();
1927: }
1928:
1929:
1930:
1931:
1932:
1933:
1934: int hSync = crtR01HSyncEndCurr + 1;
1935: int hBack = crtR02HBackEndCurr - crtR01HSyncEndCurr + 4;
1936: int hDisp = crtR03HDispEndCurr - crtR02HBackEndCurr;
1937: int hFront = crtR00HFrontEndCurr - crtR03HDispEndCurr - 4;
1938: if (hSync + hBack + hDisp + hFront < hDisp + 3) {
1939: hSync = hBack = hFront = 1;
1940: } else {
1941: if (hBack <= 0) {
1942: hFront -= 1 - hBack;
1943: hBack = 1;
1944: if (hFront <= 0) {
1945: hSync -= 1 - hFront;
1946: hFront = 1;
1947: }
1948: } else if (hFront <= 0) {
1949: hBack -= 1 - hFront;
1950: hFront = 1;
1951: if (hBack <= 0) {
1952: hSync -= 1 - hBack;
1953: hBack = 1;
1954: }
1955: }
1956: }
1957: crtHSyncColumn = hSync;
1958: crtHBackColumn = hBack;
1959: crtHDispColumn = hDisp;
1960: crtHFrontColumn = hFront;
1961: crtHTotalColumn = hSync + hBack + hDisp + hFront;
1962: crtUpdateLength ();
1963:
1964: crtDuplication = crtHighResoCurr == 1 && crtVResoCurr == 0 && ((SpriteScreen.sprReg8ResoCurr & 12) != 4);
1965: crtInterlace = crtHighResoCurr + 1 <= crtVResoCurr;
1966: crtSlit = crtHighResoCurr == 0 && crtVResoCurr == 0;
1967: crtDupExceptSp = crtHighResoCurr == 1 && crtVResoCurr == 0 && ((SpriteScreen.sprReg8ResoCurr & 12) == 4);
1968:
1969: XEiJ.pnlUpdateArrangement ();
1970:
1971: crtAllStamp += 2;
1972: (crtDuplication ? DuplicationStart :
1973: crtInterlace ? InterlaceStart :
1974: crtSlit ? SlitStart :
1975: crtDupExceptSp ? DupExceptSpStart :
1976: NormalStart).tick ();
1977: }
1978: }
1979: };
1980:
1981:
1982:
1983:
1984: public static final TickerQueue.Ticker NormalStart = new TickerQueue.Ticker () {
1985: @Override protected void tick () {
1986: if (MC68901.mfpGpipHsync != 0) {
1987: MC68901.mfpHsyncFall ();
1988: }
1989: int n = crtRasterNumber = crtVIdleStart;
1990: if (crtRasterCopyOn) {
1991: crtDoRasterCopy ();
1992: }
1993: if (RasterBreakPoint.RBP_ON) {
1994: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
1995: RasterBreakPoint.rbpFire ();
1996: }
1997: }
1998: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
1999: if (irq != MC68901.mfpGpipRint) {
2000: if (irq == 0) {
2001: if (RasterBreakPoint.RBP_ON) {
2002: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2003: RasterBreakPoint.rbpFire ();
2004: }
2005: }
2006: MC68901.mfpRintFall ();
2007: } else {
2008: MC68901.mfpRintRise ();
2009: }
2010: }
2011: if (MC68901.mfpGpipVdisp != 0) {
2012: MC68901.mfpVdispFall ();
2013: }
2014: crtClearFrames = 0;
2015: if (CRT_ENABLE_INTERMITTENT) {
2016: crtIntermittentCounter = 0;
2017: }
2018: if (!XEiJ.PNL_USE_THREAD) {
2019: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2020: crtDoFrameTask ();
2021: }
2022: }
2023: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
2024: }
2025: };
2026:
2027: public static final TickerQueue.Ticker NormalDrawIdleFront = new TickerQueue.Ticker () {
2028: @Override protected void tick () {
2029: int n = ++crtRasterNumber;
2030: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2031: if (crtR04VFrontEndCurr < n) {
2032: n = crtRasterNumber = 0;
2033: }
2034: if (crtRasterCopyOn) {
2035: crtDoRasterCopy ();
2036: }
2037: if (RasterBreakPoint.RBP_ON) {
2038: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2039: RasterBreakPoint.rbpFire ();
2040: }
2041: }
2042: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2043: if (irq != MC68901.mfpGpipRint) {
2044: if (irq == 0) {
2045: if (RasterBreakPoint.RBP_ON) {
2046: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2047: RasterBreakPoint.rbpFire ();
2048: }
2049: }
2050: MC68901.mfpRintFall ();
2051: } else {
2052: MC68901.mfpRintRise ();
2053: }
2054: }
2055: if (n != crtVDispStart) {
2056: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
2057: } else {
2058: MC68901.mfpVdispRise ();
2059: crtR11TxYZero = crtR11TxYCurr;
2060: crtR13GrYZero[0] = crtR13GrYCurr[0];
2061: crtR13GrYZero[1] = crtR13GrYCurr[1];
2062: crtR13GrYZero[2] = crtR13GrYCurr[2];
2063: crtR13GrYZero[3] = crtR13GrYCurr[3];
2064: if (crtR11TxYZeroLast != crtR11TxYZero ||
2065: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2066: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2067: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2068: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2069: crtR11TxYZeroLast = crtR11TxYZero;
2070: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2071: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2072: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2073: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2074: crtAllStamp += 2;
2075: }
2076: crtDataY = 0;
2077: if (crtClearFrames != 0) {
2078: crtClearFrames--;
2079: } else if (crtClearStandby) {
2080: crtClearStandby = false;
2081: crtClearFrames = 1;
2082: }
2083: crtScreenY = 0;
2084: if (!XEiJ.PNL_USE_THREAD) {
2085: crtDirtyY0 = -1;
2086: }
2087: if (XEiJ.PNL_USE_THREAD) {
2088: crtAllStamp += 2;
2089: }
2090: if (SpriteScreen.SPR_THREE_STEPS) {
2091: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2092: if (SpriteScreen.sprActive) {
2093: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2094: SpriteScreen.sprLatched = false;
2095: }
2096: if (!XEiJ.PNL_USE_THREAD) {
2097: crtAllStamp += 2;
2098: }
2099:
2100: SpriteScreen.sprStep1 (0);
2101: SpriteScreen.sprSwap ();
2102:
2103:
2104: SpriteScreen.sprStep1 (1);
2105: SpriteScreen.sprSwap ();
2106: SpriteScreen.sprStep2 (0);
2107: }
2108: }
2109: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2110: crtStereoscopicStart ();
2111: }
2112: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
2113: }
2114: } else {
2115:
2116: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
2117: }
2118: }
2119: };
2120:
2121: public static final TickerQueue.Ticker NormalDrawIdleSync = new TickerQueue.Ticker () {
2122: @Override protected void tick () {
2123: MC68901.mfpHsyncRise ();
2124: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleBackDisp, crtClock += crtHSyncLength);
2125: }
2126: };
2127:
2128: public static final TickerQueue.Ticker NormalDrawIdleBackDisp = new TickerQueue.Ticker () {
2129: @Override protected void tick () {
2130: MC68901.mfpHsyncFall ();
2131: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleFront, crtClock += crtHBackDispLength);
2132: }
2133: };
2134:
2135: public static final TickerQueue.Ticker NormalDrawDispFront = new TickerQueue.Ticker () {
2136: @Override protected void tick () {
2137: int n = ++crtRasterNumber;
2138: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2139: if (crtRasterCopyOn) {
2140: crtDoRasterCopy ();
2141: }
2142: if (RasterBreakPoint.RBP_ON) {
2143: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2144: RasterBreakPoint.rbpFire ();
2145: }
2146: }
2147: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2148: if (irq != MC68901.mfpGpipRint) {
2149: if (irq == 0) {
2150: if (RasterBreakPoint.RBP_ON) {
2151: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2152: RasterBreakPoint.rbpFire ();
2153: }
2154: }
2155: MC68901.mfpRintFall ();
2156: } else {
2157: MC68901.mfpRintRise ();
2158: }
2159: }
2160: if (n != crtVIdleStart) {
2161: if (crtBeginningAllStamp != crtAllStamp) {
2162: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2163: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2164: crtStereoscopicDrawRaster (crtScreenY);
2165: }
2166: }
2167: crtScreenY++;
2168: crtDataY++;
2169: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
2170: } else {
2171: if (crtBeginningAllStamp != crtAllStamp) {
2172: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2173: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2174: crtStereoscopicDrawRaster (crtScreenY);
2175: }
2176: }
2177: MC68901.mfpVdispFall ();
2178: if (!XEiJ.PNL_USE_THREAD) {
2179: if (crtDirtyY0 >= 0) {
2180: crtUpdateScreen ();
2181: if (CRT_ENABLE_INTERMITTENT) {
2182: crtIntermittentCounter = crtIntermittentInterval;
2183: }
2184: }
2185: }
2186: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2187: crtDoFrameTask ();
2188: }
2189: if (XEiJ.PNL_USE_THREAD) {
2190: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2191: }
2192: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
2193: }
2194: } else {
2195:
2196: if (crtBeginningAllStamp != crtAllStamp) {
2197: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2198: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2199: crtStereoscopicDrawRaster (crtScreenY);
2200: }
2201: }
2202: crtScreenY++;
2203: crtDataY++;
2204: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
2205: }
2206: }
2207: };
2208:
2209: public static final TickerQueue.Ticker NormalDrawDispSync = new TickerQueue.Ticker () {
2210: @Override protected void tick () {
2211: MC68901.mfpHsyncRise ();
2212: if (crtClearFrames != 0) {
2213: crtRapidClear (crtDataY);
2214: crtRasterStamp[crtDataY] = 0;
2215: }
2216: TickerQueue.tkqAdd (crtTicker = NormalDrawDispBack, crtClock += crtHSyncLength);
2217: }
2218: };
2219:
2220: public static final TickerQueue.Ticker NormalDrawDispBack = new TickerQueue.Ticker () {
2221: @Override protected void tick () {
2222: MC68901.mfpHsyncFall ();
2223: TickerQueue.tkqAdd (crtTicker = NormalDrawDispDisp, crtClock += crtHBackLength);
2224: }
2225: };
2226:
2227: public static final TickerQueue.Ticker NormalDrawDispDisp = new TickerQueue.Ticker () {
2228: @Override protected void tick () {
2229: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2230: crtRasterStamp[crtDataY] = crtAllStamp;
2231: crtBeginningAllStamp = crtAllStamp;
2232: if (Malfunction.MLF_ON) {
2233: Malfunction.mlfRaster (crtDataY);
2234: }
2235: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2236: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2237: crtStereoscopicDrawRaster (crtScreenY);
2238: }
2239: if (!XEiJ.PNL_USE_THREAD) {
2240: if (crtDirtyY0 < 0) {
2241: crtDirtyY0 = crtScreenY;
2242: }
2243: crtDirtyY1 = crtScreenY;
2244: }
2245: }
2246: if (SpriteScreen.SPR_THREE_STEPS) {
2247: if (SpriteScreen.sprActive) {
2248:
2249:
2250: SpriteScreen.sprStep1 (crtDataY + 2);
2251: SpriteScreen.sprSwap ();
2252: SpriteScreen.sprStep2 (crtDataY + 1);
2253: }
2254: }
2255: TickerQueue.tkqAdd (crtTicker = NormalDrawDispFront, crtClock += crtHDispLength);
2256: }
2257: };
2258:
2259: public static final TickerQueue.Ticker NormalOmitIdleFront = new TickerQueue.Ticker () {
2260: @Override protected void tick () {
2261: int n = ++crtRasterNumber;
2262: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2263: if (crtR04VFrontEndCurr < n) {
2264: n = crtRasterNumber = 0;
2265: }
2266: if (crtRasterCopyOn) {
2267: crtDoRasterCopy ();
2268: }
2269: if (RasterBreakPoint.RBP_ON) {
2270: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2271: RasterBreakPoint.rbpFire ();
2272: }
2273: }
2274: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2275: if (irq != MC68901.mfpGpipRint) {
2276: if (irq == 0) {
2277: if (RasterBreakPoint.RBP_ON) {
2278: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2279: RasterBreakPoint.rbpFire ();
2280: }
2281: }
2282: MC68901.mfpRintFall ();
2283: } else {
2284: MC68901.mfpRintRise ();
2285: }
2286: }
2287: if (n != crtVDispStart) {
2288: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2289: } else {
2290: MC68901.mfpVdispRise ();
2291: crtR11TxYZero = crtR11TxYCurr;
2292: crtR13GrYZero[0] = crtR13GrYCurr[0];
2293: crtR13GrYZero[1] = crtR13GrYCurr[1];
2294: crtR13GrYZero[2] = crtR13GrYCurr[2];
2295: crtR13GrYZero[3] = crtR13GrYCurr[3];
2296: if (crtR11TxYZeroLast != crtR11TxYZero ||
2297: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2298: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2299: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2300: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2301: crtR11TxYZeroLast = crtR11TxYZero;
2302: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2303: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2304: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2305: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2306: crtAllStamp += 2;
2307: }
2308: crtDataY = 0;
2309: if (crtClearFrames != 0) {
2310: crtClearFrames--;
2311: } else if (crtClearStandby) {
2312: crtClearStandby = false;
2313: crtClearFrames = 1;
2314: }
2315: if (XEiJ.PNL_USE_THREAD) {
2316: crtAllStamp += 2;
2317: }
2318: if (SpriteScreen.SPR_THREE_STEPS) {
2319: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2320: if (SpriteScreen.sprActive) {
2321: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2322: SpriteScreen.sprLatched = false;
2323: }
2324: if (!XEiJ.PNL_USE_THREAD) {
2325: crtAllStamp += 2;
2326: }
2327:
2328: SpriteScreen.sprStep1 (0);
2329: SpriteScreen.sprSwap ();
2330:
2331:
2332: SpriteScreen.sprStep1 (1);
2333: SpriteScreen.sprSwap ();
2334: SpriteScreen.sprStep2 (0);
2335: }
2336: }
2337: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2338: crtStereoscopicStart ();
2339: }
2340: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2341: }
2342: } else {
2343:
2344: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2345: }
2346: }
2347: };
2348:
2349: public static final TickerQueue.Ticker NormalOmitIdleSync = new TickerQueue.Ticker () {
2350: @Override protected void tick () {
2351: MC68901.mfpHsyncRise ();
2352: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleBackDisp, crtClock += crtHSyncLength);
2353: }
2354: };
2355:
2356: public static final TickerQueue.Ticker NormalOmitIdleBackDisp = new TickerQueue.Ticker () {
2357: @Override protected void tick () {
2358: MC68901.mfpHsyncFall ();
2359: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleFront, crtClock += crtHBackDispLength);
2360: }
2361: };
2362:
2363: public static final TickerQueue.Ticker NormalOmitDispFront = new TickerQueue.Ticker () {
2364: @Override protected void tick () {
2365: int n = ++crtRasterNumber;
2366: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2367: if (crtRasterCopyOn) {
2368: crtDoRasterCopy ();
2369: }
2370: if (RasterBreakPoint.RBP_ON) {
2371: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2372: RasterBreakPoint.rbpFire ();
2373: }
2374: }
2375: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2376: if (irq != MC68901.mfpGpipRint) {
2377: if (irq == 0) {
2378: if (RasterBreakPoint.RBP_ON) {
2379: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2380: RasterBreakPoint.rbpFire ();
2381: }
2382: }
2383: MC68901.mfpRintFall ();
2384: } else {
2385: MC68901.mfpRintRise ();
2386: }
2387: }
2388: if (n != crtVIdleStart) {
2389: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2390: } else {
2391: MC68901.mfpVdispFall ();
2392: if (CRT_ENABLE_INTERMITTENT) {
2393: crtIntermittentCounter--;
2394: }
2395: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2396: crtDoFrameTask ();
2397: }
2398: if (XEiJ.PNL_USE_THREAD) {
2399: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2400: }
2401: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2402: }
2403: } else {
2404:
2405: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2406: }
2407: }
2408: };
2409:
2410: public static final TickerQueue.Ticker NormalOmitDispSync = new TickerQueue.Ticker () {
2411: @Override protected void tick () {
2412: MC68901.mfpHsyncRise ();
2413: if (crtClearFrames != 0) {
2414: crtRapidClear (crtDataY);
2415: crtRasterStamp[crtDataY] = 0;
2416: }
2417: TickerQueue.tkqAdd (crtTicker = NormalOmitDispBackDisp, crtClock += crtHSyncLength);
2418: }
2419: };
2420:
2421: public static final TickerQueue.Ticker NormalOmitDispBackDisp = new TickerQueue.Ticker () {
2422: @Override protected void tick () {
2423: MC68901.mfpHsyncFall ();
2424: TickerQueue.tkqAdd (crtTicker = NormalOmitDispFront, crtClock += crtHBackDispLength);
2425: }
2426: };
2427:
2428:
2429:
2430:
2431: public static final TickerQueue.Ticker DuplicationStart = new TickerQueue.Ticker () {
2432: @Override protected void tick () {
2433: if (MC68901.mfpGpipHsync != 0) {
2434: MC68901.mfpHsyncFall ();
2435: }
2436: int n = crtRasterNumber = crtVIdleStart;
2437: if (crtRasterCopyOn) {
2438: crtDoRasterCopy ();
2439: }
2440: if (RasterBreakPoint.RBP_ON) {
2441: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2442: RasterBreakPoint.rbpFire ();
2443: }
2444: }
2445: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2446: if (irq != MC68901.mfpGpipRint) {
2447: if (irq == 0) {
2448: if (RasterBreakPoint.RBP_ON) {
2449: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2450: RasterBreakPoint.rbpFire ();
2451: }
2452: }
2453: MC68901.mfpRintFall ();
2454: } else {
2455: MC68901.mfpRintRise ();
2456: }
2457: }
2458: if (MC68901.mfpGpipVdisp != 0) {
2459: MC68901.mfpVdispFall ();
2460: }
2461: crtClearFrames = 0;
2462: if (CRT_ENABLE_INTERMITTENT) {
2463: crtIntermittentCounter = 0;
2464: }
2465: if (!XEiJ.PNL_USE_THREAD) {
2466: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2467: crtDoFrameTask ();
2468: }
2469: }
2470: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2471: }
2472: };
2473:
2474: public static final TickerQueue.Ticker DuplicationDrawIdleFront = new TickerQueue.Ticker () {
2475: @Override protected void tick () {
2476: int n = ++crtRasterNumber;
2477: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2478: if (crtR04VFrontEndCurr < n) {
2479: n = crtRasterNumber = 0;
2480: }
2481: if (crtRasterCopyOn) {
2482: crtDoRasterCopy ();
2483: }
2484: if (RasterBreakPoint.RBP_ON) {
2485: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2486: RasterBreakPoint.rbpFire ();
2487: }
2488: }
2489: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2490: if (irq != MC68901.mfpGpipRint) {
2491: if (irq == 0) {
2492: if (RasterBreakPoint.RBP_ON) {
2493: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2494: RasterBreakPoint.rbpFire ();
2495: }
2496: }
2497: MC68901.mfpRintFall ();
2498: } else {
2499: MC68901.mfpRintRise ();
2500: }
2501: }
2502: if (n != crtVDispStart) {
2503: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2504: } else {
2505: MC68901.mfpVdispRise ();
2506: crtR11TxYZero = crtR11TxYCurr;
2507: crtR13GrYZero[0] = crtR13GrYCurr[0];
2508: crtR13GrYZero[1] = crtR13GrYCurr[1];
2509: crtR13GrYZero[2] = crtR13GrYCurr[2];
2510: crtR13GrYZero[3] = crtR13GrYCurr[3];
2511: if (crtR11TxYZeroLast != crtR11TxYZero ||
2512: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2513: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2514: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2515: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2516: crtR11TxYZeroLast = crtR11TxYZero;
2517: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2518: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2519: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2520: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2521: crtAllStamp += 2;
2522: }
2523: crtDataY = 0;
2524: if (crtClearFrames != 0) {
2525: crtClearFrames--;
2526: } else if (crtClearStandby) {
2527: crtClearStandby = false;
2528: crtClearFrames = 1;
2529: }
2530: crtScreenY = 0;
2531: if (!XEiJ.PNL_USE_THREAD) {
2532: crtDirtyY0 = -1;
2533: }
2534: if (XEiJ.PNL_USE_THREAD) {
2535: crtAllStamp += 2;
2536: }
2537: if (SpriteScreen.SPR_THREE_STEPS) {
2538: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2539: if (SpriteScreen.sprActive) {
2540: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2541: SpriteScreen.sprLatched = false;
2542: }
2543: if (!XEiJ.PNL_USE_THREAD) {
2544: crtAllStamp += 2;
2545: }
2546:
2547: SpriteScreen.sprStep1 (0);
2548: SpriteScreen.sprSwap ();
2549:
2550:
2551: SpriteScreen.sprStep1 (0);
2552: SpriteScreen.sprSwap ();
2553: SpriteScreen.sprStep2 (0);
2554: }
2555: }
2556: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2557: crtStereoscopicStart ();
2558: }
2559: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2560: }
2561: } else {
2562:
2563: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2564: }
2565: }
2566: };
2567:
2568: public static final TickerQueue.Ticker DuplicationDrawIdleSync = new TickerQueue.Ticker () {
2569: @Override protected void tick () {
2570: MC68901.mfpHsyncRise ();
2571: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleBackDisp, crtClock += crtHSyncLength);
2572: }
2573: };
2574:
2575: public static final TickerQueue.Ticker DuplicationDrawIdleBackDisp = new TickerQueue.Ticker () {
2576: @Override protected void tick () {
2577: MC68901.mfpHsyncFall ();
2578: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleFront, crtClock += crtHBackDispLength);
2579: }
2580: };
2581:
2582: public static final TickerQueue.Ticker DuplicationDrawDispEvenFront = new TickerQueue.Ticker () {
2583: @Override protected void tick () {
2584: int n = ++crtRasterNumber;
2585: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2586: if (crtRasterCopyOn) {
2587: crtDoRasterCopy ();
2588: }
2589: if (RasterBreakPoint.RBP_ON) {
2590: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2591: RasterBreakPoint.rbpFire ();
2592: }
2593: }
2594: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2595: if (irq != MC68901.mfpGpipRint) {
2596: if (irq == 0) {
2597: if (RasterBreakPoint.RBP_ON) {
2598: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2599: RasterBreakPoint.rbpFire ();
2600: }
2601: }
2602: MC68901.mfpRintFall ();
2603: } else {
2604: MC68901.mfpRintRise ();
2605: }
2606: }
2607: if (n != crtVIdleStart) {
2608: if (crtBeginningAllStamp != crtAllStamp) {
2609: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2610: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2611: crtStereoscopicDrawRaster (crtScreenY);
2612: }
2613: }
2614: crtScreenY++;
2615: crtDataY++;
2616: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2617: } else {
2618: if (crtBeginningAllStamp != crtAllStamp) {
2619: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2620: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2621: crtStereoscopicDrawRaster (crtScreenY);
2622: }
2623: }
2624: MC68901.mfpVdispFall ();
2625: if (!XEiJ.PNL_USE_THREAD) {
2626: if (crtDirtyY0 >= 0) {
2627: crtUpdateScreen ();
2628: if (CRT_ENABLE_INTERMITTENT) {
2629: crtIntermittentCounter = crtIntermittentInterval;
2630: }
2631: }
2632: }
2633: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2634: crtDoFrameTask ();
2635: }
2636: if (XEiJ.PNL_USE_THREAD) {
2637: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2638: }
2639: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2640: }
2641: } else {
2642:
2643: if (crtBeginningAllStamp != crtAllStamp) {
2644: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2645: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2646: crtStereoscopicDrawRaster (crtScreenY);
2647: }
2648: }
2649: crtScreenY++;
2650: crtDataY++;
2651: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2652: }
2653: }
2654: };
2655:
2656: public static final TickerQueue.Ticker DuplicationDrawDispOddFront = new TickerQueue.Ticker () {
2657: @Override protected void tick () {
2658: int n = ++crtRasterNumber;
2659: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2660: if (crtRasterCopyOn) {
2661: crtDoRasterCopy ();
2662: }
2663: if (RasterBreakPoint.RBP_ON) {
2664: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2665: RasterBreakPoint.rbpFire ();
2666: }
2667: }
2668: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2669: if (irq != MC68901.mfpGpipRint) {
2670: if (irq == 0) {
2671: if (RasterBreakPoint.RBP_ON) {
2672: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2673: RasterBreakPoint.rbpFire ();
2674: }
2675: }
2676: MC68901.mfpRintFall ();
2677: } else {
2678: MC68901.mfpRintRise ();
2679: }
2680: }
2681: if (n != crtVIdleStart) {
2682: if (crtBeginningAllStamp != crtAllStamp) {
2683: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2684: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2685: crtStereoscopicDrawRaster (crtScreenY);
2686: }
2687: }
2688: crtScreenY++;
2689: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);
2690: } else {
2691: if (crtBeginningAllStamp != crtAllStamp) {
2692: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2693: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2694: crtStereoscopicDrawRaster (crtScreenY);
2695: }
2696: }
2697: MC68901.mfpVdispFall ();
2698: if (!XEiJ.PNL_USE_THREAD) {
2699: if (crtDirtyY0 >= 0) {
2700: crtUpdateScreen ();
2701: if (CRT_ENABLE_INTERMITTENT) {
2702: crtIntermittentCounter = crtIntermittentInterval;
2703: }
2704: }
2705: }
2706: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2707: crtDoFrameTask ();
2708: }
2709: if (XEiJ.PNL_USE_THREAD) {
2710: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2711: }
2712: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2713: }
2714: } else {
2715:
2716: if (crtBeginningAllStamp != crtAllStamp) {
2717: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2718: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2719: crtStereoscopicDrawRaster (crtScreenY);
2720: }
2721: }
2722: crtScreenY++;
2723: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);
2724: }
2725: }
2726: };
2727:
2728: public static final TickerQueue.Ticker DuplicationDrawDispEvenSync = new TickerQueue.Ticker () {
2729: @Override protected void tick () {
2730: MC68901.mfpHsyncRise ();
2731: if (crtClearFrames != 0) {
2732: crtRapidClear (crtDataY);
2733: crtRasterStamp[crtDataY] = 0;
2734: }
2735: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenBack, crtClock += crtHSyncLength);
2736: }
2737: };
2738:
2739: public static final TickerQueue.Ticker DuplicationDrawDispOddSync = new TickerQueue.Ticker () {
2740: @Override protected void tick () {
2741: MC68901.mfpHsyncRise ();
2742: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddBack, crtClock += crtHSyncLength);
2743: }
2744: };
2745:
2746: public static final TickerQueue.Ticker DuplicationDrawDispEvenBack = new TickerQueue.Ticker () {
2747: @Override protected void tick () {
2748: MC68901.mfpHsyncFall ();
2749: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenDisp, crtClock += crtHBackLength);
2750: }
2751: };
2752:
2753: public static final TickerQueue.Ticker DuplicationDrawDispOddBack = new TickerQueue.Ticker () {
2754: @Override protected void tick () {
2755: MC68901.mfpHsyncFall ();
2756: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddDisp, crtClock += crtHBackLength);
2757: }
2758: };
2759:
2760: public static final TickerQueue.Ticker DuplicationDrawDispEvenDisp = new TickerQueue.Ticker () {
2761: @Override protected void tick () {
2762: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2763: crtBeginningAllStamp = crtAllStamp;
2764: if (Malfunction.MLF_ON) {
2765: Malfunction.mlfRaster (crtDataY);
2766: }
2767: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2768: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2769: crtStereoscopicDrawRaster (crtScreenY);
2770: }
2771: if (!XEiJ.PNL_USE_THREAD) {
2772: if (crtDirtyY0 < 0) {
2773: crtDirtyY0 = crtScreenY;
2774: }
2775: crtDirtyY1 = crtScreenY;
2776: }
2777: }
2778: if (SpriteScreen.SPR_THREE_STEPS) {
2779: if (SpriteScreen.sprActive) {
2780:
2781:
2782: SpriteScreen.sprStep1 (crtDataY + 1);
2783: SpriteScreen.sprSwap ();
2784: SpriteScreen.sprStep2 (crtDataY);
2785: }
2786: }
2787: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddFront, crtClock += crtHDispLength);
2788: }
2789: };
2790:
2791: public static final TickerQueue.Ticker DuplicationDrawDispOddDisp = new TickerQueue.Ticker () {
2792: @Override protected void tick () {
2793: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2794: crtRasterStamp[crtDataY] = crtAllStamp;
2795: crtBeginningAllStamp = crtAllStamp;
2796: if (Malfunction.MLF_ON) {
2797: Malfunction.mlfRaster (crtDataY);
2798: }
2799: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2800: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2801: crtStereoscopicDrawRaster (crtScreenY);
2802: }
2803: if (!XEiJ.PNL_USE_THREAD) {
2804: if (crtDirtyY0 < 0) {
2805: crtDirtyY0 = crtScreenY;
2806: }
2807: crtDirtyY1 = crtScreenY;
2808: }
2809: }
2810: if (SpriteScreen.SPR_THREE_STEPS) {
2811: if (SpriteScreen.sprActive) {
2812:
2813:
2814: SpriteScreen.sprStep1 (crtDataY + 1);
2815: SpriteScreen.sprSwap ();
2816: SpriteScreen.sprStep2 (crtDataY + 1);
2817: }
2818: }
2819: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenFront, crtClock += crtHDispLength);
2820: }
2821: };
2822:
2823: public static final TickerQueue.Ticker DuplicationOmitIdleFront = new TickerQueue.Ticker () {
2824: @Override protected void tick () {
2825: int n = ++crtRasterNumber;
2826: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2827: if (crtR04VFrontEndCurr < n) {
2828: n = crtRasterNumber = 0;
2829: }
2830: if (crtRasterCopyOn) {
2831: crtDoRasterCopy ();
2832: }
2833: if (RasterBreakPoint.RBP_ON) {
2834: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2835: RasterBreakPoint.rbpFire ();
2836: }
2837: }
2838: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2839: if (irq != MC68901.mfpGpipRint) {
2840: if (irq == 0) {
2841: if (RasterBreakPoint.RBP_ON) {
2842: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2843: RasterBreakPoint.rbpFire ();
2844: }
2845: }
2846: MC68901.mfpRintFall ();
2847: } else {
2848: MC68901.mfpRintRise ();
2849: }
2850: }
2851: if (n != crtVDispStart) {
2852: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2853: } else {
2854: MC68901.mfpVdispRise ();
2855: crtR11TxYZero = crtR11TxYCurr;
2856: crtR13GrYZero[0] = crtR13GrYCurr[0];
2857: crtR13GrYZero[1] = crtR13GrYCurr[1];
2858: crtR13GrYZero[2] = crtR13GrYCurr[2];
2859: crtR13GrYZero[3] = crtR13GrYCurr[3];
2860: if (crtR11TxYZeroLast != crtR11TxYZero ||
2861: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2862: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2863: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2864: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2865: crtR11TxYZeroLast = crtR11TxYZero;
2866: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2867: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2868: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2869: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2870: crtAllStamp += 2;
2871: }
2872: crtDataY = 0;
2873: if (crtClearFrames != 0) {
2874: crtClearFrames--;
2875: } else if (crtClearStandby) {
2876: crtClearStandby = false;
2877: crtClearFrames = 1;
2878: }
2879: if (XEiJ.PNL_USE_THREAD) {
2880: crtAllStamp += 2;
2881: }
2882: if (SpriteScreen.SPR_THREE_STEPS) {
2883: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2884: if (SpriteScreen.sprActive) {
2885: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2886: SpriteScreen.sprLatched = false;
2887: }
2888: if (!XEiJ.PNL_USE_THREAD) {
2889: crtAllStamp += 2;
2890: }
2891:
2892: SpriteScreen.sprStep1 (0);
2893: SpriteScreen.sprSwap ();
2894:
2895:
2896: SpriteScreen.sprStep1 (0);
2897: SpriteScreen.sprSwap ();
2898: SpriteScreen.sprStep2 (0);
2899: }
2900: }
2901: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2902: crtStereoscopicStart ();
2903: }
2904: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2905: }
2906: } else {
2907:
2908: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2909: }
2910: }
2911: };
2912:
2913: public static final TickerQueue.Ticker DuplicationOmitIdleSync = new TickerQueue.Ticker () {
2914: @Override protected void tick () {
2915: MC68901.mfpHsyncRise ();
2916: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleBackDisp, crtClock += crtHSyncLength);
2917: }
2918: };
2919:
2920: public static final TickerQueue.Ticker DuplicationOmitIdleBackDisp = new TickerQueue.Ticker () {
2921: @Override protected void tick () {
2922: MC68901.mfpHsyncFall ();
2923: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleFront, crtClock += crtHBackDispLength);
2924: }
2925: };
2926:
2927: public static final TickerQueue.Ticker DuplicationOmitDispEvenFront = new TickerQueue.Ticker () {
2928: @Override protected void tick () {
2929: int n = ++crtRasterNumber;
2930: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2931: if (crtRasterCopyOn) {
2932: crtDoRasterCopy ();
2933: }
2934: if (RasterBreakPoint.RBP_ON) {
2935: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2936: RasterBreakPoint.rbpFire ();
2937: }
2938: }
2939: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2940: if (irq != MC68901.mfpGpipRint) {
2941: if (irq == 0) {
2942: if (RasterBreakPoint.RBP_ON) {
2943: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2944: RasterBreakPoint.rbpFire ();
2945: }
2946: }
2947: MC68901.mfpRintFall ();
2948: } else {
2949: MC68901.mfpRintRise ();
2950: }
2951: }
2952: if (n != crtVIdleStart) {
2953: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2954: } else {
2955: MC68901.mfpVdispFall ();
2956: if (CRT_ENABLE_INTERMITTENT) {
2957: crtIntermittentCounter--;
2958: }
2959: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2960: crtDoFrameTask ();
2961: }
2962: if (XEiJ.PNL_USE_THREAD) {
2963: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2964: }
2965: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2966: }
2967: } else {
2968:
2969: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2970: }
2971: }
2972: };
2973:
2974: public static final TickerQueue.Ticker DuplicationOmitDispOddFront = new TickerQueue.Ticker () {
2975: @Override protected void tick () {
2976: int n = ++crtRasterNumber;
2977: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2978: if (crtRasterCopyOn) {
2979: crtDoRasterCopy ();
2980: }
2981: if (RasterBreakPoint.RBP_ON) {
2982: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2983: RasterBreakPoint.rbpFire ();
2984: }
2985: }
2986: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2987: if (irq != MC68901.mfpGpipRint) {
2988: if (irq == 0) {
2989: if (RasterBreakPoint.RBP_ON) {
2990: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2991: RasterBreakPoint.rbpFire ();
2992: }
2993: }
2994: MC68901.mfpRintFall ();
2995: } else {
2996: MC68901.mfpRintRise ();
2997: }
2998: }
2999: if (n != crtVIdleStart) {
3000: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);
3001: } else {
3002: MC68901.mfpVdispFall ();
3003: if (CRT_ENABLE_INTERMITTENT) {
3004: crtIntermittentCounter--;
3005: }
3006: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3007: crtDoFrameTask ();
3008: }
3009: if (XEiJ.PNL_USE_THREAD) {
3010: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3011: }
3012: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
3013: }
3014: } else {
3015:
3016: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);
3017: }
3018: }
3019: };
3020:
3021: public static final TickerQueue.Ticker DuplicationOmitDispEvenSync = new TickerQueue.Ticker () {
3022: @Override protected void tick () {
3023: MC68901.mfpHsyncRise ();
3024: if (crtClearFrames != 0) {
3025: crtRapidClear (crtDataY);
3026: crtRasterStamp[crtDataY] = 0;
3027: }
3028: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenBackDisp, crtClock += crtHSyncLength);
3029: }
3030: };
3031:
3032: public static final TickerQueue.Ticker DuplicationOmitDispOddSync = new TickerQueue.Ticker () {
3033: @Override protected void tick () {
3034: MC68901.mfpHsyncRise ();
3035: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddBackDisp, crtClock += crtHSyncLength);
3036: }
3037: };
3038:
3039: public static final TickerQueue.Ticker DuplicationOmitDispEvenBackDisp = new TickerQueue.Ticker () {
3040: @Override protected void tick () {
3041: MC68901.mfpHsyncFall ();
3042: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddFront, crtClock += crtHBackDispLength);
3043: }
3044: };
3045:
3046: public static final TickerQueue.Ticker DuplicationOmitDispOddBackDisp = new TickerQueue.Ticker () {
3047: @Override protected void tick () {
3048: MC68901.mfpHsyncFall ();
3049: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenFront, crtClock += crtHBackDispLength);
3050: }
3051: };
3052:
3053:
3054:
3055:
3056: public static final TickerQueue.Ticker InterlaceStart = new TickerQueue.Ticker () {
3057: @Override protected void tick () {
3058: if (MC68901.mfpGpipHsync != 0) {
3059: MC68901.mfpHsyncFall ();
3060: }
3061: int n = crtRasterNumber = crtVIdleStart;
3062: if (crtRasterCopyOn) {
3063: crtDoRasterCopy ();
3064: }
3065: if (RasterBreakPoint.RBP_ON) {
3066: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3067: RasterBreakPoint.rbpFire ();
3068: }
3069: }
3070: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3071: if (irq != MC68901.mfpGpipRint) {
3072: if (irq == 0) {
3073: if (RasterBreakPoint.RBP_ON) {
3074: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3075: RasterBreakPoint.rbpFire ();
3076: }
3077: }
3078: MC68901.mfpRintFall ();
3079: } else {
3080: MC68901.mfpRintRise ();
3081: }
3082: }
3083: if (MC68901.mfpGpipVdisp != 0) {
3084: MC68901.mfpVdispFall ();
3085: }
3086: crtFrameParity = 0;
3087: crtClearFrames = 0;
3088: if (CRT_ENABLE_INTERMITTENT) {
3089: crtIntermittentCounter = 0;
3090: }
3091: if (!XEiJ.PNL_USE_THREAD) {
3092: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3093: crtDoFrameTask ();
3094: }
3095: }
3096: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3097: }
3098: };
3099:
3100: public static final TickerQueue.Ticker InterlaceDrawIdleFront = new TickerQueue.Ticker () {
3101: @Override protected void tick () {
3102: int n = ++crtRasterNumber;
3103: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3104: if (crtR04VFrontEndCurr < n) {
3105: n = crtRasterNumber = 0;
3106: }
3107: if (crtRasterCopyOn) {
3108: crtDoRasterCopy ();
3109: }
3110: if (RasterBreakPoint.RBP_ON) {
3111: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3112: RasterBreakPoint.rbpFire ();
3113: }
3114: }
3115: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3116: if (irq != MC68901.mfpGpipRint) {
3117: if (irq == 0) {
3118: if (RasterBreakPoint.RBP_ON) {
3119: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3120: RasterBreakPoint.rbpFire ();
3121: }
3122: }
3123: MC68901.mfpRintFall ();
3124: } else {
3125: MC68901.mfpRintRise ();
3126: }
3127: }
3128: if (n != crtVDispStart) {
3129: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3130: } else {
3131: MC68901.mfpVdispRise ();
3132: crtR11TxYZero = crtR11TxYCurr;
3133: crtR13GrYZero[0] = crtR13GrYCurr[0];
3134: crtR13GrYZero[1] = crtR13GrYCurr[1];
3135: crtR13GrYZero[2] = crtR13GrYCurr[2];
3136: crtR13GrYZero[3] = crtR13GrYCurr[3];
3137: if (crtR11TxYZeroLast != crtR11TxYZero ||
3138: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3139: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3140: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3141: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3142: crtR11TxYZeroLast = crtR11TxYZero;
3143: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3144: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3145: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3146: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3147: crtAllStamp += 2;
3148: }
3149: crtDataY = crtFrameParity;
3150: if (crtClearFrames != 0) {
3151: crtClearFrames--;
3152: } else if (crtClearStandby &&
3153: crtFrameParity == 0) {
3154: crtClearStandby = false;
3155: crtClearFrames = 2;
3156: }
3157: crtScreenY = crtFrameParity;
3158: if (!XEiJ.PNL_USE_THREAD) {
3159: crtDirtyY0 = -1;
3160: }
3161: if (XEiJ.PNL_USE_THREAD) {
3162: crtAllStamp += 2;
3163: }
3164: if (SpriteScreen.SPR_THREE_STEPS) {
3165: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3166: if (SpriteScreen.sprActive) {
3167: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3168: SpriteScreen.sprLatched = false;
3169: }
3170: if (!XEiJ.PNL_USE_THREAD) {
3171: crtAllStamp += 2;
3172: }
3173:
3174: SpriteScreen.sprStep1 (0);
3175: SpriteScreen.sprSwap ();
3176:
3177:
3178: SpriteScreen.sprStep1 (2);
3179: SpriteScreen.sprSwap ();
3180: SpriteScreen.sprStep2 (0);
3181: }
3182: }
3183: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3184: crtStereoscopicStart ();
3185: }
3186: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3187: }
3188: } else {
3189:
3190: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3191: }
3192: }
3193: };
3194:
3195: public static final TickerQueue.Ticker InterlaceDrawIdleSync = new TickerQueue.Ticker () {
3196: @Override protected void tick () {
3197: MC68901.mfpHsyncRise ();
3198: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleBackDisp, crtClock += crtHSyncLength);
3199: }
3200: };
3201:
3202: public static final TickerQueue.Ticker InterlaceDrawIdleBackDisp = new TickerQueue.Ticker () {
3203: @Override protected void tick () {
3204: MC68901.mfpHsyncFall ();
3205: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleFront, crtClock += crtHBackDispLength);
3206: }
3207: };
3208:
3209: public static final TickerQueue.Ticker InterlaceDrawDispFront = new TickerQueue.Ticker () {
3210: @Override protected void tick () {
3211: int n = ++crtRasterNumber;
3212: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3213: if (crtRasterCopyOn) {
3214: crtDoRasterCopy ();
3215: }
3216: if (RasterBreakPoint.RBP_ON) {
3217: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3218: RasterBreakPoint.rbpFire ();
3219: }
3220: }
3221: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3222: if (irq != MC68901.mfpGpipRint) {
3223: if (irq == 0) {
3224: if (RasterBreakPoint.RBP_ON) {
3225: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3226: RasterBreakPoint.rbpFire ();
3227: }
3228: }
3229: MC68901.mfpRintFall ();
3230: } else {
3231: MC68901.mfpRintRise ();
3232: }
3233: }
3234: if (n != crtVIdleStart) {
3235: if (crtBeginningAllStamp != crtAllStamp) {
3236: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3237: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3238: crtStereoscopicDrawRaster (crtScreenY);
3239: if (XEiJ.PNL_USE_THREAD) {
3240: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3241: }
3242: }
3243: }
3244: crtScreenY += 2;
3245: crtDataY += 2;
3246: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3247: } else {
3248: if (crtBeginningAllStamp != crtAllStamp) {
3249: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3250: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3251: crtStereoscopicDrawRaster (crtScreenY);
3252: if (XEiJ.PNL_USE_THREAD) {
3253: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3254: }
3255: }
3256: }
3257: MC68901.mfpVdispFall ();
3258: if (!XEiJ.PNL_USE_THREAD) {
3259: if (crtDirtyY0 >= 0) {
3260: crtUpdateScreen ();
3261: if (CRT_ENABLE_INTERMITTENT) {
3262: crtIntermittentCounter = crtIntermittentInterval;
3263: }
3264: }
3265: }
3266: crtFrameParity ^= 1;
3267: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3268: crtDoFrameTask ();
3269: }
3270: if (XEiJ.PNL_USE_THREAD) {
3271: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3272: }
3273: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3274: }
3275: } else {
3276:
3277: if (crtBeginningAllStamp != crtAllStamp) {
3278: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3279: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3280: crtStereoscopicDrawRaster (crtScreenY);
3281: if (XEiJ.PNL_USE_THREAD) {
3282: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3283: }
3284: }
3285: }
3286: crtScreenY += 2;
3287: crtDataY += 2;
3288: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3289: }
3290: }
3291: };
3292:
3293: public static final TickerQueue.Ticker InterlaceDrawDispSync = new TickerQueue.Ticker () {
3294: @Override protected void tick () {
3295: MC68901.mfpHsyncRise ();
3296: if (crtClearFrames != 0) {
3297: crtRapidClear (crtDataY);
3298: crtRasterStamp[crtDataY] = 0;
3299: }
3300: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispBack, crtClock += crtHSyncLength);
3301: }
3302: };
3303:
3304: public static final TickerQueue.Ticker InterlaceDrawDispBack = new TickerQueue.Ticker () {
3305: @Override protected void tick () {
3306: MC68901.mfpHsyncFall ();
3307: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispDisp, crtClock += crtHBackLength);
3308: }
3309: };
3310:
3311: public static final TickerQueue.Ticker InterlaceDrawDispDisp = new TickerQueue.Ticker () {
3312: @Override protected void tick () {
3313: if (crtRasterStamp[crtDataY] != crtAllStamp) {
3314: crtRasterStamp[crtDataY] = crtAllStamp;
3315: crtBeginningAllStamp = crtAllStamp;
3316: if (Malfunction.MLF_ON) {
3317: Malfunction.mlfRaster (crtDataY);
3318: }
3319: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
3320: if (XEiJ.PNL_USE_THREAD) {
3321: int[] prevBM = XEiJ.pnlBMLeftArray[(XEiJ.pnlBMWrite - 1) & 3];
3322: int da = (crtScreenY ^ 1) << XEiJ.PNL_BM_OFFSET_BITS;
3323: System.arraycopy (prevBM, da,
3324: XEiJ.pnlBM, da,
3325: XEiJ.pnlScreenWidth);
3326: }
3327: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3328: crtStereoscopicDrawRaster (crtScreenY);
3329: if (XEiJ.PNL_USE_THREAD) {
3330: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3331: }
3332: }
3333: if (!XEiJ.PNL_USE_THREAD) {
3334: if (crtDirtyY0 < 0) {
3335: crtDirtyY0 = crtScreenY;
3336: }
3337: crtDirtyY1 = crtScreenY;
3338: }
3339: }
3340: if (SpriteScreen.SPR_THREE_STEPS) {
3341: if (SpriteScreen.sprActive) {
3342:
3343:
3344: SpriteScreen.sprStep1 (crtDataY + 4);
3345: SpriteScreen.sprSwap ();
3346: SpriteScreen.sprStep2 (crtDataY + 2);
3347: }
3348: }
3349: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispFront, crtClock += crtHDispLength);
3350: }
3351: };
3352:
3353: public static final TickerQueue.Ticker InterlaceOmitIdleFront = new TickerQueue.Ticker () {
3354: @Override protected void tick () {
3355: int n = ++crtRasterNumber;
3356: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3357: if (crtR04VFrontEndCurr < n) {
3358: n = crtRasterNumber = 0;
3359: }
3360: if (crtRasterCopyOn) {
3361: crtDoRasterCopy ();
3362: }
3363: if (RasterBreakPoint.RBP_ON) {
3364: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3365: RasterBreakPoint.rbpFire ();
3366: }
3367: }
3368: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3369: if (irq != MC68901.mfpGpipRint) {
3370: if (irq == 0) {
3371: if (RasterBreakPoint.RBP_ON) {
3372: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3373: RasterBreakPoint.rbpFire ();
3374: }
3375: }
3376: MC68901.mfpRintFall ();
3377: } else {
3378: MC68901.mfpRintRise ();
3379: }
3380: }
3381: if (n != crtVDispStart) {
3382: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3383: } else {
3384: MC68901.mfpVdispRise ();
3385: crtR11TxYZero = crtR11TxYCurr;
3386: crtR13GrYZero[0] = crtR13GrYCurr[0];
3387: crtR13GrYZero[1] = crtR13GrYCurr[1];
3388: crtR13GrYZero[2] = crtR13GrYCurr[2];
3389: crtR13GrYZero[3] = crtR13GrYCurr[3];
3390: if (crtR11TxYZeroLast != crtR11TxYZero ||
3391: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3392: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3393: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3394: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3395: crtR11TxYZeroLast = crtR11TxYZero;
3396: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3397: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3398: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3399: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3400: crtAllStamp += 2;
3401: }
3402: crtDataY = crtFrameParity;
3403: if (crtClearFrames != 0) {
3404: crtClearFrames--;
3405: } else if (crtClearStandby &&
3406: crtFrameParity == 0) {
3407: crtClearStandby = false;
3408: crtClearFrames = 2;
3409: }
3410: if (XEiJ.PNL_USE_THREAD) {
3411: crtAllStamp += 2;
3412: }
3413: if (SpriteScreen.SPR_THREE_STEPS) {
3414: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3415: if (SpriteScreen.sprActive) {
3416: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3417: SpriteScreen.sprLatched = false;
3418: }
3419: if (!XEiJ.PNL_USE_THREAD) {
3420: crtAllStamp += 2;
3421: }
3422:
3423: SpriteScreen.sprStep1 (0);
3424: SpriteScreen.sprSwap ();
3425:
3426:
3427: SpriteScreen.sprStep1 (2);
3428: SpriteScreen.sprSwap ();
3429: SpriteScreen.sprStep2 (0);
3430: }
3431: }
3432: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3433: crtStereoscopicStart ();
3434: }
3435: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3436: }
3437: } else {
3438:
3439: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3440: }
3441: }
3442: };
3443:
3444: public static final TickerQueue.Ticker InterlaceOmitIdleSync = new TickerQueue.Ticker () {
3445: @Override protected void tick () {
3446: MC68901.mfpHsyncRise ();
3447: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleBackDisp, crtClock += crtHSyncLength);
3448: }
3449: };
3450:
3451: public static final TickerQueue.Ticker InterlaceOmitIdleBackDisp = new TickerQueue.Ticker () {
3452: @Override protected void tick () {
3453: MC68901.mfpHsyncFall ();
3454: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleFront, crtClock += crtHBackDispLength);
3455: }
3456: };
3457:
3458: public static final TickerQueue.Ticker InterlaceOmitDispFront = new TickerQueue.Ticker () {
3459: @Override protected void tick () {
3460: int n = ++crtRasterNumber;
3461: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3462: if (crtRasterCopyOn) {
3463: crtDoRasterCopy ();
3464: }
3465: if (RasterBreakPoint.RBP_ON) {
3466: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3467: RasterBreakPoint.rbpFire ();
3468: }
3469: }
3470: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3471: if (irq != MC68901.mfpGpipRint) {
3472: if (irq == 0) {
3473: if (RasterBreakPoint.RBP_ON) {
3474: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3475: RasterBreakPoint.rbpFire ();
3476: }
3477: }
3478: MC68901.mfpRintFall ();
3479: } else {
3480: MC68901.mfpRintRise ();
3481: }
3482: }
3483: if (n != crtVIdleStart) {
3484: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3485: } else {
3486: MC68901.mfpVdispFall ();
3487: if (CRT_ENABLE_INTERMITTENT) {
3488: crtIntermittentCounter--;
3489: }
3490: crtFrameParity ^= 1;
3491: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3492: crtDoFrameTask ();
3493: }
3494: if (XEiJ.PNL_USE_THREAD) {
3495: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3496: }
3497: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3498: }
3499: } else {
3500:
3501: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3502: }
3503: }
3504: };
3505:
3506: public static final TickerQueue.Ticker InterlaceOmitDispSync = new TickerQueue.Ticker () {
3507: @Override protected void tick () {
3508: MC68901.mfpHsyncRise ();
3509: if (crtClearFrames != 0) {
3510: crtRapidClear (crtDataY);
3511: crtRasterStamp[crtDataY] = 0;
3512: }
3513: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispBackDisp, crtClock += crtHSyncLength);
3514: }
3515: };
3516:
3517: public static final TickerQueue.Ticker InterlaceOmitDispBackDisp = new TickerQueue.Ticker () {
3518: @Override protected void tick () {
3519: MC68901.mfpHsyncFall ();
3520: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispFront, crtClock += crtHBackDispLength);
3521: }
3522: };
3523:
3524:
3525:
3526:
3527: public static final TickerQueue.Ticker SlitStart = new TickerQueue.Ticker () {
3528: @Override protected void tick () {
3529: if (MC68901.mfpGpipHsync != 0) {
3530: MC68901.mfpHsyncFall ();
3531: }
3532: int n = crtRasterNumber = crtVIdleStart;
3533: if (crtRasterCopyOn) {
3534: crtDoRasterCopy ();
3535: }
3536: if (RasterBreakPoint.RBP_ON) {
3537: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3538: RasterBreakPoint.rbpFire ();
3539: }
3540: }
3541: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3542: if (irq != MC68901.mfpGpipRint) {
3543: if (irq == 0) {
3544: if (RasterBreakPoint.RBP_ON) {
3545: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3546: RasterBreakPoint.rbpFire ();
3547: }
3548: }
3549: MC68901.mfpRintFall ();
3550: } else {
3551: MC68901.mfpRintRise ();
3552: }
3553: }
3554: if (MC68901.mfpGpipVdisp != 0) {
3555: MC68901.mfpVdispFall ();
3556: }
3557: crtClearFrames = 0;
3558: if (CRT_ENABLE_INTERMITTENT) {
3559: crtIntermittentCounter = 0;
3560: }
3561: if (!XEiJ.PNL_USE_THREAD) {
3562: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3563: crtDoFrameTask ();
3564: }
3565: }
3566: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3567: }
3568: };
3569:
3570: public static final TickerQueue.Ticker SlitDrawIdleFront = new TickerQueue.Ticker () {
3571: @Override protected void tick () {
3572: int n = ++crtRasterNumber;
3573: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3574: if (crtR04VFrontEndCurr < n) {
3575: n = crtRasterNumber = 0;
3576: }
3577: if (crtRasterCopyOn) {
3578: crtDoRasterCopy ();
3579: }
3580: if (RasterBreakPoint.RBP_ON) {
3581: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3582: RasterBreakPoint.rbpFire ();
3583: }
3584: }
3585: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3586: if (irq != MC68901.mfpGpipRint) {
3587: if (irq == 0) {
3588: if (RasterBreakPoint.RBP_ON) {
3589: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3590: RasterBreakPoint.rbpFire ();
3591: }
3592: }
3593: MC68901.mfpRintFall ();
3594: } else {
3595: MC68901.mfpRintRise ();
3596: }
3597: }
3598: if (n != crtVDispStart) {
3599: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3600: } else {
3601: MC68901.mfpVdispRise ();
3602: crtR11TxYZero = crtR11TxYCurr;
3603: crtR13GrYZero[0] = crtR13GrYCurr[0];
3604: crtR13GrYZero[1] = crtR13GrYCurr[1];
3605: crtR13GrYZero[2] = crtR13GrYCurr[2];
3606: crtR13GrYZero[3] = crtR13GrYCurr[3];
3607: if (crtR11TxYZeroLast != crtR11TxYZero ||
3608: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3609: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3610: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3611: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3612: crtR11TxYZeroLast = crtR11TxYZero;
3613: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3614: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3615: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3616: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3617: crtAllStamp += 2;
3618: }
3619: crtDataY = 0;
3620: if (crtClearFrames != 0) {
3621: crtClearFrames--;
3622: } else if (crtClearStandby) {
3623: crtClearStandby = false;
3624: crtClearFrames = 1;
3625: }
3626: crtScreenY = 0;
3627: if (!XEiJ.PNL_USE_THREAD) {
3628: crtDirtyY0 = -1;
3629: }
3630: if (XEiJ.PNL_USE_THREAD) {
3631: crtAllStamp += 2;
3632: }
3633: if (SpriteScreen.SPR_THREE_STEPS) {
3634: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3635: if (SpriteScreen.sprActive) {
3636: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3637: SpriteScreen.sprLatched = false;
3638: }
3639: if (!XEiJ.PNL_USE_THREAD) {
3640: crtAllStamp += 2;
3641: }
3642:
3643: SpriteScreen.sprStep1 (0);
3644: SpriteScreen.sprSwap ();
3645:
3646:
3647: SpriteScreen.sprStep1 (1);
3648: SpriteScreen.sprSwap ();
3649: SpriteScreen.sprStep2 (0);
3650: }
3651: }
3652: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3653: crtStereoscopicStart ();
3654: }
3655: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3656: }
3657: } else {
3658:
3659: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3660: }
3661: }
3662: };
3663:
3664: public static final TickerQueue.Ticker SlitDrawIdleSync = new TickerQueue.Ticker () {
3665: @Override protected void tick () {
3666: MC68901.mfpHsyncRise ();
3667: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleBackDisp, crtClock += crtHSyncLength);
3668: }
3669: };
3670:
3671: public static final TickerQueue.Ticker SlitDrawIdleBackDisp = new TickerQueue.Ticker () {
3672: @Override protected void tick () {
3673: MC68901.mfpHsyncFall ();
3674: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleFront, crtClock += crtHBackDispLength);
3675: }
3676: };
3677:
3678: public static final TickerQueue.Ticker SlitDrawDispFront = new TickerQueue.Ticker () {
3679: @Override protected void tick () {
3680: int n = ++crtRasterNumber;
3681: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3682: if (crtRasterCopyOn) {
3683: crtDoRasterCopy ();
3684: }
3685: if (RasterBreakPoint.RBP_ON) {
3686: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3687: RasterBreakPoint.rbpFire ();
3688: }
3689: }
3690: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3691: if (irq != MC68901.mfpGpipRint) {
3692: if (irq == 0) {
3693: if (RasterBreakPoint.RBP_ON) {
3694: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3695: RasterBreakPoint.rbpFire ();
3696: }
3697: }
3698: MC68901.mfpRintFall ();
3699: } else {
3700: MC68901.mfpRintRise ();
3701: }
3702: }
3703: if (n != crtVIdleStart) {
3704: if (crtBeginningAllStamp != crtAllStamp) {
3705: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3706: crtScanlineEffect.drawRaster (crtScreenY + 1);
3707: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3708: crtStereoscopicDrawRaster (crtScreenY);
3709: crtStereoscopicDrawRaster (crtScreenY + 1);
3710: }
3711: }
3712: crtScreenY += 2;
3713: crtDataY++;
3714: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3715: } else {
3716: if (crtBeginningAllStamp != crtAllStamp) {
3717: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3718: crtScanlineEffect.drawRaster (crtScreenY + 1);
3719: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3720: crtStereoscopicDrawRaster (crtScreenY);
3721: crtStereoscopicDrawRaster (crtScreenY + 1);
3722: }
3723: }
3724: MC68901.mfpVdispFall ();
3725: if (!XEiJ.PNL_USE_THREAD) {
3726: if (crtDirtyY0 >= 0) {
3727: crtUpdateScreen ();
3728: if (CRT_ENABLE_INTERMITTENT) {
3729: crtIntermittentCounter = crtIntermittentInterval;
3730: }
3731: }
3732: }
3733: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3734: crtDoFrameTask ();
3735: }
3736: if (XEiJ.PNL_USE_THREAD) {
3737: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3738: }
3739: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3740: }
3741: } else {
3742:
3743: if (crtBeginningAllStamp != crtAllStamp) {
3744: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3745: crtScanlineEffect.drawRaster (crtScreenY + 1);
3746: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3747: crtStereoscopicDrawRaster (crtScreenY);
3748: crtStereoscopicDrawRaster (crtScreenY + 1);
3749: }
3750: }
3751: crtScreenY += 2;
3752: crtDataY++;
3753: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3754: }
3755: }
3756: };
3757:
3758: public static final TickerQueue.Ticker SlitDrawDispSync = new TickerQueue.Ticker () {
3759: @Override protected void tick () {
3760: MC68901.mfpHsyncRise ();
3761: if (crtClearFrames != 0) {
3762: crtRapidClear (crtDataY);
3763: crtRasterStamp[crtDataY] = 0;
3764: }
3765: TickerQueue.tkqAdd (crtTicker = SlitDrawDispBack, crtClock += crtHSyncLength);
3766: }
3767: };
3768:
3769: public static final TickerQueue.Ticker SlitDrawDispBack = new TickerQueue.Ticker () {
3770: @Override protected void tick () {
3771: MC68901.mfpHsyncFall ();
3772: TickerQueue.tkqAdd (crtTicker = SlitDrawDispDisp, crtClock += crtHBackLength);
3773: }
3774: };
3775:
3776: public static final TickerQueue.Ticker SlitDrawDispDisp = new TickerQueue.Ticker () {
3777: @Override protected void tick () {
3778: if (crtRasterStamp[crtDataY] != crtAllStamp) {
3779: crtRasterStamp[crtDataY] = crtAllStamp;
3780: crtBeginningAllStamp = crtAllStamp;
3781: if (Malfunction.MLF_ON) {
3782: Malfunction.mlfRaster (crtDataY);
3783: }
3784: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
3785: crtScanlineEffect.drawRaster (crtScreenY + 1);
3786: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3787: crtStereoscopicDrawRaster (crtScreenY);
3788: crtStereoscopicDrawRaster (crtScreenY + 1);
3789: }
3790: if (!XEiJ.PNL_USE_THREAD) {
3791: if (crtDirtyY0 < 0) {
3792: crtDirtyY0 = crtScreenY;
3793: }
3794: crtDirtyY1 = crtScreenY + 1;
3795: }
3796: }
3797: if (SpriteScreen.SPR_THREE_STEPS) {
3798: if (SpriteScreen.sprActive) {
3799:
3800:
3801: SpriteScreen.sprStep1 (crtDataY + 2);
3802: SpriteScreen.sprSwap ();
3803: SpriteScreen.sprStep2 (crtDataY + 1);
3804: }
3805: }
3806: TickerQueue.tkqAdd (crtTicker = SlitDrawDispFront, crtClock += crtHDispLength);
3807: }
3808: };
3809:
3810: public static final TickerQueue.Ticker SlitOmitIdleFront = new TickerQueue.Ticker () {
3811: @Override protected void tick () {
3812: int n = ++crtRasterNumber;
3813: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3814: if (crtR04VFrontEndCurr < n) {
3815: n = crtRasterNumber = 0;
3816: }
3817: if (crtRasterCopyOn) {
3818: crtDoRasterCopy ();
3819: }
3820: if (RasterBreakPoint.RBP_ON) {
3821: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3822: RasterBreakPoint.rbpFire ();
3823: }
3824: }
3825: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3826: if (irq != MC68901.mfpGpipRint) {
3827: if (irq == 0) {
3828: if (RasterBreakPoint.RBP_ON) {
3829: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3830: RasterBreakPoint.rbpFire ();
3831: }
3832: }
3833: MC68901.mfpRintFall ();
3834: } else {
3835: MC68901.mfpRintRise ();
3836: }
3837: }
3838: if (n != crtVDispStart) {
3839: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3840: } else {
3841: MC68901.mfpVdispRise ();
3842: crtR11TxYZero = crtR11TxYCurr;
3843: crtR13GrYZero[0] = crtR13GrYCurr[0];
3844: crtR13GrYZero[1] = crtR13GrYCurr[1];
3845: crtR13GrYZero[2] = crtR13GrYCurr[2];
3846: crtR13GrYZero[3] = crtR13GrYCurr[3];
3847: if (crtR11TxYZeroLast != crtR11TxYZero ||
3848: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3849: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3850: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3851: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3852: crtR11TxYZeroLast = crtR11TxYZero;
3853: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3854: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3855: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3856: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3857: crtAllStamp += 2;
3858: }
3859: crtDataY = 0;
3860: if (crtClearFrames != 0) {
3861: crtClearFrames--;
3862: } else if (crtClearStandby) {
3863: crtClearStandby = false;
3864: crtClearFrames = 1;
3865: }
3866: if (XEiJ.PNL_USE_THREAD) {
3867: crtAllStamp += 2;
3868: }
3869: if (SpriteScreen.SPR_THREE_STEPS) {
3870: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3871: if (SpriteScreen.sprActive) {
3872: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3873: SpriteScreen.sprLatched = false;
3874: }
3875: if (!XEiJ.PNL_USE_THREAD) {
3876: crtAllStamp += 2;
3877: }
3878:
3879: SpriteScreen.sprStep1 (0);
3880: SpriteScreen.sprSwap ();
3881:
3882:
3883: SpriteScreen.sprStep1 (1);
3884: SpriteScreen.sprSwap ();
3885: SpriteScreen.sprStep2 (0);
3886: }
3887: }
3888: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3889: crtStereoscopicStart ();
3890: }
3891: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3892: }
3893: } else {
3894:
3895: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3896: }
3897: }
3898: };
3899:
3900: public static final TickerQueue.Ticker SlitOmitIdleSync = new TickerQueue.Ticker () {
3901: @Override protected void tick () {
3902: MC68901.mfpHsyncRise ();
3903: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleBackDisp, crtClock += crtHSyncLength);
3904: }
3905: };
3906:
3907: public static final TickerQueue.Ticker SlitOmitIdleBackDisp = new TickerQueue.Ticker () {
3908: @Override protected void tick () {
3909: MC68901.mfpHsyncFall ();
3910: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleFront, crtClock += crtHBackDispLength);
3911: }
3912: };
3913:
3914: public static final TickerQueue.Ticker SlitOmitDispFront = new TickerQueue.Ticker () {
3915: @Override protected void tick () {
3916: int n = ++crtRasterNumber;
3917: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3918: if (crtRasterCopyOn) {
3919: crtDoRasterCopy ();
3920: }
3921: if (RasterBreakPoint.RBP_ON) {
3922: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3923: RasterBreakPoint.rbpFire ();
3924: }
3925: }
3926: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3927: if (irq != MC68901.mfpGpipRint) {
3928: if (irq == 0) {
3929: if (RasterBreakPoint.RBP_ON) {
3930: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3931: RasterBreakPoint.rbpFire ();
3932: }
3933: }
3934: MC68901.mfpRintFall ();
3935: } else {
3936: MC68901.mfpRintRise ();
3937: }
3938: }
3939: if (n != crtVIdleStart) {
3940: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3941: } else {
3942: MC68901.mfpVdispFall ();
3943: if (CRT_ENABLE_INTERMITTENT) {
3944: crtIntermittentCounter--;
3945: }
3946: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3947: crtDoFrameTask ();
3948: }
3949: if (XEiJ.PNL_USE_THREAD) {
3950: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3951: }
3952: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3953: }
3954: } else {
3955:
3956: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3957: }
3958: }
3959: };
3960:
3961: public static final TickerQueue.Ticker SlitOmitDispSync = new TickerQueue.Ticker () {
3962: @Override protected void tick () {
3963: MC68901.mfpHsyncRise ();
3964: if (crtClearFrames != 0) {
3965: crtRapidClear (crtDataY);
3966: crtRasterStamp[crtDataY] = 0;
3967: }
3968: TickerQueue.tkqAdd (crtTicker = SlitOmitDispBackDisp, crtClock += crtHSyncLength);
3969: }
3970: };
3971:
3972: public static final TickerQueue.Ticker SlitOmitDispBackDisp = new TickerQueue.Ticker () {
3973: @Override protected void tick () {
3974: MC68901.mfpHsyncFall ();
3975: TickerQueue.tkqAdd (crtTicker = SlitOmitDispFront, crtClock += crtHBackDispLength);
3976: }
3977: };
3978:
3979:
3980:
3981:
3982: public static final TickerQueue.Ticker DupExceptSpStart = new TickerQueue.Ticker () {
3983: @Override protected void tick () {
3984: if (MC68901.mfpGpipHsync != 0) {
3985: MC68901.mfpHsyncFall ();
3986: }
3987: int n = crtRasterNumber = crtVIdleStart;
3988: if (crtRasterCopyOn) {
3989: crtDoRasterCopy ();
3990: }
3991: if (RasterBreakPoint.RBP_ON) {
3992: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3993: RasterBreakPoint.rbpFire ();
3994: }
3995: }
3996: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3997: if (irq != MC68901.mfpGpipRint) {
3998: if (irq == 0) {
3999: if (RasterBreakPoint.RBP_ON) {
4000: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4001: RasterBreakPoint.rbpFire ();
4002: }
4003: }
4004: MC68901.mfpRintFall ();
4005: } else {
4006: MC68901.mfpRintRise ();
4007: }
4008: }
4009: if (MC68901.mfpGpipVdisp != 0) {
4010: MC68901.mfpVdispFall ();
4011: }
4012: crtClearFrames = 0;
4013: if (CRT_ENABLE_INTERMITTENT) {
4014: crtIntermittentCounter = 0;
4015: }
4016: if (!XEiJ.PNL_USE_THREAD) {
4017: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4018: crtDoFrameTask ();
4019: }
4020: }
4021: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4022: }
4023: };
4024:
4025: public static final TickerQueue.Ticker DupExceptSpDrawIdleFront = new TickerQueue.Ticker () {
4026: @Override protected void tick () {
4027: int n = ++crtRasterNumber;
4028: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
4029: if (crtR04VFrontEndCurr < n) {
4030: n = crtRasterNumber = 0;
4031: }
4032: if (crtRasterCopyOn) {
4033: crtDoRasterCopy ();
4034: }
4035: if (RasterBreakPoint.RBP_ON) {
4036: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4037: RasterBreakPoint.rbpFire ();
4038: }
4039: }
4040: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4041: if (irq != MC68901.mfpGpipRint) {
4042: if (irq == 0) {
4043: if (RasterBreakPoint.RBP_ON) {
4044: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4045: RasterBreakPoint.rbpFire ();
4046: }
4047: }
4048: MC68901.mfpRintFall ();
4049: } else {
4050: MC68901.mfpRintRise ();
4051: }
4052: }
4053: if (n != crtVDispStart) {
4054: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4055: } else {
4056: MC68901.mfpVdispRise ();
4057: crtR11TxYZero = crtR11TxYCurr;
4058: crtR13GrYZero[0] = crtR13GrYCurr[0];
4059: crtR13GrYZero[1] = crtR13GrYCurr[1];
4060: crtR13GrYZero[2] = crtR13GrYCurr[2];
4061: crtR13GrYZero[3] = crtR13GrYCurr[3];
4062: if (crtR11TxYZeroLast != crtR11TxYZero ||
4063: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
4064: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
4065: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
4066: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
4067: crtR11TxYZeroLast = crtR11TxYZero;
4068: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
4069: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
4070: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
4071: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
4072: crtAllStamp += 2;
4073: }
4074: crtDataY = 0;
4075: if (crtClearFrames != 0) {
4076: crtClearFrames--;
4077: } else if (crtClearStandby) {
4078: crtClearStandby = false;
4079: crtClearFrames = 1;
4080: }
4081: crtScreenY = 0;
4082: if (!XEiJ.PNL_USE_THREAD) {
4083: crtDirtyY0 = -1;
4084: }
4085: if (XEiJ.PNL_USE_THREAD) {
4086: crtAllStamp += 2;
4087: }
4088: if (SpriteScreen.SPR_THREE_STEPS) {
4089: SpriteScreen.sprActive = SpriteScreen.sprLatched;
4090: if (SpriteScreen.sprActive) {
4091: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
4092: SpriteScreen.sprLatched = false;
4093: }
4094: if (!XEiJ.PNL_USE_THREAD) {
4095: crtAllStamp += 2;
4096: }
4097:
4098: SpriteScreen.sprStep1 (0);
4099: SpriteScreen.sprSwap ();
4100:
4101:
4102: SpriteScreen.sprStep1 (1);
4103: SpriteScreen.sprSwap ();
4104: SpriteScreen.sprStep2 (0);
4105: }
4106: }
4107: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4108: crtStereoscopicStart ();
4109: }
4110: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);
4111: }
4112: } else {
4113:
4114: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4115: }
4116: }
4117: };
4118:
4119: public static final TickerQueue.Ticker DupExceptSpDrawIdleSync = new TickerQueue.Ticker () {
4120: @Override protected void tick () {
4121: MC68901.mfpHsyncRise ();
4122: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleBackDisp, crtClock += crtHSyncLength);
4123: }
4124: };
4125:
4126: public static final TickerQueue.Ticker DupExceptSpDrawIdleBackDisp = new TickerQueue.Ticker () {
4127: @Override protected void tick () {
4128: MC68901.mfpHsyncFall ();
4129: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleFront, crtClock += crtHBackDispLength);
4130: }
4131: };
4132:
4133: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenFront = new TickerQueue.Ticker () {
4134: @Override protected void tick () {
4135: int n = ++crtRasterNumber;
4136: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4137: if (crtRasterCopyOn) {
4138: crtDoRasterCopy ();
4139: }
4140: if (RasterBreakPoint.RBP_ON) {
4141: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4142: RasterBreakPoint.rbpFire ();
4143: }
4144: }
4145: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4146: if (irq != MC68901.mfpGpipRint) {
4147: if (irq == 0) {
4148: if (RasterBreakPoint.RBP_ON) {
4149: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4150: RasterBreakPoint.rbpFire ();
4151: }
4152: }
4153: MC68901.mfpRintFall ();
4154: } else {
4155: MC68901.mfpRintRise ();
4156: }
4157: }
4158: if (n != crtVIdleStart) {
4159: if (crtBeginningAllStamp != crtAllStamp) {
4160: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4161: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4162: crtStereoscopicDrawRaster (crtScreenY);
4163: }
4164: }
4165: crtScreenY++;
4166: crtDataY++;
4167: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);
4168: } else {
4169: if (crtBeginningAllStamp != crtAllStamp) {
4170: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4171: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4172: crtStereoscopicDrawRaster (crtScreenY);
4173: }
4174: }
4175: MC68901.mfpVdispFall ();
4176: if (!XEiJ.PNL_USE_THREAD) {
4177: if (crtDirtyY0 >= 0) {
4178: crtUpdateScreen ();
4179: if (CRT_ENABLE_INTERMITTENT) {
4180: crtIntermittentCounter = crtIntermittentInterval;
4181: }
4182: }
4183: }
4184: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4185: crtDoFrameTask ();
4186: }
4187: if (XEiJ.PNL_USE_THREAD) {
4188: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4189: }
4190: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4191: }
4192: } else {
4193:
4194: if (crtBeginningAllStamp != crtAllStamp) {
4195: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4196: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4197: crtStereoscopicDrawRaster (crtScreenY);
4198: }
4199: }
4200: crtScreenY++;
4201: crtDataY++;
4202: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);
4203: }
4204: }
4205: };
4206:
4207: public static final TickerQueue.Ticker DupExceptSpDrawDispOddFront = new TickerQueue.Ticker () {
4208: @Override protected void tick () {
4209: int n = ++crtRasterNumber;
4210: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4211: if (crtRasterCopyOn) {
4212: crtDoRasterCopy ();
4213: }
4214: if (RasterBreakPoint.RBP_ON) {
4215: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4216: RasterBreakPoint.rbpFire ();
4217: }
4218: }
4219: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4220: if (irq != MC68901.mfpGpipRint) {
4221: if (irq == 0) {
4222: if (RasterBreakPoint.RBP_ON) {
4223: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4224: RasterBreakPoint.rbpFire ();
4225: }
4226: }
4227: MC68901.mfpRintFall ();
4228: } else {
4229: MC68901.mfpRintRise ();
4230: }
4231: }
4232: if (n != crtVIdleStart) {
4233: if (crtBeginningAllStamp != crtAllStamp) {
4234: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4235: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4236: crtStereoscopicDrawRaster (crtScreenY);
4237: }
4238: }
4239: crtScreenY++;
4240: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddSync, crtClock += crtHFrontLength);
4241: } else {
4242: if (crtBeginningAllStamp != crtAllStamp) {
4243: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4244: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4245: crtStereoscopicDrawRaster (crtScreenY);
4246: }
4247: }
4248: MC68901.mfpVdispFall ();
4249: if (!XEiJ.PNL_USE_THREAD) {
4250: if (crtDirtyY0 >= 0) {
4251: crtUpdateScreen ();
4252: if (CRT_ENABLE_INTERMITTENT) {
4253: crtIntermittentCounter = crtIntermittentInterval;
4254: }
4255: }
4256: }
4257: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4258: crtDoFrameTask ();
4259: }
4260: if (XEiJ.PNL_USE_THREAD) {
4261: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4262: }
4263: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4264: }
4265: } else {
4266:
4267: if (crtBeginningAllStamp != crtAllStamp) {
4268: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4269: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4270: crtStereoscopicDrawRaster (crtScreenY);
4271: }
4272: }
4273: crtScreenY++;
4274: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddSync, crtClock += crtHFrontLength);
4275: }
4276: }
4277: };
4278:
4279: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenSync = new TickerQueue.Ticker () {
4280: @Override protected void tick () {
4281: MC68901.mfpHsyncRise ();
4282: if (crtClearFrames != 0) {
4283: crtRapidClear (crtDataY);
4284: crtRasterStamp[crtDataY] = 0;
4285: }
4286: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenBack, crtClock += crtHSyncLength);
4287: }
4288: };
4289:
4290: public static final TickerQueue.Ticker DupExceptSpDrawDispOddSync = new TickerQueue.Ticker () {
4291: @Override protected void tick () {
4292: MC68901.mfpHsyncRise ();
4293: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddBack, crtClock += crtHSyncLength);
4294: }
4295: };
4296:
4297: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenBack = new TickerQueue.Ticker () {
4298: @Override protected void tick () {
4299: MC68901.mfpHsyncFall ();
4300: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenDisp, crtClock += crtHBackLength);
4301: }
4302: };
4303:
4304: public static final TickerQueue.Ticker DupExceptSpDrawDispOddBack = new TickerQueue.Ticker () {
4305: @Override protected void tick () {
4306: MC68901.mfpHsyncFall ();
4307: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddDisp, crtClock += crtHBackLength);
4308: }
4309: };
4310:
4311: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenDisp = new TickerQueue.Ticker () {
4312: @Override protected void tick () {
4313: if (crtRasterStamp[crtDataY] != crtAllStamp) {
4314: crtBeginningAllStamp = crtAllStamp;
4315: if (Malfunction.MLF_ON) {
4316: Malfunction.mlfRaster (crtDataY);
4317: }
4318: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
4319: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4320: crtStereoscopicDrawRaster (crtScreenY);
4321: }
4322: if (!XEiJ.PNL_USE_THREAD) {
4323: if (crtDirtyY0 < 0) {
4324: crtDirtyY0 = crtScreenY;
4325: }
4326: crtDirtyY1 = crtScreenY;
4327: }
4328: }
4329: if (SpriteScreen.SPR_THREE_STEPS) {
4330: if (SpriteScreen.sprActive) {
4331:
4332:
4333: SpriteScreen.sprStep1 (crtScreenY + 2);
4334: SpriteScreen.sprSwap ();
4335: SpriteScreen.sprStep2 (crtScreenY + 1);
4336: }
4337: }
4338: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddFront, crtClock += crtHDispLength);
4339: }
4340: };
4341:
4342: public static final TickerQueue.Ticker DupExceptSpDrawDispOddDisp = new TickerQueue.Ticker () {
4343: @Override protected void tick () {
4344: if (crtRasterStamp[crtDataY] != crtAllStamp) {
4345: crtRasterStamp[crtDataY] = crtAllStamp;
4346: crtBeginningAllStamp = crtAllStamp;
4347: if (Malfunction.MLF_ON) {
4348: Malfunction.mlfRaster (crtDataY);
4349: }
4350: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
4351: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4352: crtStereoscopicDrawRaster (crtScreenY);
4353: }
4354: if (!XEiJ.PNL_USE_THREAD) {
4355: if (crtDirtyY0 < 0) {
4356: crtDirtyY0 = crtScreenY;
4357: }
4358: crtDirtyY1 = crtScreenY;
4359: }
4360: }
4361: if (SpriteScreen.SPR_THREE_STEPS) {
4362: if (SpriteScreen.sprActive) {
4363:
4364:
4365: SpriteScreen.sprStep1 (crtScreenY + 2);
4366: SpriteScreen.sprSwap ();
4367: SpriteScreen.sprStep2 (crtScreenY + 1);
4368: }
4369: }
4370: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenFront, crtClock += crtHDispLength);
4371: }
4372: };
4373:
4374: public static final TickerQueue.Ticker DupExceptSpOmitIdleFront = new TickerQueue.Ticker () {
4375: @Override protected void tick () {
4376: int n = ++crtRasterNumber;
4377: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
4378: if (crtR04VFrontEndCurr < n) {
4379: n = crtRasterNumber = 0;
4380: }
4381: if (crtRasterCopyOn) {
4382: crtDoRasterCopy ();
4383: }
4384: if (RasterBreakPoint.RBP_ON) {
4385: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4386: RasterBreakPoint.rbpFire ();
4387: }
4388: }
4389: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4390: if (irq != MC68901.mfpGpipRint) {
4391: if (irq == 0) {
4392: if (RasterBreakPoint.RBP_ON) {
4393: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4394: RasterBreakPoint.rbpFire ();
4395: }
4396: }
4397: MC68901.mfpRintFall ();
4398: } else {
4399: MC68901.mfpRintRise ();
4400: }
4401: }
4402: if (n != crtVDispStart) {
4403: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4404: } else {
4405: MC68901.mfpVdispRise ();
4406: crtR11TxYZero = crtR11TxYCurr;
4407: crtR13GrYZero[0] = crtR13GrYCurr[0];
4408: crtR13GrYZero[1] = crtR13GrYCurr[1];
4409: crtR13GrYZero[2] = crtR13GrYCurr[2];
4410: crtR13GrYZero[3] = crtR13GrYCurr[3];
4411: if (crtR11TxYZeroLast != crtR11TxYZero ||
4412: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
4413: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
4414: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
4415: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
4416: crtR11TxYZeroLast = crtR11TxYZero;
4417: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
4418: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
4419: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
4420: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
4421: crtAllStamp += 2;
4422: }
4423: crtDataY = 0;
4424: if (crtClearFrames != 0) {
4425: crtClearFrames--;
4426: } else if (crtClearStandby) {
4427: crtClearStandby = false;
4428: crtClearFrames = 1;
4429: }
4430: if (XEiJ.PNL_USE_THREAD) {
4431: crtAllStamp += 2;
4432: }
4433: if (SpriteScreen.SPR_THREE_STEPS) {
4434: SpriteScreen.sprActive = SpriteScreen.sprLatched;
4435: if (SpriteScreen.sprActive) {
4436: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
4437: SpriteScreen.sprLatched = false;
4438: }
4439: if (!XEiJ.PNL_USE_THREAD) {
4440: crtAllStamp += 2;
4441: }
4442:
4443: SpriteScreen.sprStep1 (0);
4444: SpriteScreen.sprSwap ();
4445:
4446:
4447: SpriteScreen.sprStep1 (1);
4448: SpriteScreen.sprSwap ();
4449: SpriteScreen.sprStep2 (0);
4450: }
4451: }
4452: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4453: crtStereoscopicStart ();
4454: }
4455: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);
4456: }
4457: } else {
4458:
4459: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4460: }
4461: }
4462: };
4463:
4464: public static final TickerQueue.Ticker DupExceptSpOmitIdleSync = new TickerQueue.Ticker () {
4465: @Override protected void tick () {
4466: MC68901.mfpHsyncRise ();
4467: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleBackDisp, crtClock += crtHSyncLength);
4468: }
4469: };
4470:
4471: public static final TickerQueue.Ticker DupExceptSpOmitIdleBackDisp = new TickerQueue.Ticker () {
4472: @Override protected void tick () {
4473: MC68901.mfpHsyncFall ();
4474: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleFront, crtClock += crtHBackDispLength);
4475: }
4476: };
4477:
4478: public static final TickerQueue.Ticker DupExceptSpOmitDispEvenFront = new TickerQueue.Ticker () {
4479: @Override protected void tick () {
4480: int n = ++crtRasterNumber;
4481: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4482: if (crtRasterCopyOn) {
4483: crtDoRasterCopy ();
4484: }
4485: if (RasterBreakPoint.RBP_ON) {
4486: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4487: RasterBreakPoint.rbpFire ();
4488: }
4489: }
4490: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4491: if (irq != MC68901.mfpGpipRint) {
4492: if (irq == 0) {
4493: if (RasterBreakPoint.RBP_ON) {
4494: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4495: RasterBreakPoint.rbpFire ();
4496: }
4497: }
4498: MC68901.mfpRintFall ();
4499: } else {
4500: MC68901.mfpRintRise ();
4501: }
4502: }
4503: if (n != crtVIdleStart) {
4504: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);
4505: } else {
4506: MC68901.mfpVdispFall ();
4507: if (CRT_ENABLE_INTERMITTENT) {
4508: crtIntermittentCounter--;
4509: }
4510: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4511: crtDoFrameTask ();
4512: }
4513: if (XEiJ.PNL_USE_THREAD) {
4514: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4515: }
4516: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4517: }
4518: } else {
4519:
4520: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);
4521: }
4522: }
4523: };
4524:
4525: public static final TickerQueue.Ticker DupExceptSpOmitDispOddFront = new TickerQueue.Ticker () {
4526: @Override protected void tick () {
4527: int n = ++crtRasterNumber;
4528: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4529: if (crtRasterCopyOn) {
4530: crtDoRasterCopy ();
4531: }
4532: if (RasterBreakPoint.RBP_ON) {
4533: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4534: RasterBreakPoint.rbpFire ();
4535: }
4536: }
4537: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4538: if (irq != MC68901.mfpGpipRint) {
4539: if (irq == 0) {
4540: if (RasterBreakPoint.RBP_ON) {
4541: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4542: RasterBreakPoint.rbpFire ();
4543: }
4544: }
4545: MC68901.mfpRintFall ();
4546: } else {
4547: MC68901.mfpRintRise ();
4548: }
4549: }
4550: if (n != crtVIdleStart) {
4551: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddSync, crtClock += crtHFrontLength);
4552: } else {
4553: MC68901.mfpVdispFall ();
4554: if (CRT_ENABLE_INTERMITTENT) {
4555: crtIntermittentCounter--;
4556: }
4557: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4558: crtDoFrameTask ();
4559: }
4560: if (XEiJ.PNL_USE_THREAD) {
4561: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4562: }
4563: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4564: }
4565: } else {
4566:
4567: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddSync, crtClock += crtHFrontLength);
4568: }
4569: }
4570: };
4571:
4572: public static final TickerQueue.Ticker DupExceptSpOmitDispEvenSync = new TickerQueue.Ticker () {
4573: @Override protected void tick () {
4574: MC68901.mfpHsyncRise ();
4575: if (crtClearFrames != 0) {
4576: crtRapidClear (crtDataY);
4577: crtRasterStamp[crtDataY] = 0;
4578: }
4579: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenBackDisp, crtClock += crtHSyncLength);
4580: }
4581: };
4582:
4583: public static final TickerQueue.Ticker DupExceptSpOmitDispOddSync = new TickerQueue.Ticker () {
4584: @Override protected void tick () {
4585: MC68901.mfpHsyncRise ();
4586: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddBackDisp, crtClock += crtHSyncLength);
4587: }
4588: };
4589:
4590: public static final TickerQueue.Ticker DupExceptSpOmitDispEvenBackDisp = new TickerQueue.Ticker () {
4591: @Override protected void tick () {
4592: MC68901.mfpHsyncFall ();
4593: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddFront, crtClock += crtHBackDispLength);
4594: }
4595: };
4596:
4597: public static final TickerQueue.Ticker DupExceptSpOmitDispOddBackDisp = new TickerQueue.Ticker () {
4598: @Override protected void tick () {
4599: MC68901.mfpHsyncFall ();
4600: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenFront, crtClock += crtHBackDispLength);
4601: }
4602: };
4603:
4604:
4605:
4606: }
4607:
4608:
4609: