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.pnlStereoscopicShutter = 0;
1144: crtDuplication = false;
1145: crtInterlace = false;
1146: crtSlit = false;
1147: crtDupExceptSp = false;
1148: crtHSyncColumn = 2;
1149: crtHBackColumn = 2;
1150: crtHDispColumn = 2;
1151: crtHFrontColumn = 2;
1152: crtHTotalColumn = 8;
1153: crtVsyncMultiplier = 1.0;
1154: crtColumnTime = 0;
1155: crtHSyncLength = 0;
1156: crtHBackLength = 0;
1157: crtHDispLength = 0;
1158: crtHFrontLength = 0;
1159: crtHBackDispLength = 0;
1160: crtTotalLength = 0L;
1161: crtTotalLengthMNP = 0L;
1162:
1163: if (!XEiJ.PNL_USE_THREAD) {
1164: crtDirtyY0 = -1;
1165: crtDirtyY1 = -1;
1166: }
1167:
1168: Arrays.fill (crtRasterStamp, 0);
1169: crtAllStamp = 1;
1170:
1171: crtBeginningAllStamp = 1;
1172:
1173: crtRasterNumber = 0;
1174: crtDataY = 0;
1175: crtScreenY = 0;
1176: crtFrameParity = 0;
1177:
1178: crtRasterHashIdle = CRT_RASTER_HASH_ZERO;
1179: crtRasterHashDisp = CRT_RASTER_HASH_ZERO;
1180:
1181: crtContrastClock = XEiJ.FAR_FUTURE;
1182: crtCaptureClock = XEiJ.FAR_FUTURE;
1183: crtFrameTaskClock = Math.min (crtContrastClock, crtCaptureClock);
1184:
1185: if (CRT_ENABLE_INTERMITTENT) {
1186:
1187: crtIntermittentCounter = 0;
1188: }
1189:
1190: if (crtTicker != null) {
1191: TickerQueue.tkqRemove (crtTicker);
1192: crtTicker = null;
1193: }
1194: crtClock = XEiJ.FAR_FUTURE;
1195:
1196: }
1197:
1198:
1199:
1200: public static void crtRestart () {
1201: if (crtTicker != null) {
1202: TickerQueue.tkqRemove (crtTicker);
1203: }
1204: TickerQueue.tkqAdd (crtTicker = InitialStage, crtClock = XEiJ.mpuClockTime + CRT_RESTART_DELAY);
1205: }
1206:
1207:
1208:
1209: public static void crtStereoscopicStart () {
1210: if (XEiJ.PNL_USE_THREAD) {
1211: XEiJ.pnlBM = (XEiJ.pnlStereoscopicShutter != 1 ? XEiJ.pnlBMLeftArray[XEiJ.pnlBMWrite & 3] :
1212: XEiJ.pnlBMRightArray[XEiJ.pnlBMWrite & 3]);
1213: } else {
1214: XEiJ.pnlBM = (XEiJ.pnlStereoscopicShutter != 1 ? XEiJ.pnlBMLeft :
1215: XEiJ.pnlBMRight);
1216: }
1217: crtAllStamp += 2;
1218: }
1219:
1220:
1221:
1222: public static void crtStereoscopicDrawRaster (int screenY) {
1223: if (XEiJ.pnlStereoscopicShutter == 0 ||
1224: XEiJ.pnlStereoscopicShutter == 3) {
1225: if (XEiJ.PNL_USE_THREAD) {
1226: System.arraycopy (XEiJ.pnlBMLeftArray[XEiJ.pnlBMWrite & 3], screenY << XEiJ.PNL_BM_OFFSET_BITS,
1227: XEiJ.pnlBMRightArray[XEiJ.pnlBMWrite & 3], screenY << XEiJ.PNL_BM_OFFSET_BITS,
1228: XEiJ.pnlScreenWidth);
1229: } else {
1230: System.arraycopy (XEiJ.pnlBMLeft, screenY << XEiJ.PNL_BM_OFFSET_BITS,
1231: XEiJ.pnlBMRight, screenY << XEiJ.PNL_BM_OFFSET_BITS,
1232: XEiJ.pnlScreenWidth);
1233: }
1234: }
1235: }
1236:
1237:
1238:
1239: public static void crtUpdateScreen () {
1240: if (!XEiJ.PNL_USE_THREAD) {
1241: if (XEiJ.pnlZoomRatioOutY == 1 << 16) {
1242: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1 + crtDirtyY0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, crtDirtyY1 - crtDirtyY0 + 1);
1243: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
1244: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3 + crtDirtyY0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, crtDirtyY1 - crtDirtyY0 + 1);
1245: }
1246: } else {
1247: int y0 = (crtDirtyY0 - 1) * XEiJ.pnlZoomRatioOutY >> 16;
1248: int y1 = (crtDirtyY1 + 2) * (XEiJ.pnlZoomRatioOutY + 1) >> 16;
1249: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1 + y0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, y1 - y0);
1250: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
1251: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3 + y0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, y1 - y0);
1252: }
1253: }
1254: crtDirtyY0 = -1;
1255: }
1256: }
1257:
1258:
1259:
1260:
1261:
1262:
1263: public static void crtRepaint () {
1264: crtBeginningAllStamp = crtAllStamp;
1265: int l = Math.max (0, Math.min (1024, crtR07VDispEndCurr - crtR06VBackEndCurr));
1266: if (crtDuplication) {
1267: for (int screenY = 0; screenY < l; screenY += 2) {
1268: if (SpriteScreen.SPR_THREE_STEPS) {
1269: SpriteScreen.sprStep1 (screenY >> 1);
1270: SpriteScreen.sprStep2 (screenY >> 1);
1271: }
1272: if (Malfunction.MLF_ON) {
1273: Malfunction.mlfRaster (screenY >> 1);
1274: }
1275: VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);
1276: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1277: crtStereoscopicDrawRaster (screenY);
1278: }
1279:
1280: System.arraycopy (XEiJ.pnlBM, screenY << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlBM, screenY + 1 << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlScreenWidth);
1281: }
1282: } else if (crtSlit) {
1283: for (int screenY = 0; screenY < l; screenY += 2) {
1284: if (SpriteScreen.SPR_THREE_STEPS) {
1285: SpriteScreen.sprStep1 (screenY >> 1);
1286: SpriteScreen.sprStep2 (screenY >> 1);
1287: }
1288: if (Malfunction.MLF_ON) {
1289: Malfunction.mlfRaster (screenY >> 1);
1290: }
1291: VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);
1292: crtScanlineEffect.drawRaster (screenY + 1);
1293: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1294: crtStereoscopicDrawRaster (screenY);
1295: crtStereoscopicDrawRaster (screenY + 1);
1296: }
1297: }
1298: } else if (crtDupExceptSp) {
1299: for (int screenY = 0; screenY < l; screenY++) {
1300: if (SpriteScreen.SPR_THREE_STEPS) {
1301: SpriteScreen.sprStep1 (screenY);
1302: SpriteScreen.sprStep2 (screenY);
1303: }
1304: if (Malfunction.MLF_ON) {
1305: Malfunction.mlfRaster (screenY >> 1);
1306: }
1307: VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);
1308: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1309: crtStereoscopicDrawRaster (screenY);
1310: }
1311: }
1312: } else {
1313: for (int screenY = 0; screenY < l; screenY++) {
1314: if (SpriteScreen.SPR_THREE_STEPS) {
1315: SpriteScreen.sprStep1 (screenY);
1316: SpriteScreen.sprStep2 (screenY);
1317: }
1318: if (Malfunction.MLF_ON) {
1319: Malfunction.mlfRaster (screenY);
1320: }
1321: VideoController.vcnMode.drawRaster (screenY, screenY, false);
1322: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1323: crtStereoscopicDrawRaster (screenY);
1324: }
1325: }
1326: }
1327: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, l);
1328: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
1329: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, l);
1330: }
1331: }
1332:
1333:
1334:
1335:
1336:
1337:
1338: public static void crtDoFrameTask () {
1339: if (XEiJ.mpuClockTime >= crtContrastClock) {
1340: VideoController.vcnCurrentScaledContrast += VideoController.vcnCurrentScaledContrast < VideoController.vcnTargetScaledContrast ? 1 : -1;
1341: VideoController.vcnSetContrast (VideoController.vcnCurrentScaledContrast);
1342: if (VideoController.vcnCurrentScaledContrast == VideoController.vcnTargetScaledContrast) {
1343: crtContrastClock = XEiJ.FAR_FUTURE;
1344: } else {
1345: crtContrastClock += VideoController.VCN_CONTRAST_DELAY;
1346: }
1347: }
1348: if (XEiJ.mpuClockTime >= crtCaptureClock) {
1349: GIFAnimation.gifCaptureFrame ();
1350: }
1351: crtFrameTaskClock = Math.min (crtContrastClock, crtCaptureClock);
1352: }
1353:
1354:
1355:
1356:
1357:
1358: public static void crtSetMemoryMode (int textStorage, int graphicStorage, int memoryMode) {
1359: boolean updateMemoryMap = false;
1360: textStorage &= 1;
1361: if (crtTextStorage != textStorage) {
1362: crtTextStorage = textStorage;
1363: }
1364: graphicStorage &= 1;
1365: if (crtGraphicStorage != graphicStorage) {
1366: crtGraphicStorage = graphicStorage;
1367: updateMemoryMap = true;
1368: }
1369: memoryMode &= 7;
1370: crtMemoryModePort = memoryMode;
1371: int curr = crtMemoryModeMask == 0 ? crtMemoryModePort : crtMemoryModeTest;
1372: if (crtMemoryModeCurr != curr) {
1373: crtMemoryModeCurr = curr;
1374: updateMemoryMap = true;
1375: }
1376: if (updateMemoryMap) {
1377: if (crtGraphicStorage != 0) {
1378: if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn &&
1379: (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7)) {
1380:
1381: XEiJ.busSuper (MemoryMappedDevice.MMD_GJ0, 0x00c00000, 0x00e00000);
1382: } else {
1383:
1384: XEiJ.busSuper (MemoryMappedDevice.MMD_GG0, 0x00c00000, 0x00c80000);
1385: XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00c80000, 0x00e00000);
1386: }
1387: } else {
1388: switch (crtMemoryModeCurr) {
1389: case 0:
1390:
1391: XEiJ.busSuper (MemoryMappedDevice.MMD_GE0, 0x00c00000, 0x00c80000);
1392: XEiJ.busSuper (MemoryMappedDevice.MMD_GE1, 0x00c80000, 0x00d00000);
1393: XEiJ.busSuper (MemoryMappedDevice.MMD_GE2, 0x00d00000, 0x00d80000);
1394: XEiJ.busSuper (MemoryMappedDevice.MMD_GE3, 0x00d80000, 0x00e00000);
1395: break;
1396: case 1:
1397:
1398: XEiJ.busSuper (MemoryMappedDevice.MMD_GF0, 0x00c00000, 0x00c80000);
1399: XEiJ.busSuper (MemoryMappedDevice.MMD_GF1, 0x00c80000, 0x00d00000);
1400: XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00d00000, 0x00e00000);
1401: break;
1402: case 2:
1403:
1404: XEiJ.busSuper (MemoryMappedDevice.MMD_GM2, 0x00c00000, 0x00e00000);
1405: break;
1406: case 3:
1407:
1408: XEiJ.busSuper (MemoryMappedDevice.MMD_GG0, 0x00c00000, 0x00c80000);
1409: XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00c80000, 0x00e00000);
1410: break;
1411: case 4:
1412:
1413: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1414: break;
1415: case 5:
1416: if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn) {
1417:
1418: XEiJ.busSuper (MemoryMappedDevice.MMD_GI0, 0x00c00000, 0x00e00000);
1419: } else {
1420:
1421: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1422: }
1423: break;
1424: case 6:
1425:
1426: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1427: break;
1428: case 7:
1429: if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn) {
1430:
1431: XEiJ.busSuper (MemoryMappedDevice.MMD_GJ0, 0x00c00000, 0x00e00000);
1432: } else {
1433:
1434: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1435: }
1436: break;
1437: }
1438: }
1439: }
1440: }
1441:
1442:
1443:
1444:
1445:
1446:
1447:
1448:
1449:
1450:
1451:
1452: public static void crtUpdateRasterHash () {
1453: if (CRT_RASTER_HASH_ON) {
1454: long t = crtRasterCopyOn ? ~CRT_RASTER_HASH_ZERO : CRT_RASTER_HASH_ZERO;
1455:
1456: if (RasterBreakPoint.RBP_ON && RasterBreakPoint.rbpActiveBreakRaster >= 0) {
1457: t |= CRT_RASTER_HASH_MSB >>> RasterBreakPoint.rbpActiveBreakRaster;
1458: }
1459: if (crtR09IRQRasterCurr <= crtR04VFrontEndCurr) {
1460: t |= (CRT_RASTER_HASH_MSB >>> crtR09IRQRasterCurr |
1461: CRT_RASTER_HASH_MSB >>> (crtR09IRQRasterCurr < crtR04VFrontEndCurr ? crtR09IRQRasterCurr + 1 : 0));
1462: }
1463: crtRasterHashIdle = (t |
1464: CRT_RASTER_HASH_MSB >>> crtVDispStart |
1465: CRT_RASTER_HASH_MSB >>> crtR04VFrontEndCurr + 1);
1466: crtRasterHashDisp = (t |
1467: CRT_RASTER_HASH_MSB >>> crtVIdleStart);
1468: }
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: public static void crtRapidClear (int y) {
1507: y += crtR13GrYZero[0];
1508: int x = crtR12GrXCurr[0] & (512 - 2);
1509: int w = 8 * crtHDispColumn;
1510: if (512 <= w) {
1511: x = 0;
1512: w = 512;
1513: }
1514: if (crtMemoryModeCurr < 4) {
1515: int i = (y & 511) << 9;
1516: if (x + w <= 512) {
1517:
1518:
1519: if (crtCCPlane0) {
1520: Arrays.fill (GraphicScreen.graM4, i + x, i + x + w, (byte) 0);
1521: }
1522: if (crtCCPlane1) {
1523: Arrays.fill (GraphicScreen.graM4, 0x40000 + i + x, 0x40000 + i + x + w, (byte) 0);
1524: }
1525: if (crtCCPlane2) {
1526: Arrays.fill (GraphicScreen.graM4, 0x80000 + i + x, 0x80000 + i + x + w, (byte) 0);
1527: }
1528: if (crtCCPlane3) {
1529: Arrays.fill (GraphicScreen.graM4, 0xc0000 + i + x, 0xc0000 + i + x + w, (byte) 0);
1530: }
1531: } else {
1532:
1533:
1534: if (crtCCPlane0) {
1535: Arrays.fill (GraphicScreen.graM4, i + x, i + 512, (byte) 0);
1536: Arrays.fill (GraphicScreen.graM4, i , i + x + w - 512, (byte) 0);
1537: }
1538: if (crtCCPlane1) {
1539: Arrays.fill (GraphicScreen.graM4, 0x40000 + i + x, 0x40000 + i + 512, (byte) 0);
1540: Arrays.fill (GraphicScreen.graM4, 0x40000 + i , 0x40000 + i + x + w - 512, (byte) 0);
1541: }
1542: if (crtCCPlane2) {
1543: Arrays.fill (GraphicScreen.graM4, 0x80000 + i + x, 0x80000 + i + 512, (byte) 0);
1544: Arrays.fill (GraphicScreen.graM4, 0x80000 + i , 0x80000 + i + x + w - 512, (byte) 0);
1545: }
1546: if (crtCCPlane3) {
1547: Arrays.fill (GraphicScreen.graM4, 0xc0000 + i + x, 0xc0000 + i + 512, (byte) 0);
1548: Arrays.fill (GraphicScreen.graM4, 0xc0000 + i , 0xc0000 + i + x + w - 512, (byte) 0);
1549: }
1550: }
1551: } else {
1552: int i = (y & 512) << 10 | (y & 511) << 9;
1553: if (x + w <= 512) {
1554:
1555:
1556: for (int k = 0; k < 2; k++) {
1557: Arrays.fill (GraphicScreen.graM4, i + x, i + x + w, (byte) 0);
1558: if (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7) {
1559: Arrays.fill (GraphicScreen.graM4, 0x100000 + i + x, 0x100000 + i + x + w, (byte) 0);
1560: if (crtMemoryModeCurr == 7) {
1561: Arrays.fill (GraphicScreen.graM4, 0x200000 + i + x, 0x200000 + i + x + w, (byte) 0);
1562: Arrays.fill (GraphicScreen.graM4, 0x300000 + i + x, 0x300000 + i + x + w, (byte) 0);
1563: }
1564: }
1565: i += 512 << 9;
1566: }
1567: } else {
1568:
1569:
1570: for (int k = 0; k < 2; k++) {
1571: Arrays.fill (GraphicScreen.graM4, i + x, i + 512, (byte) 0);
1572: Arrays.fill (GraphicScreen.graM4, i , i + x + w - 512, (byte) 0);
1573: if (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7) {
1574: Arrays.fill (GraphicScreen.graM4, 0x100000 + i + x, 0x100000 + i + 512, (byte) 0);
1575: Arrays.fill (GraphicScreen.graM4, 0x100000 + i , 0x100000 + i + x + w - 512, (byte) 0);
1576: if (crtMemoryModeCurr == 7) {
1577: Arrays.fill (GraphicScreen.graM4, 0x200000 + i + x, 0x200000 + i + 512, (byte) 0);
1578: Arrays.fill (GraphicScreen.graM4, 0x200000 + i , 0x200000 + i + x + w - 512, (byte) 0);
1579: Arrays.fill (GraphicScreen.graM4, 0x300000 + i + x, 0x300000 + i + 512, (byte) 0);
1580: Arrays.fill (GraphicScreen.graM4, 0x300000 + i , 0x300000 + i + x + w - 512, (byte) 0);
1581: }
1582: }
1583: i += 512 << 9;
1584: }
1585: }
1586: }
1587: }
1588:
1589:
1590:
1591: public static void crtDoRasterCopy () {
1592: int srcOffset = crtR22SrcBlock << 9;
1593: int dstOffset = crtR22DstBlock << 9;
1594: if (crtCCPlane0) {
1595: System.arraycopy (MainMemory.mmrM8, 0x00e00000 + srcOffset, MainMemory.mmrM8, 0x00e00000 + dstOffset, 512);
1596: }
1597: if (crtCCPlane1) {
1598: System.arraycopy (MainMemory.mmrM8, 0x00e20000 + srcOffset, MainMemory.mmrM8, 0x00e20000 + dstOffset, 512);
1599: }
1600: if (crtCCPlane2) {
1601: System.arraycopy (MainMemory.mmrM8, 0x00e40000 + srcOffset, MainMemory.mmrM8, 0x00e40000 + dstOffset, 512);
1602: }
1603: if (crtCCPlane3) {
1604: System.arraycopy (MainMemory.mmrM8, 0x00e60000 + srcOffset, MainMemory.mmrM8, 0x00e60000 + dstOffset, 512);
1605: }
1606: int y = (dstOffset >> 7) - crtR11TxYZero;
1607: crtRasterStamp[y & 1023] = 0;
1608: crtRasterStamp[y + 1 & 1023] = 0;
1609: crtRasterStamp[y + 2 & 1023] = 0;
1610: crtRasterStamp[y + 3 & 1023] = 0;
1611: }
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: public static void crtUpdateLength () {
1880: int k = crtHRLCurr << 3 | crtHighResoCurr << 2 | crtHResoCurr;
1881: double osc = (double) crtFreqs[CRT_OSCS[k]];
1882: int div = CRT_DIVS[k];
1883: int vTotal = crtR04VFrontEndCurr + 1;
1884: double multiplier = 1.0;
1885: if (XEiJ.pnlAdjustVsync && XEiJ.pnlFixedRate != 0.0) {
1886: double hFreq = osc / (8 * div * crtHTotalColumn);
1887: double vFreq = hFreq / vTotal;
1888: double rate = XEiJ.pnlFixedRate;
1889: if (vFreq * 0.75 <= rate && rate <= vFreq * 1.25) {
1890: multiplier = rate / vFreq;
1891: }
1892: }
1893: crtVsyncMultiplier = multiplier;
1894: crtColumnTime = (int) ((double) (XEiJ.TMR_FREQ * 8 * div) / (osc * multiplier) + 0.5);
1895: crtHSyncLength = crtColumnTime * crtHSyncColumn;
1896: crtHBackLength = crtColumnTime * crtHBackColumn;
1897: crtHDispLength = crtColumnTime * crtHDispColumn;
1898: crtHFrontLength = crtColumnTime * crtHFrontColumn;
1899: crtHBackDispLength = crtColumnTime * (crtHBackColumn + crtHDispColumn);
1900: long t = (long) crtColumnTime * (long) (crtHTotalColumn * vTotal);
1901: crtTotalLength = t / 1000000000L;
1902: crtTotalLengthMNP = t - 1000000000L * crtTotalLength;
1903: }
1904:
1905:
1906:
1907: public static final TickerQueue.Ticker InitialStage = new TickerQueue.Ticker () {
1908: @Override protected void tick () {
1909: ret:
1910: {
1911:
1912:
1913:
1914:
1915:
1916: if (!(crtR02HBackEndCurr < crtR03HDispEndCurr && crtR03HDispEndCurr - crtR02HBackEndCurr <= 128 &&
1917: crtR07VDispEndCurr < crtR04VFrontEndCurr && crtR07VDispEndCurr - crtR06VBackEndCurr <= 1024 &&
1918: crtR05VSyncEndCurr < crtR06VBackEndCurr &&
1919: crtR06VBackEndCurr < crtR07VDispEndCurr)) {
1920: crtRestart ();
1921: break ret;
1922: }
1923:
1924: if (CRT_RASTER_HASH_ON) {
1925: crtUpdateRasterHash ();
1926: }
1927:
1928:
1929:
1930:
1931:
1932:
1933: int hSync = crtR01HSyncEndCurr + 1;
1934: int hBack = crtR02HBackEndCurr - crtR01HSyncEndCurr + 4;
1935: int hDisp = crtR03HDispEndCurr - crtR02HBackEndCurr;
1936: int hFront = crtR00HFrontEndCurr - crtR03HDispEndCurr - 4;
1937: if (hSync + hBack + hDisp + hFront < hDisp + 3) {
1938: hSync = hBack = hFront = 1;
1939: } else {
1940: if (hBack <= 0) {
1941: hFront -= 1 - hBack;
1942: hBack = 1;
1943: if (hFront <= 0) {
1944: hSync -= 1 - hFront;
1945: hFront = 1;
1946: }
1947: } else if (hFront <= 0) {
1948: hBack -= 1 - hFront;
1949: hFront = 1;
1950: if (hBack <= 0) {
1951: hSync -= 1 - hBack;
1952: hBack = 1;
1953: }
1954: }
1955: }
1956: crtHSyncColumn = hSync;
1957: crtHBackColumn = hBack;
1958: crtHDispColumn = hDisp;
1959: crtHFrontColumn = hFront;
1960: crtHTotalColumn = hSync + hBack + hDisp + hFront;
1961: crtUpdateLength ();
1962:
1963: crtDuplication = crtHighResoCurr == 1 && crtVResoCurr == 0 && ((SpriteScreen.sprReg8ResoCurr & 12) != 4);
1964: crtInterlace = crtHighResoCurr + 1 <= crtVResoCurr;
1965: crtSlit = crtHighResoCurr == 0 && crtVResoCurr == 0;
1966: crtDupExceptSp = crtHighResoCurr == 1 && crtVResoCurr == 0 && ((SpriteScreen.sprReg8ResoCurr & 12) == 4);
1967:
1968: XEiJ.pnlUpdateArrangement ();
1969:
1970: crtAllStamp += 2;
1971: (crtDuplication ? DuplicationStart :
1972: crtInterlace ? InterlaceStart :
1973: crtSlit ? SlitStart :
1974: crtDupExceptSp ? DupExceptSpStart :
1975: NormalStart).tick ();
1976: }
1977: }
1978: };
1979:
1980:
1981:
1982:
1983: public static final TickerQueue.Ticker NormalStart = new TickerQueue.Ticker () {
1984: @Override protected void tick () {
1985: if (MC68901.mfpGpipHsync != 0) {
1986: MC68901.mfpHsyncFall ();
1987: }
1988: int n = crtRasterNumber = crtVIdleStart;
1989: if (crtRasterCopyOn) {
1990: crtDoRasterCopy ();
1991: }
1992: if (RasterBreakPoint.RBP_ON) {
1993: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
1994: RasterBreakPoint.rbpFire ();
1995: }
1996: }
1997: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
1998: if (irq != MC68901.mfpGpipRint) {
1999: if (irq == 0) {
2000: if (RasterBreakPoint.RBP_ON) {
2001: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2002: RasterBreakPoint.rbpFire ();
2003: }
2004: }
2005: MC68901.mfpRintFall ();
2006: } else {
2007: MC68901.mfpRintRise ();
2008: }
2009: }
2010: if (MC68901.mfpGpipVdisp != 0) {
2011: MC68901.mfpVdispFall ();
2012: }
2013: crtClearFrames = 0;
2014: if (CRT_ENABLE_INTERMITTENT) {
2015: crtIntermittentCounter = 0;
2016: }
2017: if (!XEiJ.PNL_USE_THREAD) {
2018: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2019: crtDoFrameTask ();
2020: }
2021: }
2022: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
2023: }
2024: };
2025:
2026: public static final TickerQueue.Ticker NormalDrawIdleFront = new TickerQueue.Ticker () {
2027: @Override protected void tick () {
2028: int n = ++crtRasterNumber;
2029: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2030: if (crtR04VFrontEndCurr < n) {
2031: n = crtRasterNumber = 0;
2032: }
2033: if (crtRasterCopyOn) {
2034: crtDoRasterCopy ();
2035: }
2036: if (RasterBreakPoint.RBP_ON) {
2037: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2038: RasterBreakPoint.rbpFire ();
2039: }
2040: }
2041: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2042: if (irq != MC68901.mfpGpipRint) {
2043: if (irq == 0) {
2044: if (RasterBreakPoint.RBP_ON) {
2045: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2046: RasterBreakPoint.rbpFire ();
2047: }
2048: }
2049: MC68901.mfpRintFall ();
2050: } else {
2051: MC68901.mfpRintRise ();
2052: }
2053: }
2054: if (n != crtVDispStart) {
2055: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
2056: } else {
2057: MC68901.mfpVdispRise ();
2058: crtR11TxYZero = crtR11TxYCurr;
2059: crtR13GrYZero[0] = crtR13GrYCurr[0];
2060: crtR13GrYZero[1] = crtR13GrYCurr[1];
2061: crtR13GrYZero[2] = crtR13GrYCurr[2];
2062: crtR13GrYZero[3] = crtR13GrYCurr[3];
2063: if (crtR11TxYZeroLast != crtR11TxYZero ||
2064: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2065: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2066: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2067: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2068: crtR11TxYZeroLast = crtR11TxYZero;
2069: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2070: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2071: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2072: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2073: crtAllStamp += 2;
2074: }
2075: crtDataY = 0;
2076: if (crtClearFrames != 0) {
2077: crtClearFrames--;
2078: } else if (crtClearStandby) {
2079: crtClearStandby = false;
2080: crtClearFrames = 1;
2081: }
2082: crtScreenY = 0;
2083: if (!XEiJ.PNL_USE_THREAD) {
2084: crtDirtyY0 = -1;
2085: }
2086: if (XEiJ.PNL_USE_THREAD) {
2087: crtAllStamp += 2;
2088: }
2089: if (SpriteScreen.SPR_THREE_STEPS) {
2090: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2091: if (SpriteScreen.sprActive) {
2092: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2093: SpriteScreen.sprLatched = false;
2094: }
2095: if (!XEiJ.PNL_USE_THREAD) {
2096: crtAllStamp += 2;
2097: }
2098:
2099: SpriteScreen.sprStep1 (0);
2100: SpriteScreen.sprSwap ();
2101:
2102:
2103: SpriteScreen.sprStep1 (1);
2104: SpriteScreen.sprSwap ();
2105: SpriteScreen.sprStep2 (0);
2106: }
2107: }
2108: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2109: crtStereoscopicStart ();
2110: }
2111: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
2112: }
2113: } else {
2114:
2115: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
2116: }
2117: }
2118: };
2119:
2120: public static final TickerQueue.Ticker NormalDrawIdleSync = new TickerQueue.Ticker () {
2121: @Override protected void tick () {
2122: MC68901.mfpHsyncRise ();
2123: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleBackDisp, crtClock += crtHSyncLength);
2124: }
2125: };
2126:
2127: public static final TickerQueue.Ticker NormalDrawIdleBackDisp = new TickerQueue.Ticker () {
2128: @Override protected void tick () {
2129: MC68901.mfpHsyncFall ();
2130: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleFront, crtClock += crtHBackDispLength);
2131: }
2132: };
2133:
2134: public static final TickerQueue.Ticker NormalDrawDispFront = new TickerQueue.Ticker () {
2135: @Override protected void tick () {
2136: int n = ++crtRasterNumber;
2137: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2138: if (crtRasterCopyOn) {
2139: crtDoRasterCopy ();
2140: }
2141: if (RasterBreakPoint.RBP_ON) {
2142: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2143: RasterBreakPoint.rbpFire ();
2144: }
2145: }
2146: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2147: if (irq != MC68901.mfpGpipRint) {
2148: if (irq == 0) {
2149: if (RasterBreakPoint.RBP_ON) {
2150: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2151: RasterBreakPoint.rbpFire ();
2152: }
2153: }
2154: MC68901.mfpRintFall ();
2155: } else {
2156: MC68901.mfpRintRise ();
2157: }
2158: }
2159: if (n != crtVIdleStart) {
2160: if (crtBeginningAllStamp != crtAllStamp) {
2161: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2162: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2163: crtStereoscopicDrawRaster (crtScreenY);
2164: }
2165: }
2166: crtScreenY++;
2167: crtDataY++;
2168: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
2169: } else {
2170: if (crtBeginningAllStamp != crtAllStamp) {
2171: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2172: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2173: crtStereoscopicDrawRaster (crtScreenY);
2174: }
2175: }
2176: MC68901.mfpVdispFall ();
2177: if (!XEiJ.PNL_USE_THREAD) {
2178: if (crtDirtyY0 >= 0) {
2179: crtUpdateScreen ();
2180: if (CRT_ENABLE_INTERMITTENT) {
2181: crtIntermittentCounter = crtIntermittentInterval;
2182: }
2183: }
2184: }
2185: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2186: crtDoFrameTask ();
2187: }
2188: if (XEiJ.PNL_USE_THREAD) {
2189: if (FlashingLights.FLR_ON &&
2190: FlashingLights.flrActive) {
2191: FlashingLights.flrVsync ();
2192: }
2193: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2194: }
2195: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
2196: }
2197: } else {
2198:
2199: if (crtBeginningAllStamp != crtAllStamp) {
2200: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2201: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2202: crtStereoscopicDrawRaster (crtScreenY);
2203: }
2204: }
2205: crtScreenY++;
2206: crtDataY++;
2207: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
2208: }
2209: }
2210: };
2211:
2212: public static final TickerQueue.Ticker NormalDrawDispSync = new TickerQueue.Ticker () {
2213: @Override protected void tick () {
2214: MC68901.mfpHsyncRise ();
2215: if (crtClearFrames != 0) {
2216: crtRapidClear (crtDataY);
2217: crtRasterStamp[crtDataY] = 0;
2218: }
2219: TickerQueue.tkqAdd (crtTicker = NormalDrawDispBack, crtClock += crtHSyncLength);
2220: }
2221: };
2222:
2223: public static final TickerQueue.Ticker NormalDrawDispBack = new TickerQueue.Ticker () {
2224: @Override protected void tick () {
2225: MC68901.mfpHsyncFall ();
2226: TickerQueue.tkqAdd (crtTicker = NormalDrawDispDisp, crtClock += crtHBackLength);
2227: }
2228: };
2229:
2230: public static final TickerQueue.Ticker NormalDrawDispDisp = new TickerQueue.Ticker () {
2231: @Override protected void tick () {
2232: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2233: crtRasterStamp[crtDataY] = crtAllStamp;
2234: crtBeginningAllStamp = crtAllStamp;
2235: if (Malfunction.MLF_ON) {
2236: Malfunction.mlfRaster (crtDataY);
2237: }
2238: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2239: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2240: crtStereoscopicDrawRaster (crtScreenY);
2241: }
2242: if (!XEiJ.PNL_USE_THREAD) {
2243: if (crtDirtyY0 < 0) {
2244: crtDirtyY0 = crtScreenY;
2245: }
2246: crtDirtyY1 = crtScreenY;
2247: }
2248: }
2249: if (SpriteScreen.SPR_THREE_STEPS) {
2250: if (SpriteScreen.sprActive) {
2251:
2252:
2253: SpriteScreen.sprStep1 (crtDataY + 2);
2254: SpriteScreen.sprSwap ();
2255: SpriteScreen.sprStep2 (crtDataY + 1);
2256: }
2257: }
2258: TickerQueue.tkqAdd (crtTicker = NormalDrawDispFront, crtClock += crtHDispLength);
2259: }
2260: };
2261:
2262: public static final TickerQueue.Ticker NormalOmitIdleFront = new TickerQueue.Ticker () {
2263: @Override protected void tick () {
2264: int n = ++crtRasterNumber;
2265: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2266: if (crtR04VFrontEndCurr < n) {
2267: n = crtRasterNumber = 0;
2268: }
2269: if (crtRasterCopyOn) {
2270: crtDoRasterCopy ();
2271: }
2272: if (RasterBreakPoint.RBP_ON) {
2273: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2274: RasterBreakPoint.rbpFire ();
2275: }
2276: }
2277: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2278: if (irq != MC68901.mfpGpipRint) {
2279: if (irq == 0) {
2280: if (RasterBreakPoint.RBP_ON) {
2281: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2282: RasterBreakPoint.rbpFire ();
2283: }
2284: }
2285: MC68901.mfpRintFall ();
2286: } else {
2287: MC68901.mfpRintRise ();
2288: }
2289: }
2290: if (n != crtVDispStart) {
2291: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2292: } else {
2293: MC68901.mfpVdispRise ();
2294: crtR11TxYZero = crtR11TxYCurr;
2295: crtR13GrYZero[0] = crtR13GrYCurr[0];
2296: crtR13GrYZero[1] = crtR13GrYCurr[1];
2297: crtR13GrYZero[2] = crtR13GrYCurr[2];
2298: crtR13GrYZero[3] = crtR13GrYCurr[3];
2299: if (crtR11TxYZeroLast != crtR11TxYZero ||
2300: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2301: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2302: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2303: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2304: crtR11TxYZeroLast = crtR11TxYZero;
2305: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2306: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2307: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2308: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2309: crtAllStamp += 2;
2310: }
2311: crtDataY = 0;
2312: if (crtClearFrames != 0) {
2313: crtClearFrames--;
2314: } else if (crtClearStandby) {
2315: crtClearStandby = false;
2316: crtClearFrames = 1;
2317: }
2318: if (XEiJ.PNL_USE_THREAD) {
2319: crtAllStamp += 2;
2320: }
2321: if (SpriteScreen.SPR_THREE_STEPS) {
2322: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2323: if (SpriteScreen.sprActive) {
2324: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2325: SpriteScreen.sprLatched = false;
2326: }
2327: if (!XEiJ.PNL_USE_THREAD) {
2328: crtAllStamp += 2;
2329: }
2330:
2331: SpriteScreen.sprStep1 (0);
2332: SpriteScreen.sprSwap ();
2333:
2334:
2335: SpriteScreen.sprStep1 (1);
2336: SpriteScreen.sprSwap ();
2337: SpriteScreen.sprStep2 (0);
2338: }
2339: }
2340: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2341: crtStereoscopicStart ();
2342: }
2343: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2344: }
2345: } else {
2346:
2347: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2348: }
2349: }
2350: };
2351:
2352: public static final TickerQueue.Ticker NormalOmitIdleSync = new TickerQueue.Ticker () {
2353: @Override protected void tick () {
2354: MC68901.mfpHsyncRise ();
2355: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleBackDisp, crtClock += crtHSyncLength);
2356: }
2357: };
2358:
2359: public static final TickerQueue.Ticker NormalOmitIdleBackDisp = new TickerQueue.Ticker () {
2360: @Override protected void tick () {
2361: MC68901.mfpHsyncFall ();
2362: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleFront, crtClock += crtHBackDispLength);
2363: }
2364: };
2365:
2366: public static final TickerQueue.Ticker NormalOmitDispFront = new TickerQueue.Ticker () {
2367: @Override protected void tick () {
2368: int n = ++crtRasterNumber;
2369: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2370: if (crtRasterCopyOn) {
2371: crtDoRasterCopy ();
2372: }
2373: if (RasterBreakPoint.RBP_ON) {
2374: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2375: RasterBreakPoint.rbpFire ();
2376: }
2377: }
2378: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2379: if (irq != MC68901.mfpGpipRint) {
2380: if (irq == 0) {
2381: if (RasterBreakPoint.RBP_ON) {
2382: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2383: RasterBreakPoint.rbpFire ();
2384: }
2385: }
2386: MC68901.mfpRintFall ();
2387: } else {
2388: MC68901.mfpRintRise ();
2389: }
2390: }
2391: if (n != crtVIdleStart) {
2392: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2393: } else {
2394: MC68901.mfpVdispFall ();
2395: if (CRT_ENABLE_INTERMITTENT) {
2396: crtIntermittentCounter--;
2397: }
2398: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2399: crtDoFrameTask ();
2400: }
2401: if (XEiJ.PNL_USE_THREAD) {
2402: if (FlashingLights.FLR_ON &&
2403: FlashingLights.flrActive) {
2404: FlashingLights.flrVsync ();
2405: }
2406: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2407: }
2408: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2409: }
2410: } else {
2411:
2412: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2413: }
2414: }
2415: };
2416:
2417: public static final TickerQueue.Ticker NormalOmitDispSync = new TickerQueue.Ticker () {
2418: @Override protected void tick () {
2419: MC68901.mfpHsyncRise ();
2420: if (crtClearFrames != 0) {
2421: crtRapidClear (crtDataY);
2422: crtRasterStamp[crtDataY] = 0;
2423: }
2424: TickerQueue.tkqAdd (crtTicker = NormalOmitDispBackDisp, crtClock += crtHSyncLength);
2425: }
2426: };
2427:
2428: public static final TickerQueue.Ticker NormalOmitDispBackDisp = new TickerQueue.Ticker () {
2429: @Override protected void tick () {
2430: MC68901.mfpHsyncFall ();
2431: TickerQueue.tkqAdd (crtTicker = NormalOmitDispFront, crtClock += crtHBackDispLength);
2432: }
2433: };
2434:
2435:
2436:
2437:
2438: public static final TickerQueue.Ticker DuplicationStart = new TickerQueue.Ticker () {
2439: @Override protected void tick () {
2440: if (MC68901.mfpGpipHsync != 0) {
2441: MC68901.mfpHsyncFall ();
2442: }
2443: int n = crtRasterNumber = crtVIdleStart;
2444: if (crtRasterCopyOn) {
2445: crtDoRasterCopy ();
2446: }
2447: if (RasterBreakPoint.RBP_ON) {
2448: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2449: RasterBreakPoint.rbpFire ();
2450: }
2451: }
2452: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2453: if (irq != MC68901.mfpGpipRint) {
2454: if (irq == 0) {
2455: if (RasterBreakPoint.RBP_ON) {
2456: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2457: RasterBreakPoint.rbpFire ();
2458: }
2459: }
2460: MC68901.mfpRintFall ();
2461: } else {
2462: MC68901.mfpRintRise ();
2463: }
2464: }
2465: if (MC68901.mfpGpipVdisp != 0) {
2466: MC68901.mfpVdispFall ();
2467: }
2468: crtClearFrames = 0;
2469: if (CRT_ENABLE_INTERMITTENT) {
2470: crtIntermittentCounter = 0;
2471: }
2472: if (!XEiJ.PNL_USE_THREAD) {
2473: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2474: crtDoFrameTask ();
2475: }
2476: }
2477: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2478: }
2479: };
2480:
2481: public static final TickerQueue.Ticker DuplicationDrawIdleFront = new TickerQueue.Ticker () {
2482: @Override protected void tick () {
2483: int n = ++crtRasterNumber;
2484: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2485: if (crtR04VFrontEndCurr < n) {
2486: n = crtRasterNumber = 0;
2487: }
2488: if (crtRasterCopyOn) {
2489: crtDoRasterCopy ();
2490: }
2491: if (RasterBreakPoint.RBP_ON) {
2492: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2493: RasterBreakPoint.rbpFire ();
2494: }
2495: }
2496: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2497: if (irq != MC68901.mfpGpipRint) {
2498: if (irq == 0) {
2499: if (RasterBreakPoint.RBP_ON) {
2500: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2501: RasterBreakPoint.rbpFire ();
2502: }
2503: }
2504: MC68901.mfpRintFall ();
2505: } else {
2506: MC68901.mfpRintRise ();
2507: }
2508: }
2509: if (n != crtVDispStart) {
2510: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2511: } else {
2512: MC68901.mfpVdispRise ();
2513: crtR11TxYZero = crtR11TxYCurr;
2514: crtR13GrYZero[0] = crtR13GrYCurr[0];
2515: crtR13GrYZero[1] = crtR13GrYCurr[1];
2516: crtR13GrYZero[2] = crtR13GrYCurr[2];
2517: crtR13GrYZero[3] = crtR13GrYCurr[3];
2518: if (crtR11TxYZeroLast != crtR11TxYZero ||
2519: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2520: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2521: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2522: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2523: crtR11TxYZeroLast = crtR11TxYZero;
2524: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2525: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2526: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2527: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2528: crtAllStamp += 2;
2529: }
2530: crtDataY = 0;
2531: if (crtClearFrames != 0) {
2532: crtClearFrames--;
2533: } else if (crtClearStandby) {
2534: crtClearStandby = false;
2535: crtClearFrames = 1;
2536: }
2537: crtScreenY = 0;
2538: if (!XEiJ.PNL_USE_THREAD) {
2539: crtDirtyY0 = -1;
2540: }
2541: if (XEiJ.PNL_USE_THREAD) {
2542: crtAllStamp += 2;
2543: }
2544: if (SpriteScreen.SPR_THREE_STEPS) {
2545: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2546: if (SpriteScreen.sprActive) {
2547: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2548: SpriteScreen.sprLatched = false;
2549: }
2550: if (!XEiJ.PNL_USE_THREAD) {
2551: crtAllStamp += 2;
2552: }
2553:
2554: SpriteScreen.sprStep1 (0);
2555: SpriteScreen.sprSwap ();
2556:
2557:
2558: SpriteScreen.sprStep1 (0);
2559: SpriteScreen.sprSwap ();
2560: SpriteScreen.sprStep2 (0);
2561: }
2562: }
2563: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2564: crtStereoscopicStart ();
2565: }
2566: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2567: }
2568: } else {
2569:
2570: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2571: }
2572: }
2573: };
2574:
2575: public static final TickerQueue.Ticker DuplicationDrawIdleSync = new TickerQueue.Ticker () {
2576: @Override protected void tick () {
2577: MC68901.mfpHsyncRise ();
2578: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleBackDisp, crtClock += crtHSyncLength);
2579: }
2580: };
2581:
2582: public static final TickerQueue.Ticker DuplicationDrawIdleBackDisp = new TickerQueue.Ticker () {
2583: @Override protected void tick () {
2584: MC68901.mfpHsyncFall ();
2585: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleFront, crtClock += crtHBackDispLength);
2586: }
2587: };
2588:
2589: public static final TickerQueue.Ticker DuplicationDrawDispEvenFront = new TickerQueue.Ticker () {
2590: @Override protected void tick () {
2591: int n = ++crtRasterNumber;
2592: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2593: if (crtRasterCopyOn) {
2594: crtDoRasterCopy ();
2595: }
2596: if (RasterBreakPoint.RBP_ON) {
2597: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2598: RasterBreakPoint.rbpFire ();
2599: }
2600: }
2601: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2602: if (irq != MC68901.mfpGpipRint) {
2603: if (irq == 0) {
2604: if (RasterBreakPoint.RBP_ON) {
2605: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2606: RasterBreakPoint.rbpFire ();
2607: }
2608: }
2609: MC68901.mfpRintFall ();
2610: } else {
2611: MC68901.mfpRintRise ();
2612: }
2613: }
2614: if (n != crtVIdleStart) {
2615: if (crtBeginningAllStamp != crtAllStamp) {
2616: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2617: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2618: crtStereoscopicDrawRaster (crtScreenY);
2619: }
2620: }
2621: crtScreenY++;
2622: crtDataY++;
2623: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2624: } else {
2625: if (crtBeginningAllStamp != crtAllStamp) {
2626: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2627: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2628: crtStereoscopicDrawRaster (crtScreenY);
2629: }
2630: }
2631: MC68901.mfpVdispFall ();
2632: if (!XEiJ.PNL_USE_THREAD) {
2633: if (crtDirtyY0 >= 0) {
2634: crtUpdateScreen ();
2635: if (CRT_ENABLE_INTERMITTENT) {
2636: crtIntermittentCounter = crtIntermittentInterval;
2637: }
2638: }
2639: }
2640: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2641: crtDoFrameTask ();
2642: }
2643: if (XEiJ.PNL_USE_THREAD) {
2644: if (FlashingLights.FLR_ON &&
2645: FlashingLights.flrActive) {
2646: FlashingLights.flrVsync ();
2647: }
2648: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2649: }
2650: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2651: }
2652: } else {
2653:
2654: if (crtBeginningAllStamp != crtAllStamp) {
2655: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2656: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2657: crtStereoscopicDrawRaster (crtScreenY);
2658: }
2659: }
2660: crtScreenY++;
2661: crtDataY++;
2662: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2663: }
2664: }
2665: };
2666:
2667: public static final TickerQueue.Ticker DuplicationDrawDispOddFront = new TickerQueue.Ticker () {
2668: @Override protected void tick () {
2669: int n = ++crtRasterNumber;
2670: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2671: if (crtRasterCopyOn) {
2672: crtDoRasterCopy ();
2673: }
2674: if (RasterBreakPoint.RBP_ON) {
2675: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2676: RasterBreakPoint.rbpFire ();
2677: }
2678: }
2679: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2680: if (irq != MC68901.mfpGpipRint) {
2681: if (irq == 0) {
2682: if (RasterBreakPoint.RBP_ON) {
2683: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2684: RasterBreakPoint.rbpFire ();
2685: }
2686: }
2687: MC68901.mfpRintFall ();
2688: } else {
2689: MC68901.mfpRintRise ();
2690: }
2691: }
2692: if (n != crtVIdleStart) {
2693: if (crtBeginningAllStamp != crtAllStamp) {
2694: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2695: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2696: crtStereoscopicDrawRaster (crtScreenY);
2697: }
2698: }
2699: crtScreenY++;
2700: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);
2701: } else {
2702: if (crtBeginningAllStamp != crtAllStamp) {
2703: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2704: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2705: crtStereoscopicDrawRaster (crtScreenY);
2706: }
2707: }
2708: MC68901.mfpVdispFall ();
2709: if (!XEiJ.PNL_USE_THREAD) {
2710: if (crtDirtyY0 >= 0) {
2711: crtUpdateScreen ();
2712: if (CRT_ENABLE_INTERMITTENT) {
2713: crtIntermittentCounter = crtIntermittentInterval;
2714: }
2715: }
2716: }
2717: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2718: crtDoFrameTask ();
2719: }
2720: if (XEiJ.PNL_USE_THREAD) {
2721: if (FlashingLights.FLR_ON &&
2722: FlashingLights.flrActive) {
2723: FlashingLights.flrVsync ();
2724: }
2725: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2726: }
2727: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2728: }
2729: } else {
2730:
2731: if (crtBeginningAllStamp != crtAllStamp) {
2732: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2733: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2734: crtStereoscopicDrawRaster (crtScreenY);
2735: }
2736: }
2737: crtScreenY++;
2738: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);
2739: }
2740: }
2741: };
2742:
2743: public static final TickerQueue.Ticker DuplicationDrawDispEvenSync = new TickerQueue.Ticker () {
2744: @Override protected void tick () {
2745: MC68901.mfpHsyncRise ();
2746: if (crtClearFrames != 0) {
2747: crtRapidClear (crtDataY);
2748: crtRasterStamp[crtDataY] = 0;
2749: }
2750: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenBack, crtClock += crtHSyncLength);
2751: }
2752: };
2753:
2754: public static final TickerQueue.Ticker DuplicationDrawDispOddSync = new TickerQueue.Ticker () {
2755: @Override protected void tick () {
2756: MC68901.mfpHsyncRise ();
2757: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddBack, crtClock += crtHSyncLength);
2758: }
2759: };
2760:
2761: public static final TickerQueue.Ticker DuplicationDrawDispEvenBack = new TickerQueue.Ticker () {
2762: @Override protected void tick () {
2763: MC68901.mfpHsyncFall ();
2764: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenDisp, crtClock += crtHBackLength);
2765: }
2766: };
2767:
2768: public static final TickerQueue.Ticker DuplicationDrawDispOddBack = new TickerQueue.Ticker () {
2769: @Override protected void tick () {
2770: MC68901.mfpHsyncFall ();
2771: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddDisp, crtClock += crtHBackLength);
2772: }
2773: };
2774:
2775: public static final TickerQueue.Ticker DuplicationDrawDispEvenDisp = new TickerQueue.Ticker () {
2776: @Override protected void tick () {
2777: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2778: crtBeginningAllStamp = crtAllStamp;
2779: if (Malfunction.MLF_ON) {
2780: Malfunction.mlfRaster (crtDataY);
2781: }
2782: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2783: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2784: crtStereoscopicDrawRaster (crtScreenY);
2785: }
2786: if (!XEiJ.PNL_USE_THREAD) {
2787: if (crtDirtyY0 < 0) {
2788: crtDirtyY0 = crtScreenY;
2789: }
2790: crtDirtyY1 = crtScreenY;
2791: }
2792: }
2793: if (SpriteScreen.SPR_THREE_STEPS) {
2794: if (SpriteScreen.sprActive) {
2795:
2796:
2797: SpriteScreen.sprStep1 (crtDataY + 1);
2798: SpriteScreen.sprSwap ();
2799: SpriteScreen.sprStep2 (crtDataY);
2800: }
2801: }
2802: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddFront, crtClock += crtHDispLength);
2803: }
2804: };
2805:
2806: public static final TickerQueue.Ticker DuplicationDrawDispOddDisp = new TickerQueue.Ticker () {
2807: @Override protected void tick () {
2808: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2809: crtRasterStamp[crtDataY] = crtAllStamp;
2810: crtBeginningAllStamp = crtAllStamp;
2811: if (Malfunction.MLF_ON) {
2812: Malfunction.mlfRaster (crtDataY);
2813: }
2814: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2815: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2816: crtStereoscopicDrawRaster (crtScreenY);
2817: }
2818: if (!XEiJ.PNL_USE_THREAD) {
2819: if (crtDirtyY0 < 0) {
2820: crtDirtyY0 = crtScreenY;
2821: }
2822: crtDirtyY1 = crtScreenY;
2823: }
2824: }
2825: if (SpriteScreen.SPR_THREE_STEPS) {
2826: if (SpriteScreen.sprActive) {
2827:
2828:
2829: SpriteScreen.sprStep1 (crtDataY + 1);
2830: SpriteScreen.sprSwap ();
2831: SpriteScreen.sprStep2 (crtDataY + 1);
2832: }
2833: }
2834: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenFront, crtClock += crtHDispLength);
2835: }
2836: };
2837:
2838: public static final TickerQueue.Ticker DuplicationOmitIdleFront = new TickerQueue.Ticker () {
2839: @Override protected void tick () {
2840: int n = ++crtRasterNumber;
2841: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2842: if (crtR04VFrontEndCurr < n) {
2843: n = crtRasterNumber = 0;
2844: }
2845: if (crtRasterCopyOn) {
2846: crtDoRasterCopy ();
2847: }
2848: if (RasterBreakPoint.RBP_ON) {
2849: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2850: RasterBreakPoint.rbpFire ();
2851: }
2852: }
2853: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2854: if (irq != MC68901.mfpGpipRint) {
2855: if (irq == 0) {
2856: if (RasterBreakPoint.RBP_ON) {
2857: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2858: RasterBreakPoint.rbpFire ();
2859: }
2860: }
2861: MC68901.mfpRintFall ();
2862: } else {
2863: MC68901.mfpRintRise ();
2864: }
2865: }
2866: if (n != crtVDispStart) {
2867: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2868: } else {
2869: MC68901.mfpVdispRise ();
2870: crtR11TxYZero = crtR11TxYCurr;
2871: crtR13GrYZero[0] = crtR13GrYCurr[0];
2872: crtR13GrYZero[1] = crtR13GrYCurr[1];
2873: crtR13GrYZero[2] = crtR13GrYCurr[2];
2874: crtR13GrYZero[3] = crtR13GrYCurr[3];
2875: if (crtR11TxYZeroLast != crtR11TxYZero ||
2876: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2877: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2878: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2879: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2880: crtR11TxYZeroLast = crtR11TxYZero;
2881: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2882: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2883: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2884: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2885: crtAllStamp += 2;
2886: }
2887: crtDataY = 0;
2888: if (crtClearFrames != 0) {
2889: crtClearFrames--;
2890: } else if (crtClearStandby) {
2891: crtClearStandby = false;
2892: crtClearFrames = 1;
2893: }
2894: if (XEiJ.PNL_USE_THREAD) {
2895: crtAllStamp += 2;
2896: }
2897: if (SpriteScreen.SPR_THREE_STEPS) {
2898: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2899: if (SpriteScreen.sprActive) {
2900: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2901: SpriteScreen.sprLatched = false;
2902: }
2903: if (!XEiJ.PNL_USE_THREAD) {
2904: crtAllStamp += 2;
2905: }
2906:
2907: SpriteScreen.sprStep1 (0);
2908: SpriteScreen.sprSwap ();
2909:
2910:
2911: SpriteScreen.sprStep1 (0);
2912: SpriteScreen.sprSwap ();
2913: SpriteScreen.sprStep2 (0);
2914: }
2915: }
2916: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2917: crtStereoscopicStart ();
2918: }
2919: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2920: }
2921: } else {
2922:
2923: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2924: }
2925: }
2926: };
2927:
2928: public static final TickerQueue.Ticker DuplicationOmitIdleSync = new TickerQueue.Ticker () {
2929: @Override protected void tick () {
2930: MC68901.mfpHsyncRise ();
2931: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleBackDisp, crtClock += crtHSyncLength);
2932: }
2933: };
2934:
2935: public static final TickerQueue.Ticker DuplicationOmitIdleBackDisp = new TickerQueue.Ticker () {
2936: @Override protected void tick () {
2937: MC68901.mfpHsyncFall ();
2938: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleFront, crtClock += crtHBackDispLength);
2939: }
2940: };
2941:
2942: public static final TickerQueue.Ticker DuplicationOmitDispEvenFront = new TickerQueue.Ticker () {
2943: @Override protected void tick () {
2944: int n = ++crtRasterNumber;
2945: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2946: if (crtRasterCopyOn) {
2947: crtDoRasterCopy ();
2948: }
2949: if (RasterBreakPoint.RBP_ON) {
2950: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2951: RasterBreakPoint.rbpFire ();
2952: }
2953: }
2954: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2955: if (irq != MC68901.mfpGpipRint) {
2956: if (irq == 0) {
2957: if (RasterBreakPoint.RBP_ON) {
2958: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2959: RasterBreakPoint.rbpFire ();
2960: }
2961: }
2962: MC68901.mfpRintFall ();
2963: } else {
2964: MC68901.mfpRintRise ();
2965: }
2966: }
2967: if (n != crtVIdleStart) {
2968: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2969: } else {
2970: MC68901.mfpVdispFall ();
2971: if (CRT_ENABLE_INTERMITTENT) {
2972: crtIntermittentCounter--;
2973: }
2974: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2975: crtDoFrameTask ();
2976: }
2977: if (XEiJ.PNL_USE_THREAD) {
2978: if (FlashingLights.FLR_ON &&
2979: FlashingLights.flrActive) {
2980: FlashingLights.flrVsync ();
2981: }
2982: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2983: }
2984: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2985: }
2986: } else {
2987:
2988: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2989: }
2990: }
2991: };
2992:
2993: public static final TickerQueue.Ticker DuplicationOmitDispOddFront = new TickerQueue.Ticker () {
2994: @Override protected void tick () {
2995: int n = ++crtRasterNumber;
2996: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2997: if (crtRasterCopyOn) {
2998: crtDoRasterCopy ();
2999: }
3000: if (RasterBreakPoint.RBP_ON) {
3001: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3002: RasterBreakPoint.rbpFire ();
3003: }
3004: }
3005: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3006: if (irq != MC68901.mfpGpipRint) {
3007: if (irq == 0) {
3008: if (RasterBreakPoint.RBP_ON) {
3009: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3010: RasterBreakPoint.rbpFire ();
3011: }
3012: }
3013: MC68901.mfpRintFall ();
3014: } else {
3015: MC68901.mfpRintRise ();
3016: }
3017: }
3018: if (n != crtVIdleStart) {
3019: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);
3020: } else {
3021: MC68901.mfpVdispFall ();
3022: if (CRT_ENABLE_INTERMITTENT) {
3023: crtIntermittentCounter--;
3024: }
3025: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3026: crtDoFrameTask ();
3027: }
3028: if (XEiJ.PNL_USE_THREAD) {
3029: if (FlashingLights.FLR_ON &&
3030: FlashingLights.flrActive) {
3031: FlashingLights.flrVsync ();
3032: }
3033: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3034: }
3035: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
3036: }
3037: } else {
3038:
3039: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);
3040: }
3041: }
3042: };
3043:
3044: public static final TickerQueue.Ticker DuplicationOmitDispEvenSync = new TickerQueue.Ticker () {
3045: @Override protected void tick () {
3046: MC68901.mfpHsyncRise ();
3047: if (crtClearFrames != 0) {
3048: crtRapidClear (crtDataY);
3049: crtRasterStamp[crtDataY] = 0;
3050: }
3051: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenBackDisp, crtClock += crtHSyncLength);
3052: }
3053: };
3054:
3055: public static final TickerQueue.Ticker DuplicationOmitDispOddSync = new TickerQueue.Ticker () {
3056: @Override protected void tick () {
3057: MC68901.mfpHsyncRise ();
3058: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddBackDisp, crtClock += crtHSyncLength);
3059: }
3060: };
3061:
3062: public static final TickerQueue.Ticker DuplicationOmitDispEvenBackDisp = new TickerQueue.Ticker () {
3063: @Override protected void tick () {
3064: MC68901.mfpHsyncFall ();
3065: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddFront, crtClock += crtHBackDispLength);
3066: }
3067: };
3068:
3069: public static final TickerQueue.Ticker DuplicationOmitDispOddBackDisp = new TickerQueue.Ticker () {
3070: @Override protected void tick () {
3071: MC68901.mfpHsyncFall ();
3072: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenFront, crtClock += crtHBackDispLength);
3073: }
3074: };
3075:
3076:
3077:
3078:
3079: public static final TickerQueue.Ticker InterlaceStart = new TickerQueue.Ticker () {
3080: @Override protected void tick () {
3081: if (MC68901.mfpGpipHsync != 0) {
3082: MC68901.mfpHsyncFall ();
3083: }
3084: int n = crtRasterNumber = crtVIdleStart;
3085: if (crtRasterCopyOn) {
3086: crtDoRasterCopy ();
3087: }
3088: if (RasterBreakPoint.RBP_ON) {
3089: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3090: RasterBreakPoint.rbpFire ();
3091: }
3092: }
3093: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3094: if (irq != MC68901.mfpGpipRint) {
3095: if (irq == 0) {
3096: if (RasterBreakPoint.RBP_ON) {
3097: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3098: RasterBreakPoint.rbpFire ();
3099: }
3100: }
3101: MC68901.mfpRintFall ();
3102: } else {
3103: MC68901.mfpRintRise ();
3104: }
3105: }
3106: if (MC68901.mfpGpipVdisp != 0) {
3107: MC68901.mfpVdispFall ();
3108: }
3109: crtFrameParity = 0;
3110: crtClearFrames = 0;
3111: if (CRT_ENABLE_INTERMITTENT) {
3112: crtIntermittentCounter = 0;
3113: }
3114: if (!XEiJ.PNL_USE_THREAD) {
3115: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3116: crtDoFrameTask ();
3117: }
3118: }
3119: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3120: }
3121: };
3122:
3123: public static final TickerQueue.Ticker InterlaceDrawIdleFront = new TickerQueue.Ticker () {
3124: @Override protected void tick () {
3125: int n = ++crtRasterNumber;
3126: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3127: if (crtR04VFrontEndCurr < n) {
3128: n = crtRasterNumber = 0;
3129: }
3130: if (crtRasterCopyOn) {
3131: crtDoRasterCopy ();
3132: }
3133: if (RasterBreakPoint.RBP_ON) {
3134: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3135: RasterBreakPoint.rbpFire ();
3136: }
3137: }
3138: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3139: if (irq != MC68901.mfpGpipRint) {
3140: if (irq == 0) {
3141: if (RasterBreakPoint.RBP_ON) {
3142: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3143: RasterBreakPoint.rbpFire ();
3144: }
3145: }
3146: MC68901.mfpRintFall ();
3147: } else {
3148: MC68901.mfpRintRise ();
3149: }
3150: }
3151: if (n != crtVDispStart) {
3152: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3153: } else {
3154: MC68901.mfpVdispRise ();
3155: crtR11TxYZero = crtR11TxYCurr;
3156: crtR13GrYZero[0] = crtR13GrYCurr[0];
3157: crtR13GrYZero[1] = crtR13GrYCurr[1];
3158: crtR13GrYZero[2] = crtR13GrYCurr[2];
3159: crtR13GrYZero[3] = crtR13GrYCurr[3];
3160: if (crtR11TxYZeroLast != crtR11TxYZero ||
3161: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3162: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3163: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3164: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3165: crtR11TxYZeroLast = crtR11TxYZero;
3166: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3167: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3168: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3169: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3170: crtAllStamp += 2;
3171: }
3172: crtDataY = crtFrameParity;
3173: if (crtClearFrames != 0) {
3174: crtClearFrames--;
3175: } else if (crtClearStandby &&
3176: crtFrameParity == 0) {
3177: crtClearStandby = false;
3178: crtClearFrames = 2;
3179: }
3180: crtScreenY = crtFrameParity;
3181: if (!XEiJ.PNL_USE_THREAD) {
3182: crtDirtyY0 = -1;
3183: }
3184: if (XEiJ.PNL_USE_THREAD) {
3185: crtAllStamp += 2;
3186: }
3187: if (SpriteScreen.SPR_THREE_STEPS) {
3188: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3189: if (SpriteScreen.sprActive) {
3190: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3191: SpriteScreen.sprLatched = false;
3192: }
3193: if (!XEiJ.PNL_USE_THREAD) {
3194: crtAllStamp += 2;
3195: }
3196:
3197: SpriteScreen.sprStep1 (0);
3198: SpriteScreen.sprSwap ();
3199:
3200:
3201: SpriteScreen.sprStep1 (2);
3202: SpriteScreen.sprSwap ();
3203: SpriteScreen.sprStep2 (0);
3204: }
3205: }
3206: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3207: crtStereoscopicStart ();
3208: }
3209: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3210: }
3211: } else {
3212:
3213: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3214: }
3215: }
3216: };
3217:
3218: public static final TickerQueue.Ticker InterlaceDrawIdleSync = new TickerQueue.Ticker () {
3219: @Override protected void tick () {
3220: MC68901.mfpHsyncRise ();
3221: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleBackDisp, crtClock += crtHSyncLength);
3222: }
3223: };
3224:
3225: public static final TickerQueue.Ticker InterlaceDrawIdleBackDisp = new TickerQueue.Ticker () {
3226: @Override protected void tick () {
3227: MC68901.mfpHsyncFall ();
3228: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleFront, crtClock += crtHBackDispLength);
3229: }
3230: };
3231:
3232: public static final TickerQueue.Ticker InterlaceDrawDispFront = new TickerQueue.Ticker () {
3233: @Override protected void tick () {
3234: int n = ++crtRasterNumber;
3235: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3236: if (crtRasterCopyOn) {
3237: crtDoRasterCopy ();
3238: }
3239: if (RasterBreakPoint.RBP_ON) {
3240: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3241: RasterBreakPoint.rbpFire ();
3242: }
3243: }
3244: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3245: if (irq != MC68901.mfpGpipRint) {
3246: if (irq == 0) {
3247: if (RasterBreakPoint.RBP_ON) {
3248: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3249: RasterBreakPoint.rbpFire ();
3250: }
3251: }
3252: MC68901.mfpRintFall ();
3253: } else {
3254: MC68901.mfpRintRise ();
3255: }
3256: }
3257: if (n != crtVIdleStart) {
3258: if (crtBeginningAllStamp != crtAllStamp) {
3259: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3260: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3261: crtStereoscopicDrawRaster (crtScreenY);
3262: if (XEiJ.PNL_USE_THREAD) {
3263: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3264: }
3265: }
3266: }
3267: crtScreenY += 2;
3268: crtDataY += 2;
3269: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3270: } else {
3271: if (crtBeginningAllStamp != crtAllStamp) {
3272: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3273: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3274: crtStereoscopicDrawRaster (crtScreenY);
3275: if (XEiJ.PNL_USE_THREAD) {
3276: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3277: }
3278: }
3279: }
3280: MC68901.mfpVdispFall ();
3281: if (!XEiJ.PNL_USE_THREAD) {
3282: if (crtDirtyY0 >= 0) {
3283: crtUpdateScreen ();
3284: if (CRT_ENABLE_INTERMITTENT) {
3285: crtIntermittentCounter = crtIntermittentInterval;
3286: }
3287: }
3288: }
3289: crtFrameParity ^= 1;
3290: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3291: crtDoFrameTask ();
3292: }
3293: if (XEiJ.PNL_USE_THREAD) {
3294: if (FlashingLights.FLR_ON &&
3295: FlashingLights.flrActive) {
3296: FlashingLights.flrVsync ();
3297: }
3298: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3299: }
3300: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3301: }
3302: } else {
3303:
3304: if (crtBeginningAllStamp != crtAllStamp) {
3305: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3306: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3307: crtStereoscopicDrawRaster (crtScreenY);
3308: if (XEiJ.PNL_USE_THREAD) {
3309: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3310: }
3311: }
3312: }
3313: crtScreenY += 2;
3314: crtDataY += 2;
3315: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3316: }
3317: }
3318: };
3319:
3320: public static final TickerQueue.Ticker InterlaceDrawDispSync = new TickerQueue.Ticker () {
3321: @Override protected void tick () {
3322: MC68901.mfpHsyncRise ();
3323: if (crtClearFrames != 0) {
3324: crtRapidClear (crtDataY);
3325: crtRasterStamp[crtDataY] = 0;
3326: }
3327: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispBack, crtClock += crtHSyncLength);
3328: }
3329: };
3330:
3331: public static final TickerQueue.Ticker InterlaceDrawDispBack = new TickerQueue.Ticker () {
3332: @Override protected void tick () {
3333: MC68901.mfpHsyncFall ();
3334: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispDisp, crtClock += crtHBackLength);
3335: }
3336: };
3337:
3338: public static final TickerQueue.Ticker InterlaceDrawDispDisp = new TickerQueue.Ticker () {
3339: @Override protected void tick () {
3340: if (crtRasterStamp[crtDataY] != crtAllStamp) {
3341: crtRasterStamp[crtDataY] = crtAllStamp;
3342: crtBeginningAllStamp = crtAllStamp;
3343: if (Malfunction.MLF_ON) {
3344: Malfunction.mlfRaster (crtDataY);
3345: }
3346: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
3347: if (XEiJ.PNL_USE_THREAD) {
3348: int[] prevBM = XEiJ.pnlBMLeftArray[(XEiJ.pnlBMWrite - 1) & 3];
3349: int da = (crtScreenY ^ 1) << XEiJ.PNL_BM_OFFSET_BITS;
3350: System.arraycopy (prevBM, da,
3351: XEiJ.pnlBM, da,
3352: XEiJ.pnlScreenWidth);
3353: }
3354: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3355: crtStereoscopicDrawRaster (crtScreenY);
3356: if (XEiJ.PNL_USE_THREAD) {
3357: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3358: }
3359: }
3360: if (!XEiJ.PNL_USE_THREAD) {
3361: if (crtDirtyY0 < 0) {
3362: crtDirtyY0 = crtScreenY;
3363: }
3364: crtDirtyY1 = crtScreenY;
3365: }
3366: }
3367: if (SpriteScreen.SPR_THREE_STEPS) {
3368: if (SpriteScreen.sprActive) {
3369:
3370:
3371: SpriteScreen.sprStep1 (crtDataY + 4);
3372: SpriteScreen.sprSwap ();
3373: SpriteScreen.sprStep2 (crtDataY + 2);
3374: }
3375: }
3376: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispFront, crtClock += crtHDispLength);
3377: }
3378: };
3379:
3380: public static final TickerQueue.Ticker InterlaceOmitIdleFront = new TickerQueue.Ticker () {
3381: @Override protected void tick () {
3382: int n = ++crtRasterNumber;
3383: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3384: if (crtR04VFrontEndCurr < n) {
3385: n = crtRasterNumber = 0;
3386: }
3387: if (crtRasterCopyOn) {
3388: crtDoRasterCopy ();
3389: }
3390: if (RasterBreakPoint.RBP_ON) {
3391: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3392: RasterBreakPoint.rbpFire ();
3393: }
3394: }
3395: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3396: if (irq != MC68901.mfpGpipRint) {
3397: if (irq == 0) {
3398: if (RasterBreakPoint.RBP_ON) {
3399: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3400: RasterBreakPoint.rbpFire ();
3401: }
3402: }
3403: MC68901.mfpRintFall ();
3404: } else {
3405: MC68901.mfpRintRise ();
3406: }
3407: }
3408: if (n != crtVDispStart) {
3409: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3410: } else {
3411: MC68901.mfpVdispRise ();
3412: crtR11TxYZero = crtR11TxYCurr;
3413: crtR13GrYZero[0] = crtR13GrYCurr[0];
3414: crtR13GrYZero[1] = crtR13GrYCurr[1];
3415: crtR13GrYZero[2] = crtR13GrYCurr[2];
3416: crtR13GrYZero[3] = crtR13GrYCurr[3];
3417: if (crtR11TxYZeroLast != crtR11TxYZero ||
3418: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3419: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3420: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3421: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3422: crtR11TxYZeroLast = crtR11TxYZero;
3423: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3424: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3425: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3426: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3427: crtAllStamp += 2;
3428: }
3429: crtDataY = crtFrameParity;
3430: if (crtClearFrames != 0) {
3431: crtClearFrames--;
3432: } else if (crtClearStandby &&
3433: crtFrameParity == 0) {
3434: crtClearStandby = false;
3435: crtClearFrames = 2;
3436: }
3437: if (XEiJ.PNL_USE_THREAD) {
3438: crtAllStamp += 2;
3439: }
3440: if (SpriteScreen.SPR_THREE_STEPS) {
3441: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3442: if (SpriteScreen.sprActive) {
3443: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3444: SpriteScreen.sprLatched = false;
3445: }
3446: if (!XEiJ.PNL_USE_THREAD) {
3447: crtAllStamp += 2;
3448: }
3449:
3450: SpriteScreen.sprStep1 (0);
3451: SpriteScreen.sprSwap ();
3452:
3453:
3454: SpriteScreen.sprStep1 (2);
3455: SpriteScreen.sprSwap ();
3456: SpriteScreen.sprStep2 (0);
3457: }
3458: }
3459: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3460: crtStereoscopicStart ();
3461: }
3462: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3463: }
3464: } else {
3465:
3466: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3467: }
3468: }
3469: };
3470:
3471: public static final TickerQueue.Ticker InterlaceOmitIdleSync = new TickerQueue.Ticker () {
3472: @Override protected void tick () {
3473: MC68901.mfpHsyncRise ();
3474: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleBackDisp, crtClock += crtHSyncLength);
3475: }
3476: };
3477:
3478: public static final TickerQueue.Ticker InterlaceOmitIdleBackDisp = new TickerQueue.Ticker () {
3479: @Override protected void tick () {
3480: MC68901.mfpHsyncFall ();
3481: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleFront, crtClock += crtHBackDispLength);
3482: }
3483: };
3484:
3485: public static final TickerQueue.Ticker InterlaceOmitDispFront = new TickerQueue.Ticker () {
3486: @Override protected void tick () {
3487: int n = ++crtRasterNumber;
3488: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3489: if (crtRasterCopyOn) {
3490: crtDoRasterCopy ();
3491: }
3492: if (RasterBreakPoint.RBP_ON) {
3493: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3494: RasterBreakPoint.rbpFire ();
3495: }
3496: }
3497: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3498: if (irq != MC68901.mfpGpipRint) {
3499: if (irq == 0) {
3500: if (RasterBreakPoint.RBP_ON) {
3501: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3502: RasterBreakPoint.rbpFire ();
3503: }
3504: }
3505: MC68901.mfpRintFall ();
3506: } else {
3507: MC68901.mfpRintRise ();
3508: }
3509: }
3510: if (n != crtVIdleStart) {
3511: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3512: } else {
3513: MC68901.mfpVdispFall ();
3514: if (CRT_ENABLE_INTERMITTENT) {
3515: crtIntermittentCounter--;
3516: }
3517: crtFrameParity ^= 1;
3518: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3519: crtDoFrameTask ();
3520: }
3521: if (XEiJ.PNL_USE_THREAD) {
3522: if (FlashingLights.FLR_ON &&
3523: FlashingLights.flrActive) {
3524: FlashingLights.flrVsync ();
3525: }
3526: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3527: }
3528: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3529: }
3530: } else {
3531:
3532: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3533: }
3534: }
3535: };
3536:
3537: public static final TickerQueue.Ticker InterlaceOmitDispSync = new TickerQueue.Ticker () {
3538: @Override protected void tick () {
3539: MC68901.mfpHsyncRise ();
3540: if (crtClearFrames != 0) {
3541: crtRapidClear (crtDataY);
3542: crtRasterStamp[crtDataY] = 0;
3543: }
3544: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispBackDisp, crtClock += crtHSyncLength);
3545: }
3546: };
3547:
3548: public static final TickerQueue.Ticker InterlaceOmitDispBackDisp = new TickerQueue.Ticker () {
3549: @Override protected void tick () {
3550: MC68901.mfpHsyncFall ();
3551: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispFront, crtClock += crtHBackDispLength);
3552: }
3553: };
3554:
3555:
3556:
3557:
3558: public static final TickerQueue.Ticker SlitStart = new TickerQueue.Ticker () {
3559: @Override protected void tick () {
3560: if (MC68901.mfpGpipHsync != 0) {
3561: MC68901.mfpHsyncFall ();
3562: }
3563: int n = crtRasterNumber = crtVIdleStart;
3564: if (crtRasterCopyOn) {
3565: crtDoRasterCopy ();
3566: }
3567: if (RasterBreakPoint.RBP_ON) {
3568: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3569: RasterBreakPoint.rbpFire ();
3570: }
3571: }
3572: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3573: if (irq != MC68901.mfpGpipRint) {
3574: if (irq == 0) {
3575: if (RasterBreakPoint.RBP_ON) {
3576: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3577: RasterBreakPoint.rbpFire ();
3578: }
3579: }
3580: MC68901.mfpRintFall ();
3581: } else {
3582: MC68901.mfpRintRise ();
3583: }
3584: }
3585: if (MC68901.mfpGpipVdisp != 0) {
3586: MC68901.mfpVdispFall ();
3587: }
3588: crtClearFrames = 0;
3589: if (CRT_ENABLE_INTERMITTENT) {
3590: crtIntermittentCounter = 0;
3591: }
3592: if (!XEiJ.PNL_USE_THREAD) {
3593: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3594: crtDoFrameTask ();
3595: }
3596: }
3597: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3598: }
3599: };
3600:
3601: public static final TickerQueue.Ticker SlitDrawIdleFront = new TickerQueue.Ticker () {
3602: @Override protected void tick () {
3603: int n = ++crtRasterNumber;
3604: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3605: if (crtR04VFrontEndCurr < n) {
3606: n = crtRasterNumber = 0;
3607: }
3608: if (crtRasterCopyOn) {
3609: crtDoRasterCopy ();
3610: }
3611: if (RasterBreakPoint.RBP_ON) {
3612: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3613: RasterBreakPoint.rbpFire ();
3614: }
3615: }
3616: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3617: if (irq != MC68901.mfpGpipRint) {
3618: if (irq == 0) {
3619: if (RasterBreakPoint.RBP_ON) {
3620: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3621: RasterBreakPoint.rbpFire ();
3622: }
3623: }
3624: MC68901.mfpRintFall ();
3625: } else {
3626: MC68901.mfpRintRise ();
3627: }
3628: }
3629: if (n != crtVDispStart) {
3630: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3631: } else {
3632: MC68901.mfpVdispRise ();
3633: crtR11TxYZero = crtR11TxYCurr;
3634: crtR13GrYZero[0] = crtR13GrYCurr[0];
3635: crtR13GrYZero[1] = crtR13GrYCurr[1];
3636: crtR13GrYZero[2] = crtR13GrYCurr[2];
3637: crtR13GrYZero[3] = crtR13GrYCurr[3];
3638: if (crtR11TxYZeroLast != crtR11TxYZero ||
3639: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3640: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3641: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3642: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3643: crtR11TxYZeroLast = crtR11TxYZero;
3644: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3645: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3646: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3647: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3648: crtAllStamp += 2;
3649: }
3650: crtDataY = 0;
3651: if (crtClearFrames != 0) {
3652: crtClearFrames--;
3653: } else if (crtClearStandby) {
3654: crtClearStandby = false;
3655: crtClearFrames = 1;
3656: }
3657: crtScreenY = 0;
3658: if (!XEiJ.PNL_USE_THREAD) {
3659: crtDirtyY0 = -1;
3660: }
3661: if (XEiJ.PNL_USE_THREAD) {
3662: crtAllStamp += 2;
3663: }
3664: if (SpriteScreen.SPR_THREE_STEPS) {
3665: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3666: if (SpriteScreen.sprActive) {
3667: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3668: SpriteScreen.sprLatched = false;
3669: }
3670: if (!XEiJ.PNL_USE_THREAD) {
3671: crtAllStamp += 2;
3672: }
3673:
3674: SpriteScreen.sprStep1 (0);
3675: SpriteScreen.sprSwap ();
3676:
3677:
3678: SpriteScreen.sprStep1 (1);
3679: SpriteScreen.sprSwap ();
3680: SpriteScreen.sprStep2 (0);
3681: }
3682: }
3683: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3684: crtStereoscopicStart ();
3685: }
3686: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3687: }
3688: } else {
3689:
3690: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3691: }
3692: }
3693: };
3694:
3695: public static final TickerQueue.Ticker SlitDrawIdleSync = new TickerQueue.Ticker () {
3696: @Override protected void tick () {
3697: MC68901.mfpHsyncRise ();
3698: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleBackDisp, crtClock += crtHSyncLength);
3699: }
3700: };
3701:
3702: public static final TickerQueue.Ticker SlitDrawIdleBackDisp = new TickerQueue.Ticker () {
3703: @Override protected void tick () {
3704: MC68901.mfpHsyncFall ();
3705: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleFront, crtClock += crtHBackDispLength);
3706: }
3707: };
3708:
3709: public static final TickerQueue.Ticker SlitDrawDispFront = new TickerQueue.Ticker () {
3710: @Override protected void tick () {
3711: int n = ++crtRasterNumber;
3712: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3713: if (crtRasterCopyOn) {
3714: crtDoRasterCopy ();
3715: }
3716: if (RasterBreakPoint.RBP_ON) {
3717: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3718: RasterBreakPoint.rbpFire ();
3719: }
3720: }
3721: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3722: if (irq != MC68901.mfpGpipRint) {
3723: if (irq == 0) {
3724: if (RasterBreakPoint.RBP_ON) {
3725: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3726: RasterBreakPoint.rbpFire ();
3727: }
3728: }
3729: MC68901.mfpRintFall ();
3730: } else {
3731: MC68901.mfpRintRise ();
3732: }
3733: }
3734: if (n != crtVIdleStart) {
3735: if (crtBeginningAllStamp != crtAllStamp) {
3736: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3737: crtScanlineEffect.drawRaster (crtScreenY + 1);
3738: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3739: crtStereoscopicDrawRaster (crtScreenY);
3740: crtStereoscopicDrawRaster (crtScreenY + 1);
3741: }
3742: }
3743: crtScreenY += 2;
3744: crtDataY++;
3745: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3746: } else {
3747: if (crtBeginningAllStamp != crtAllStamp) {
3748: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3749: crtScanlineEffect.drawRaster (crtScreenY + 1);
3750: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3751: crtStereoscopicDrawRaster (crtScreenY);
3752: crtStereoscopicDrawRaster (crtScreenY + 1);
3753: }
3754: }
3755: MC68901.mfpVdispFall ();
3756: if (!XEiJ.PNL_USE_THREAD) {
3757: if (crtDirtyY0 >= 0) {
3758: crtUpdateScreen ();
3759: if (CRT_ENABLE_INTERMITTENT) {
3760: crtIntermittentCounter = crtIntermittentInterval;
3761: }
3762: }
3763: }
3764: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3765: crtDoFrameTask ();
3766: }
3767: if (XEiJ.PNL_USE_THREAD) {
3768: if (FlashingLights.FLR_ON &&
3769: FlashingLights.flrActive) {
3770: FlashingLights.flrVsync ();
3771: }
3772: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3773: }
3774: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3775: }
3776: } else {
3777:
3778: if (crtBeginningAllStamp != crtAllStamp) {
3779: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3780: crtScanlineEffect.drawRaster (crtScreenY + 1);
3781: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3782: crtStereoscopicDrawRaster (crtScreenY);
3783: crtStereoscopicDrawRaster (crtScreenY + 1);
3784: }
3785: }
3786: crtScreenY += 2;
3787: crtDataY++;
3788: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3789: }
3790: }
3791: };
3792:
3793: public static final TickerQueue.Ticker SlitDrawDispSync = new TickerQueue.Ticker () {
3794: @Override protected void tick () {
3795: MC68901.mfpHsyncRise ();
3796: if (crtClearFrames != 0) {
3797: crtRapidClear (crtDataY);
3798: crtRasterStamp[crtDataY] = 0;
3799: }
3800: TickerQueue.tkqAdd (crtTicker = SlitDrawDispBack, crtClock += crtHSyncLength);
3801: }
3802: };
3803:
3804: public static final TickerQueue.Ticker SlitDrawDispBack = new TickerQueue.Ticker () {
3805: @Override protected void tick () {
3806: MC68901.mfpHsyncFall ();
3807: TickerQueue.tkqAdd (crtTicker = SlitDrawDispDisp, crtClock += crtHBackLength);
3808: }
3809: };
3810:
3811: public static final TickerQueue.Ticker SlitDrawDispDisp = new TickerQueue.Ticker () {
3812: @Override protected void tick () {
3813: if (crtRasterStamp[crtDataY] != crtAllStamp) {
3814: crtRasterStamp[crtDataY] = crtAllStamp;
3815: crtBeginningAllStamp = crtAllStamp;
3816: if (Malfunction.MLF_ON) {
3817: Malfunction.mlfRaster (crtDataY);
3818: }
3819: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
3820: crtScanlineEffect.drawRaster (crtScreenY + 1);
3821: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3822: crtStereoscopicDrawRaster (crtScreenY);
3823: crtStereoscopicDrawRaster (crtScreenY + 1);
3824: }
3825: if (!XEiJ.PNL_USE_THREAD) {
3826: if (crtDirtyY0 < 0) {
3827: crtDirtyY0 = crtScreenY;
3828: }
3829: crtDirtyY1 = crtScreenY + 1;
3830: }
3831: }
3832: if (SpriteScreen.SPR_THREE_STEPS) {
3833: if (SpriteScreen.sprActive) {
3834:
3835:
3836: SpriteScreen.sprStep1 (crtDataY + 2);
3837: SpriteScreen.sprSwap ();
3838: SpriteScreen.sprStep2 (crtDataY + 1);
3839: }
3840: }
3841: TickerQueue.tkqAdd (crtTicker = SlitDrawDispFront, crtClock += crtHDispLength);
3842: }
3843: };
3844:
3845: public static final TickerQueue.Ticker SlitOmitIdleFront = new TickerQueue.Ticker () {
3846: @Override protected void tick () {
3847: int n = ++crtRasterNumber;
3848: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3849: if (crtR04VFrontEndCurr < n) {
3850: n = crtRasterNumber = 0;
3851: }
3852: if (crtRasterCopyOn) {
3853: crtDoRasterCopy ();
3854: }
3855: if (RasterBreakPoint.RBP_ON) {
3856: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3857: RasterBreakPoint.rbpFire ();
3858: }
3859: }
3860: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3861: if (irq != MC68901.mfpGpipRint) {
3862: if (irq == 0) {
3863: if (RasterBreakPoint.RBP_ON) {
3864: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3865: RasterBreakPoint.rbpFire ();
3866: }
3867: }
3868: MC68901.mfpRintFall ();
3869: } else {
3870: MC68901.mfpRintRise ();
3871: }
3872: }
3873: if (n != crtVDispStart) {
3874: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3875: } else {
3876: MC68901.mfpVdispRise ();
3877: crtR11TxYZero = crtR11TxYCurr;
3878: crtR13GrYZero[0] = crtR13GrYCurr[0];
3879: crtR13GrYZero[1] = crtR13GrYCurr[1];
3880: crtR13GrYZero[2] = crtR13GrYCurr[2];
3881: crtR13GrYZero[3] = crtR13GrYCurr[3];
3882: if (crtR11TxYZeroLast != crtR11TxYZero ||
3883: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3884: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3885: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3886: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3887: crtR11TxYZeroLast = crtR11TxYZero;
3888: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3889: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3890: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3891: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3892: crtAllStamp += 2;
3893: }
3894: crtDataY = 0;
3895: if (crtClearFrames != 0) {
3896: crtClearFrames--;
3897: } else if (crtClearStandby) {
3898: crtClearStandby = false;
3899: crtClearFrames = 1;
3900: }
3901: if (XEiJ.PNL_USE_THREAD) {
3902: crtAllStamp += 2;
3903: }
3904: if (SpriteScreen.SPR_THREE_STEPS) {
3905: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3906: if (SpriteScreen.sprActive) {
3907: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3908: SpriteScreen.sprLatched = false;
3909: }
3910: if (!XEiJ.PNL_USE_THREAD) {
3911: crtAllStamp += 2;
3912: }
3913:
3914: SpriteScreen.sprStep1 (0);
3915: SpriteScreen.sprSwap ();
3916:
3917:
3918: SpriteScreen.sprStep1 (1);
3919: SpriteScreen.sprSwap ();
3920: SpriteScreen.sprStep2 (0);
3921: }
3922: }
3923: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3924: crtStereoscopicStart ();
3925: }
3926: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3927: }
3928: } else {
3929:
3930: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3931: }
3932: }
3933: };
3934:
3935: public static final TickerQueue.Ticker SlitOmitIdleSync = new TickerQueue.Ticker () {
3936: @Override protected void tick () {
3937: MC68901.mfpHsyncRise ();
3938: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleBackDisp, crtClock += crtHSyncLength);
3939: }
3940: };
3941:
3942: public static final TickerQueue.Ticker SlitOmitIdleBackDisp = new TickerQueue.Ticker () {
3943: @Override protected void tick () {
3944: MC68901.mfpHsyncFall ();
3945: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleFront, crtClock += crtHBackDispLength);
3946: }
3947: };
3948:
3949: public static final TickerQueue.Ticker SlitOmitDispFront = new TickerQueue.Ticker () {
3950: @Override protected void tick () {
3951: int n = ++crtRasterNumber;
3952: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3953: if (crtRasterCopyOn) {
3954: crtDoRasterCopy ();
3955: }
3956: if (RasterBreakPoint.RBP_ON) {
3957: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3958: RasterBreakPoint.rbpFire ();
3959: }
3960: }
3961: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3962: if (irq != MC68901.mfpGpipRint) {
3963: if (irq == 0) {
3964: if (RasterBreakPoint.RBP_ON) {
3965: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3966: RasterBreakPoint.rbpFire ();
3967: }
3968: }
3969: MC68901.mfpRintFall ();
3970: } else {
3971: MC68901.mfpRintRise ();
3972: }
3973: }
3974: if (n != crtVIdleStart) {
3975: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3976: } else {
3977: MC68901.mfpVdispFall ();
3978: if (CRT_ENABLE_INTERMITTENT) {
3979: crtIntermittentCounter--;
3980: }
3981: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3982: crtDoFrameTask ();
3983: }
3984: if (XEiJ.PNL_USE_THREAD) {
3985: if (FlashingLights.FLR_ON &&
3986: FlashingLights.flrActive) {
3987: FlashingLights.flrVsync ();
3988: }
3989: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3990: }
3991: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3992: }
3993: } else {
3994:
3995: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3996: }
3997: }
3998: };
3999:
4000: public static final TickerQueue.Ticker SlitOmitDispSync = new TickerQueue.Ticker () {
4001: @Override protected void tick () {
4002: MC68901.mfpHsyncRise ();
4003: if (crtClearFrames != 0) {
4004: crtRapidClear (crtDataY);
4005: crtRasterStamp[crtDataY] = 0;
4006: }
4007: TickerQueue.tkqAdd (crtTicker = SlitOmitDispBackDisp, crtClock += crtHSyncLength);
4008: }
4009: };
4010:
4011: public static final TickerQueue.Ticker SlitOmitDispBackDisp = new TickerQueue.Ticker () {
4012: @Override protected void tick () {
4013: MC68901.mfpHsyncFall ();
4014: TickerQueue.tkqAdd (crtTicker = SlitOmitDispFront, crtClock += crtHBackDispLength);
4015: }
4016: };
4017:
4018:
4019:
4020:
4021: public static final TickerQueue.Ticker DupExceptSpStart = new TickerQueue.Ticker () {
4022: @Override protected void tick () {
4023: if (MC68901.mfpGpipHsync != 0) {
4024: MC68901.mfpHsyncFall ();
4025: }
4026: int n = crtRasterNumber = crtVIdleStart;
4027: if (crtRasterCopyOn) {
4028: crtDoRasterCopy ();
4029: }
4030: if (RasterBreakPoint.RBP_ON) {
4031: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4032: RasterBreakPoint.rbpFire ();
4033: }
4034: }
4035: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4036: if (irq != MC68901.mfpGpipRint) {
4037: if (irq == 0) {
4038: if (RasterBreakPoint.RBP_ON) {
4039: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4040: RasterBreakPoint.rbpFire ();
4041: }
4042: }
4043: MC68901.mfpRintFall ();
4044: } else {
4045: MC68901.mfpRintRise ();
4046: }
4047: }
4048: if (MC68901.mfpGpipVdisp != 0) {
4049: MC68901.mfpVdispFall ();
4050: }
4051: crtClearFrames = 0;
4052: if (CRT_ENABLE_INTERMITTENT) {
4053: crtIntermittentCounter = 0;
4054: }
4055: if (!XEiJ.PNL_USE_THREAD) {
4056: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4057: crtDoFrameTask ();
4058: }
4059: }
4060: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4061: }
4062: };
4063:
4064: public static final TickerQueue.Ticker DupExceptSpDrawIdleFront = new TickerQueue.Ticker () {
4065: @Override protected void tick () {
4066: int n = ++crtRasterNumber;
4067: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
4068: if (crtR04VFrontEndCurr < n) {
4069: n = crtRasterNumber = 0;
4070: }
4071: if (crtRasterCopyOn) {
4072: crtDoRasterCopy ();
4073: }
4074: if (RasterBreakPoint.RBP_ON) {
4075: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4076: RasterBreakPoint.rbpFire ();
4077: }
4078: }
4079: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4080: if (irq != MC68901.mfpGpipRint) {
4081: if (irq == 0) {
4082: if (RasterBreakPoint.RBP_ON) {
4083: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4084: RasterBreakPoint.rbpFire ();
4085: }
4086: }
4087: MC68901.mfpRintFall ();
4088: } else {
4089: MC68901.mfpRintRise ();
4090: }
4091: }
4092: if (n != crtVDispStart) {
4093: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4094: } else {
4095: MC68901.mfpVdispRise ();
4096: crtR11TxYZero = crtR11TxYCurr;
4097: crtR13GrYZero[0] = crtR13GrYCurr[0];
4098: crtR13GrYZero[1] = crtR13GrYCurr[1];
4099: crtR13GrYZero[2] = crtR13GrYCurr[2];
4100: crtR13GrYZero[3] = crtR13GrYCurr[3];
4101: if (crtR11TxYZeroLast != crtR11TxYZero ||
4102: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
4103: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
4104: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
4105: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
4106: crtR11TxYZeroLast = crtR11TxYZero;
4107: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
4108: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
4109: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
4110: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
4111: crtAllStamp += 2;
4112: }
4113: crtDataY = 0;
4114: if (crtClearFrames != 0) {
4115: crtClearFrames--;
4116: } else if (crtClearStandby) {
4117: crtClearStandby = false;
4118: crtClearFrames = 1;
4119: }
4120: crtScreenY = 0;
4121: if (!XEiJ.PNL_USE_THREAD) {
4122: crtDirtyY0 = -1;
4123: }
4124: if (XEiJ.PNL_USE_THREAD) {
4125: crtAllStamp += 2;
4126: }
4127: if (SpriteScreen.SPR_THREE_STEPS) {
4128: SpriteScreen.sprActive = SpriteScreen.sprLatched;
4129: if (SpriteScreen.sprActive) {
4130: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
4131: SpriteScreen.sprLatched = false;
4132: }
4133: if (!XEiJ.PNL_USE_THREAD) {
4134: crtAllStamp += 2;
4135: }
4136:
4137: SpriteScreen.sprStep1 (0);
4138: SpriteScreen.sprSwap ();
4139:
4140:
4141: SpriteScreen.sprStep1 (1);
4142: SpriteScreen.sprSwap ();
4143: SpriteScreen.sprStep2 (0);
4144: }
4145: }
4146: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4147: crtStereoscopicStart ();
4148: }
4149: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);
4150: }
4151: } else {
4152:
4153: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4154: }
4155: }
4156: };
4157:
4158: public static final TickerQueue.Ticker DupExceptSpDrawIdleSync = new TickerQueue.Ticker () {
4159: @Override protected void tick () {
4160: MC68901.mfpHsyncRise ();
4161: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleBackDisp, crtClock += crtHSyncLength);
4162: }
4163: };
4164:
4165: public static final TickerQueue.Ticker DupExceptSpDrawIdleBackDisp = new TickerQueue.Ticker () {
4166: @Override protected void tick () {
4167: MC68901.mfpHsyncFall ();
4168: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleFront, crtClock += crtHBackDispLength);
4169: }
4170: };
4171:
4172: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenFront = new TickerQueue.Ticker () {
4173: @Override protected void tick () {
4174: int n = ++crtRasterNumber;
4175: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4176: if (crtRasterCopyOn) {
4177: crtDoRasterCopy ();
4178: }
4179: if (RasterBreakPoint.RBP_ON) {
4180: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4181: RasterBreakPoint.rbpFire ();
4182: }
4183: }
4184: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4185: if (irq != MC68901.mfpGpipRint) {
4186: if (irq == 0) {
4187: if (RasterBreakPoint.RBP_ON) {
4188: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4189: RasterBreakPoint.rbpFire ();
4190: }
4191: }
4192: MC68901.mfpRintFall ();
4193: } else {
4194: MC68901.mfpRintRise ();
4195: }
4196: }
4197: if (n != crtVIdleStart) {
4198: if (crtBeginningAllStamp != crtAllStamp) {
4199: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4200: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4201: crtStereoscopicDrawRaster (crtScreenY);
4202: }
4203: }
4204: crtScreenY++;
4205: crtDataY++;
4206: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);
4207: } else {
4208: if (crtBeginningAllStamp != crtAllStamp) {
4209: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4210: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4211: crtStereoscopicDrawRaster (crtScreenY);
4212: }
4213: }
4214: MC68901.mfpVdispFall ();
4215: if (!XEiJ.PNL_USE_THREAD) {
4216: if (crtDirtyY0 >= 0) {
4217: crtUpdateScreen ();
4218: if (CRT_ENABLE_INTERMITTENT) {
4219: crtIntermittentCounter = crtIntermittentInterval;
4220: }
4221: }
4222: }
4223: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4224: crtDoFrameTask ();
4225: }
4226: if (XEiJ.PNL_USE_THREAD) {
4227: if (FlashingLights.FLR_ON &&
4228: FlashingLights.flrActive) {
4229: FlashingLights.flrVsync ();
4230: }
4231: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4232: }
4233: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4234: }
4235: } else {
4236:
4237: if (crtBeginningAllStamp != crtAllStamp) {
4238: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4239: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4240: crtStereoscopicDrawRaster (crtScreenY);
4241: }
4242: }
4243: crtScreenY++;
4244: crtDataY++;
4245: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);
4246: }
4247: }
4248: };
4249:
4250: public static final TickerQueue.Ticker DupExceptSpDrawDispOddFront = new TickerQueue.Ticker () {
4251: @Override protected void tick () {
4252: int n = ++crtRasterNumber;
4253: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4254: if (crtRasterCopyOn) {
4255: crtDoRasterCopy ();
4256: }
4257: if (RasterBreakPoint.RBP_ON) {
4258: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4259: RasterBreakPoint.rbpFire ();
4260: }
4261: }
4262: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4263: if (irq != MC68901.mfpGpipRint) {
4264: if (irq == 0) {
4265: if (RasterBreakPoint.RBP_ON) {
4266: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4267: RasterBreakPoint.rbpFire ();
4268: }
4269: }
4270: MC68901.mfpRintFall ();
4271: } else {
4272: MC68901.mfpRintRise ();
4273: }
4274: }
4275: if (n != crtVIdleStart) {
4276: if (crtBeginningAllStamp != crtAllStamp) {
4277: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4278: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4279: crtStereoscopicDrawRaster (crtScreenY);
4280: }
4281: }
4282: crtScreenY++;
4283: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddSync, crtClock += crtHFrontLength);
4284: } else {
4285: if (crtBeginningAllStamp != crtAllStamp) {
4286: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4287: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4288: crtStereoscopicDrawRaster (crtScreenY);
4289: }
4290: }
4291: MC68901.mfpVdispFall ();
4292: if (!XEiJ.PNL_USE_THREAD) {
4293: if (crtDirtyY0 >= 0) {
4294: crtUpdateScreen ();
4295: if (CRT_ENABLE_INTERMITTENT) {
4296: crtIntermittentCounter = crtIntermittentInterval;
4297: }
4298: }
4299: }
4300: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4301: crtDoFrameTask ();
4302: }
4303: if (XEiJ.PNL_USE_THREAD) {
4304: if (FlashingLights.FLR_ON &&
4305: FlashingLights.flrActive) {
4306: FlashingLights.flrVsync ();
4307: }
4308: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4309: }
4310: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4311: }
4312: } else {
4313:
4314: if (crtBeginningAllStamp != crtAllStamp) {
4315: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4316: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4317: crtStereoscopicDrawRaster (crtScreenY);
4318: }
4319: }
4320: crtScreenY++;
4321: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddSync, crtClock += crtHFrontLength);
4322: }
4323: }
4324: };
4325:
4326: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenSync = new TickerQueue.Ticker () {
4327: @Override protected void tick () {
4328: MC68901.mfpHsyncRise ();
4329: if (crtClearFrames != 0) {
4330: crtRapidClear (crtDataY);
4331: crtRasterStamp[crtDataY] = 0;
4332: }
4333: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenBack, crtClock += crtHSyncLength);
4334: }
4335: };
4336:
4337: public static final TickerQueue.Ticker DupExceptSpDrawDispOddSync = new TickerQueue.Ticker () {
4338: @Override protected void tick () {
4339: MC68901.mfpHsyncRise ();
4340: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddBack, crtClock += crtHSyncLength);
4341: }
4342: };
4343:
4344: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenBack = new TickerQueue.Ticker () {
4345: @Override protected void tick () {
4346: MC68901.mfpHsyncFall ();
4347: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenDisp, crtClock += crtHBackLength);
4348: }
4349: };
4350:
4351: public static final TickerQueue.Ticker DupExceptSpDrawDispOddBack = new TickerQueue.Ticker () {
4352: @Override protected void tick () {
4353: MC68901.mfpHsyncFall ();
4354: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddDisp, crtClock += crtHBackLength);
4355: }
4356: };
4357:
4358: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenDisp = new TickerQueue.Ticker () {
4359: @Override protected void tick () {
4360: if (crtRasterStamp[crtDataY] != crtAllStamp) {
4361: crtBeginningAllStamp = crtAllStamp;
4362: if (Malfunction.MLF_ON) {
4363: Malfunction.mlfRaster (crtDataY);
4364: }
4365: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
4366: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4367: crtStereoscopicDrawRaster (crtScreenY);
4368: }
4369: if (!XEiJ.PNL_USE_THREAD) {
4370: if (crtDirtyY0 < 0) {
4371: crtDirtyY0 = crtScreenY;
4372: }
4373: crtDirtyY1 = crtScreenY;
4374: }
4375: }
4376: if (SpriteScreen.SPR_THREE_STEPS) {
4377: if (SpriteScreen.sprActive) {
4378:
4379:
4380: SpriteScreen.sprStep1 (crtScreenY + 2);
4381: SpriteScreen.sprSwap ();
4382: SpriteScreen.sprStep2 (crtScreenY + 1);
4383: }
4384: }
4385: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddFront, crtClock += crtHDispLength);
4386: }
4387: };
4388:
4389: public static final TickerQueue.Ticker DupExceptSpDrawDispOddDisp = new TickerQueue.Ticker () {
4390: @Override protected void tick () {
4391: if (crtRasterStamp[crtDataY] != crtAllStamp) {
4392: crtRasterStamp[crtDataY] = crtAllStamp;
4393: crtBeginningAllStamp = crtAllStamp;
4394: if (Malfunction.MLF_ON) {
4395: Malfunction.mlfRaster (crtDataY);
4396: }
4397: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
4398: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4399: crtStereoscopicDrawRaster (crtScreenY);
4400: }
4401: if (!XEiJ.PNL_USE_THREAD) {
4402: if (crtDirtyY0 < 0) {
4403: crtDirtyY0 = crtScreenY;
4404: }
4405: crtDirtyY1 = crtScreenY;
4406: }
4407: }
4408: if (SpriteScreen.SPR_THREE_STEPS) {
4409: if (SpriteScreen.sprActive) {
4410:
4411:
4412: SpriteScreen.sprStep1 (crtScreenY + 2);
4413: SpriteScreen.sprSwap ();
4414: SpriteScreen.sprStep2 (crtScreenY + 1);
4415: }
4416: }
4417: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenFront, crtClock += crtHDispLength);
4418: }
4419: };
4420:
4421: public static final TickerQueue.Ticker DupExceptSpOmitIdleFront = new TickerQueue.Ticker () {
4422: @Override protected void tick () {
4423: int n = ++crtRasterNumber;
4424: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
4425: if (crtR04VFrontEndCurr < n) {
4426: n = crtRasterNumber = 0;
4427: }
4428: if (crtRasterCopyOn) {
4429: crtDoRasterCopy ();
4430: }
4431: if (RasterBreakPoint.RBP_ON) {
4432: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4433: RasterBreakPoint.rbpFire ();
4434: }
4435: }
4436: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4437: if (irq != MC68901.mfpGpipRint) {
4438: if (irq == 0) {
4439: if (RasterBreakPoint.RBP_ON) {
4440: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4441: RasterBreakPoint.rbpFire ();
4442: }
4443: }
4444: MC68901.mfpRintFall ();
4445: } else {
4446: MC68901.mfpRintRise ();
4447: }
4448: }
4449: if (n != crtVDispStart) {
4450: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4451: } else {
4452: MC68901.mfpVdispRise ();
4453: crtR11TxYZero = crtR11TxYCurr;
4454: crtR13GrYZero[0] = crtR13GrYCurr[0];
4455: crtR13GrYZero[1] = crtR13GrYCurr[1];
4456: crtR13GrYZero[2] = crtR13GrYCurr[2];
4457: crtR13GrYZero[3] = crtR13GrYCurr[3];
4458: if (crtR11TxYZeroLast != crtR11TxYZero ||
4459: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
4460: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
4461: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
4462: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
4463: crtR11TxYZeroLast = crtR11TxYZero;
4464: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
4465: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
4466: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
4467: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
4468: crtAllStamp += 2;
4469: }
4470: crtDataY = 0;
4471: if (crtClearFrames != 0) {
4472: crtClearFrames--;
4473: } else if (crtClearStandby) {
4474: crtClearStandby = false;
4475: crtClearFrames = 1;
4476: }
4477: if (XEiJ.PNL_USE_THREAD) {
4478: crtAllStamp += 2;
4479: }
4480: if (SpriteScreen.SPR_THREE_STEPS) {
4481: SpriteScreen.sprActive = SpriteScreen.sprLatched;
4482: if (SpriteScreen.sprActive) {
4483: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
4484: SpriteScreen.sprLatched = false;
4485: }
4486: if (!XEiJ.PNL_USE_THREAD) {
4487: crtAllStamp += 2;
4488: }
4489:
4490: SpriteScreen.sprStep1 (0);
4491: SpriteScreen.sprSwap ();
4492:
4493:
4494: SpriteScreen.sprStep1 (1);
4495: SpriteScreen.sprSwap ();
4496: SpriteScreen.sprStep2 (0);
4497: }
4498: }
4499: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4500: crtStereoscopicStart ();
4501: }
4502: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);
4503: }
4504: } else {
4505:
4506: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4507: }
4508: }
4509: };
4510:
4511: public static final TickerQueue.Ticker DupExceptSpOmitIdleSync = new TickerQueue.Ticker () {
4512: @Override protected void tick () {
4513: MC68901.mfpHsyncRise ();
4514: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleBackDisp, crtClock += crtHSyncLength);
4515: }
4516: };
4517:
4518: public static final TickerQueue.Ticker DupExceptSpOmitIdleBackDisp = new TickerQueue.Ticker () {
4519: @Override protected void tick () {
4520: MC68901.mfpHsyncFall ();
4521: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleFront, crtClock += crtHBackDispLength);
4522: }
4523: };
4524:
4525: public static final TickerQueue.Ticker DupExceptSpOmitDispEvenFront = 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 = DupExceptSpOmitDispEvenSync, 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: if (FlashingLights.FLR_ON &&
4562: FlashingLights.flrActive) {
4563: FlashingLights.flrVsync ();
4564: }
4565: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4566: }
4567: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4568: }
4569: } else {
4570:
4571: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);
4572: }
4573: }
4574: };
4575:
4576: public static final TickerQueue.Ticker DupExceptSpOmitDispOddFront = new TickerQueue.Ticker () {
4577: @Override protected void tick () {
4578: int n = ++crtRasterNumber;
4579: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4580: if (crtRasterCopyOn) {
4581: crtDoRasterCopy ();
4582: }
4583: if (RasterBreakPoint.RBP_ON) {
4584: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4585: RasterBreakPoint.rbpFire ();
4586: }
4587: }
4588: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4589: if (irq != MC68901.mfpGpipRint) {
4590: if (irq == 0) {
4591: if (RasterBreakPoint.RBP_ON) {
4592: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4593: RasterBreakPoint.rbpFire ();
4594: }
4595: }
4596: MC68901.mfpRintFall ();
4597: } else {
4598: MC68901.mfpRintRise ();
4599: }
4600: }
4601: if (n != crtVIdleStart) {
4602: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddSync, crtClock += crtHFrontLength);
4603: } else {
4604: MC68901.mfpVdispFall ();
4605: if (CRT_ENABLE_INTERMITTENT) {
4606: crtIntermittentCounter--;
4607: }
4608: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4609: crtDoFrameTask ();
4610: }
4611: if (XEiJ.PNL_USE_THREAD) {
4612: if (FlashingLights.FLR_ON &&
4613: FlashingLights.flrActive) {
4614: FlashingLights.flrVsync ();
4615: }
4616: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4617: }
4618: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4619: }
4620: } else {
4621:
4622: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddSync, crtClock += crtHFrontLength);
4623: }
4624: }
4625: };
4626:
4627: public static final TickerQueue.Ticker DupExceptSpOmitDispEvenSync = new TickerQueue.Ticker () {
4628: @Override protected void tick () {
4629: MC68901.mfpHsyncRise ();
4630: if (crtClearFrames != 0) {
4631: crtRapidClear (crtDataY);
4632: crtRasterStamp[crtDataY] = 0;
4633: }
4634: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenBackDisp, crtClock += crtHSyncLength);
4635: }
4636: };
4637:
4638: public static final TickerQueue.Ticker DupExceptSpOmitDispOddSync = new TickerQueue.Ticker () {
4639: @Override protected void tick () {
4640: MC68901.mfpHsyncRise ();
4641: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddBackDisp, crtClock += crtHSyncLength);
4642: }
4643: };
4644:
4645: public static final TickerQueue.Ticker DupExceptSpOmitDispEvenBackDisp = new TickerQueue.Ticker () {
4646: @Override protected void tick () {
4647: MC68901.mfpHsyncFall ();
4648: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddFront, crtClock += crtHBackDispLength);
4649: }
4650: };
4651:
4652: public static final TickerQueue.Ticker DupExceptSpOmitDispOddBackDisp = new TickerQueue.Ticker () {
4653: @Override protected void tick () {
4654: MC68901.mfpHsyncFall ();
4655: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenFront, crtClock += crtHBackDispLength);
4656: }
4657: };
4658:
4659:
4660:
4661: }
4662:
4663:
4664: