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: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2190: }
2191: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
2192: }
2193: } else {
2194:
2195: if (crtBeginningAllStamp != crtAllStamp) {
2196: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2197: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2198: crtStereoscopicDrawRaster (crtScreenY);
2199: }
2200: }
2201: crtScreenY++;
2202: crtDataY++;
2203: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
2204: }
2205: }
2206: };
2207:
2208: public static final TickerQueue.Ticker NormalDrawDispSync = new TickerQueue.Ticker () {
2209: @Override protected void tick () {
2210: MC68901.mfpHsyncRise ();
2211: if (crtClearFrames != 0) {
2212: crtRapidClear (crtDataY);
2213: crtRasterStamp[crtDataY] = 0;
2214: }
2215: TickerQueue.tkqAdd (crtTicker = NormalDrawDispBack, crtClock += crtHSyncLength);
2216: }
2217: };
2218:
2219: public static final TickerQueue.Ticker NormalDrawDispBack = new TickerQueue.Ticker () {
2220: @Override protected void tick () {
2221: MC68901.mfpHsyncFall ();
2222: TickerQueue.tkqAdd (crtTicker = NormalDrawDispDisp, crtClock += crtHBackLength);
2223: }
2224: };
2225:
2226: public static final TickerQueue.Ticker NormalDrawDispDisp = new TickerQueue.Ticker () {
2227: @Override protected void tick () {
2228: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2229: crtRasterStamp[crtDataY] = crtAllStamp;
2230: crtBeginningAllStamp = crtAllStamp;
2231: if (Malfunction.MLF_ON) {
2232: Malfunction.mlfRaster (crtDataY);
2233: }
2234: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2235: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2236: crtStereoscopicDrawRaster (crtScreenY);
2237: }
2238: if (!XEiJ.PNL_USE_THREAD) {
2239: if (crtDirtyY0 < 0) {
2240: crtDirtyY0 = crtScreenY;
2241: }
2242: crtDirtyY1 = crtScreenY;
2243: }
2244: }
2245: if (SpriteScreen.SPR_THREE_STEPS) {
2246: if (SpriteScreen.sprActive) {
2247:
2248:
2249: SpriteScreen.sprStep1 (crtDataY + 2);
2250: SpriteScreen.sprSwap ();
2251: SpriteScreen.sprStep2 (crtDataY + 1);
2252: }
2253: }
2254: TickerQueue.tkqAdd (crtTicker = NormalDrawDispFront, crtClock += crtHDispLength);
2255: }
2256: };
2257:
2258: public static final TickerQueue.Ticker NormalOmitIdleFront = new TickerQueue.Ticker () {
2259: @Override protected void tick () {
2260: int n = ++crtRasterNumber;
2261: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2262: if (crtR04VFrontEndCurr < n) {
2263: n = crtRasterNumber = 0;
2264: }
2265: if (crtRasterCopyOn) {
2266: crtDoRasterCopy ();
2267: }
2268: if (RasterBreakPoint.RBP_ON) {
2269: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2270: RasterBreakPoint.rbpFire ();
2271: }
2272: }
2273: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2274: if (irq != MC68901.mfpGpipRint) {
2275: if (irq == 0) {
2276: if (RasterBreakPoint.RBP_ON) {
2277: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2278: RasterBreakPoint.rbpFire ();
2279: }
2280: }
2281: MC68901.mfpRintFall ();
2282: } else {
2283: MC68901.mfpRintRise ();
2284: }
2285: }
2286: if (n != crtVDispStart) {
2287: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2288: } else {
2289: MC68901.mfpVdispRise ();
2290: crtR11TxYZero = crtR11TxYCurr;
2291: crtR13GrYZero[0] = crtR13GrYCurr[0];
2292: crtR13GrYZero[1] = crtR13GrYCurr[1];
2293: crtR13GrYZero[2] = crtR13GrYCurr[2];
2294: crtR13GrYZero[3] = crtR13GrYCurr[3];
2295: if (crtR11TxYZeroLast != crtR11TxYZero ||
2296: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2297: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2298: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2299: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2300: crtR11TxYZeroLast = crtR11TxYZero;
2301: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2302: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2303: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2304: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2305: crtAllStamp += 2;
2306: }
2307: crtDataY = 0;
2308: if (crtClearFrames != 0) {
2309: crtClearFrames--;
2310: } else if (crtClearStandby) {
2311: crtClearStandby = false;
2312: crtClearFrames = 1;
2313: }
2314: if (XEiJ.PNL_USE_THREAD) {
2315: crtAllStamp += 2;
2316: }
2317: if (SpriteScreen.SPR_THREE_STEPS) {
2318: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2319: if (SpriteScreen.sprActive) {
2320: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2321: SpriteScreen.sprLatched = false;
2322: }
2323: if (!XEiJ.PNL_USE_THREAD) {
2324: crtAllStamp += 2;
2325: }
2326:
2327: SpriteScreen.sprStep1 (0);
2328: SpriteScreen.sprSwap ();
2329:
2330:
2331: SpriteScreen.sprStep1 (1);
2332: SpriteScreen.sprSwap ();
2333: SpriteScreen.sprStep2 (0);
2334: }
2335: }
2336: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2337: crtStereoscopicStart ();
2338: }
2339: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2340: }
2341: } else {
2342:
2343: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2344: }
2345: }
2346: };
2347:
2348: public static final TickerQueue.Ticker NormalOmitIdleSync = new TickerQueue.Ticker () {
2349: @Override protected void tick () {
2350: MC68901.mfpHsyncRise ();
2351: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleBackDisp, crtClock += crtHSyncLength);
2352: }
2353: };
2354:
2355: public static final TickerQueue.Ticker NormalOmitIdleBackDisp = new TickerQueue.Ticker () {
2356: @Override protected void tick () {
2357: MC68901.mfpHsyncFall ();
2358: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleFront, crtClock += crtHBackDispLength);
2359: }
2360: };
2361:
2362: public static final TickerQueue.Ticker NormalOmitDispFront = new TickerQueue.Ticker () {
2363: @Override protected void tick () {
2364: int n = ++crtRasterNumber;
2365: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2366: if (crtRasterCopyOn) {
2367: crtDoRasterCopy ();
2368: }
2369: if (RasterBreakPoint.RBP_ON) {
2370: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2371: RasterBreakPoint.rbpFire ();
2372: }
2373: }
2374: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2375: if (irq != MC68901.mfpGpipRint) {
2376: if (irq == 0) {
2377: if (RasterBreakPoint.RBP_ON) {
2378: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2379: RasterBreakPoint.rbpFire ();
2380: }
2381: }
2382: MC68901.mfpRintFall ();
2383: } else {
2384: MC68901.mfpRintRise ();
2385: }
2386: }
2387: if (n != crtVIdleStart) {
2388: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2389: } else {
2390: MC68901.mfpVdispFall ();
2391: if (CRT_ENABLE_INTERMITTENT) {
2392: crtIntermittentCounter--;
2393: }
2394: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2395: crtDoFrameTask ();
2396: }
2397: if (XEiJ.PNL_USE_THREAD) {
2398: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2399: }
2400: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2401: }
2402: } else {
2403:
2404: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2405: }
2406: }
2407: };
2408:
2409: public static final TickerQueue.Ticker NormalOmitDispSync = new TickerQueue.Ticker () {
2410: @Override protected void tick () {
2411: MC68901.mfpHsyncRise ();
2412: if (crtClearFrames != 0) {
2413: crtRapidClear (crtDataY);
2414: crtRasterStamp[crtDataY] = 0;
2415: }
2416: TickerQueue.tkqAdd (crtTicker = NormalOmitDispBackDisp, crtClock += crtHSyncLength);
2417: }
2418: };
2419:
2420: public static final TickerQueue.Ticker NormalOmitDispBackDisp = new TickerQueue.Ticker () {
2421: @Override protected void tick () {
2422: MC68901.mfpHsyncFall ();
2423: TickerQueue.tkqAdd (crtTicker = NormalOmitDispFront, crtClock += crtHBackDispLength);
2424: }
2425: };
2426:
2427:
2428:
2429:
2430: public static final TickerQueue.Ticker DuplicationStart = new TickerQueue.Ticker () {
2431: @Override protected void tick () {
2432: if (MC68901.mfpGpipHsync != 0) {
2433: MC68901.mfpHsyncFall ();
2434: }
2435: int n = crtRasterNumber = crtVIdleStart;
2436: if (crtRasterCopyOn) {
2437: crtDoRasterCopy ();
2438: }
2439: if (RasterBreakPoint.RBP_ON) {
2440: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2441: RasterBreakPoint.rbpFire ();
2442: }
2443: }
2444: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2445: if (irq != MC68901.mfpGpipRint) {
2446: if (irq == 0) {
2447: if (RasterBreakPoint.RBP_ON) {
2448: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2449: RasterBreakPoint.rbpFire ();
2450: }
2451: }
2452: MC68901.mfpRintFall ();
2453: } else {
2454: MC68901.mfpRintRise ();
2455: }
2456: }
2457: if (MC68901.mfpGpipVdisp != 0) {
2458: MC68901.mfpVdispFall ();
2459: }
2460: crtClearFrames = 0;
2461: if (CRT_ENABLE_INTERMITTENT) {
2462: crtIntermittentCounter = 0;
2463: }
2464: if (!XEiJ.PNL_USE_THREAD) {
2465: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2466: crtDoFrameTask ();
2467: }
2468: }
2469: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2470: }
2471: };
2472:
2473: public static final TickerQueue.Ticker DuplicationDrawIdleFront = new TickerQueue.Ticker () {
2474: @Override protected void tick () {
2475: int n = ++crtRasterNumber;
2476: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2477: if (crtR04VFrontEndCurr < n) {
2478: n = crtRasterNumber = 0;
2479: }
2480: if (crtRasterCopyOn) {
2481: crtDoRasterCopy ();
2482: }
2483: if (RasterBreakPoint.RBP_ON) {
2484: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2485: RasterBreakPoint.rbpFire ();
2486: }
2487: }
2488: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2489: if (irq != MC68901.mfpGpipRint) {
2490: if (irq == 0) {
2491: if (RasterBreakPoint.RBP_ON) {
2492: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2493: RasterBreakPoint.rbpFire ();
2494: }
2495: }
2496: MC68901.mfpRintFall ();
2497: } else {
2498: MC68901.mfpRintRise ();
2499: }
2500: }
2501: if (n != crtVDispStart) {
2502: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2503: } else {
2504: MC68901.mfpVdispRise ();
2505: crtR11TxYZero = crtR11TxYCurr;
2506: crtR13GrYZero[0] = crtR13GrYCurr[0];
2507: crtR13GrYZero[1] = crtR13GrYCurr[1];
2508: crtR13GrYZero[2] = crtR13GrYCurr[2];
2509: crtR13GrYZero[3] = crtR13GrYCurr[3];
2510: if (crtR11TxYZeroLast != crtR11TxYZero ||
2511: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2512: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2513: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2514: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2515: crtR11TxYZeroLast = crtR11TxYZero;
2516: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2517: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2518: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2519: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2520: crtAllStamp += 2;
2521: }
2522: crtDataY = 0;
2523: if (crtClearFrames != 0) {
2524: crtClearFrames--;
2525: } else if (crtClearStandby) {
2526: crtClearStandby = false;
2527: crtClearFrames = 1;
2528: }
2529: crtScreenY = 0;
2530: if (!XEiJ.PNL_USE_THREAD) {
2531: crtDirtyY0 = -1;
2532: }
2533: if (XEiJ.PNL_USE_THREAD) {
2534: crtAllStamp += 2;
2535: }
2536: if (SpriteScreen.SPR_THREE_STEPS) {
2537: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2538: if (SpriteScreen.sprActive) {
2539: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2540: SpriteScreen.sprLatched = false;
2541: }
2542: if (!XEiJ.PNL_USE_THREAD) {
2543: crtAllStamp += 2;
2544: }
2545:
2546: SpriteScreen.sprStep1 (0);
2547: SpriteScreen.sprSwap ();
2548:
2549:
2550: SpriteScreen.sprStep1 (0);
2551: SpriteScreen.sprSwap ();
2552: SpriteScreen.sprStep2 (0);
2553: }
2554: }
2555: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2556: crtStereoscopicStart ();
2557: }
2558: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2559: }
2560: } else {
2561:
2562: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2563: }
2564: }
2565: };
2566:
2567: public static final TickerQueue.Ticker DuplicationDrawIdleSync = new TickerQueue.Ticker () {
2568: @Override protected void tick () {
2569: MC68901.mfpHsyncRise ();
2570: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleBackDisp, crtClock += crtHSyncLength);
2571: }
2572: };
2573:
2574: public static final TickerQueue.Ticker DuplicationDrawIdleBackDisp = new TickerQueue.Ticker () {
2575: @Override protected void tick () {
2576: MC68901.mfpHsyncFall ();
2577: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleFront, crtClock += crtHBackDispLength);
2578: }
2579: };
2580:
2581: public static final TickerQueue.Ticker DuplicationDrawDispEvenFront = new TickerQueue.Ticker () {
2582: @Override protected void tick () {
2583: int n = ++crtRasterNumber;
2584: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2585: if (crtRasterCopyOn) {
2586: crtDoRasterCopy ();
2587: }
2588: if (RasterBreakPoint.RBP_ON) {
2589: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2590: RasterBreakPoint.rbpFire ();
2591: }
2592: }
2593: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2594: if (irq != MC68901.mfpGpipRint) {
2595: if (irq == 0) {
2596: if (RasterBreakPoint.RBP_ON) {
2597: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2598: RasterBreakPoint.rbpFire ();
2599: }
2600: }
2601: MC68901.mfpRintFall ();
2602: } else {
2603: MC68901.mfpRintRise ();
2604: }
2605: }
2606: if (n != crtVIdleStart) {
2607: if (crtBeginningAllStamp != crtAllStamp) {
2608: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2609: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2610: crtStereoscopicDrawRaster (crtScreenY);
2611: }
2612: }
2613: crtScreenY++;
2614: crtDataY++;
2615: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2616: } else {
2617: if (crtBeginningAllStamp != crtAllStamp) {
2618: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2619: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2620: crtStereoscopicDrawRaster (crtScreenY);
2621: }
2622: }
2623: MC68901.mfpVdispFall ();
2624: if (!XEiJ.PNL_USE_THREAD) {
2625: if (crtDirtyY0 >= 0) {
2626: crtUpdateScreen ();
2627: if (CRT_ENABLE_INTERMITTENT) {
2628: crtIntermittentCounter = crtIntermittentInterval;
2629: }
2630: }
2631: }
2632: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2633: crtDoFrameTask ();
2634: }
2635: if (XEiJ.PNL_USE_THREAD) {
2636: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2637: }
2638: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2639: }
2640: } else {
2641:
2642: if (crtBeginningAllStamp != crtAllStamp) {
2643: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2644: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2645: crtStereoscopicDrawRaster (crtScreenY);
2646: }
2647: }
2648: crtScreenY++;
2649: crtDataY++;
2650: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2651: }
2652: }
2653: };
2654:
2655: public static final TickerQueue.Ticker DuplicationDrawDispOddFront = new TickerQueue.Ticker () {
2656: @Override protected void tick () {
2657: int n = ++crtRasterNumber;
2658: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2659: if (crtRasterCopyOn) {
2660: crtDoRasterCopy ();
2661: }
2662: if (RasterBreakPoint.RBP_ON) {
2663: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2664: RasterBreakPoint.rbpFire ();
2665: }
2666: }
2667: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2668: if (irq != MC68901.mfpGpipRint) {
2669: if (irq == 0) {
2670: if (RasterBreakPoint.RBP_ON) {
2671: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2672: RasterBreakPoint.rbpFire ();
2673: }
2674: }
2675: MC68901.mfpRintFall ();
2676: } else {
2677: MC68901.mfpRintRise ();
2678: }
2679: }
2680: if (n != crtVIdleStart) {
2681: if (crtBeginningAllStamp != crtAllStamp) {
2682: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2683: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2684: crtStereoscopicDrawRaster (crtScreenY);
2685: }
2686: }
2687: crtScreenY++;
2688: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);
2689: } else {
2690: if (crtBeginningAllStamp != crtAllStamp) {
2691: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2692: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2693: crtStereoscopicDrawRaster (crtScreenY);
2694: }
2695: }
2696: MC68901.mfpVdispFall ();
2697: if (!XEiJ.PNL_USE_THREAD) {
2698: if (crtDirtyY0 >= 0) {
2699: crtUpdateScreen ();
2700: if (CRT_ENABLE_INTERMITTENT) {
2701: crtIntermittentCounter = crtIntermittentInterval;
2702: }
2703: }
2704: }
2705: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2706: crtDoFrameTask ();
2707: }
2708: if (XEiJ.PNL_USE_THREAD) {
2709: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2710: }
2711: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2712: }
2713: } else {
2714:
2715: if (crtBeginningAllStamp != crtAllStamp) {
2716: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2717: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2718: crtStereoscopicDrawRaster (crtScreenY);
2719: }
2720: }
2721: crtScreenY++;
2722: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);
2723: }
2724: }
2725: };
2726:
2727: public static final TickerQueue.Ticker DuplicationDrawDispEvenSync = new TickerQueue.Ticker () {
2728: @Override protected void tick () {
2729: MC68901.mfpHsyncRise ();
2730: if (crtClearFrames != 0) {
2731: crtRapidClear (crtDataY);
2732: crtRasterStamp[crtDataY] = 0;
2733: }
2734: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenBack, crtClock += crtHSyncLength);
2735: }
2736: };
2737:
2738: public static final TickerQueue.Ticker DuplicationDrawDispOddSync = new TickerQueue.Ticker () {
2739: @Override protected void tick () {
2740: MC68901.mfpHsyncRise ();
2741: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddBack, crtClock += crtHSyncLength);
2742: }
2743: };
2744:
2745: public static final TickerQueue.Ticker DuplicationDrawDispEvenBack = new TickerQueue.Ticker () {
2746: @Override protected void tick () {
2747: MC68901.mfpHsyncFall ();
2748: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenDisp, crtClock += crtHBackLength);
2749: }
2750: };
2751:
2752: public static final TickerQueue.Ticker DuplicationDrawDispOddBack = new TickerQueue.Ticker () {
2753: @Override protected void tick () {
2754: MC68901.mfpHsyncFall ();
2755: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddDisp, crtClock += crtHBackLength);
2756: }
2757: };
2758:
2759: public static final TickerQueue.Ticker DuplicationDrawDispEvenDisp = new TickerQueue.Ticker () {
2760: @Override protected void tick () {
2761: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2762: crtBeginningAllStamp = crtAllStamp;
2763: if (Malfunction.MLF_ON) {
2764: Malfunction.mlfRaster (crtDataY);
2765: }
2766: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2767: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2768: crtStereoscopicDrawRaster (crtScreenY);
2769: }
2770: if (!XEiJ.PNL_USE_THREAD) {
2771: if (crtDirtyY0 < 0) {
2772: crtDirtyY0 = crtScreenY;
2773: }
2774: crtDirtyY1 = crtScreenY;
2775: }
2776: }
2777: if (SpriteScreen.SPR_THREE_STEPS) {
2778: if (SpriteScreen.sprActive) {
2779:
2780:
2781: SpriteScreen.sprStep1 (crtDataY + 1);
2782: SpriteScreen.sprSwap ();
2783: SpriteScreen.sprStep2 (crtDataY);
2784: }
2785: }
2786: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddFront, crtClock += crtHDispLength);
2787: }
2788: };
2789:
2790: public static final TickerQueue.Ticker DuplicationDrawDispOddDisp = new TickerQueue.Ticker () {
2791: @Override protected void tick () {
2792: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2793: crtRasterStamp[crtDataY] = crtAllStamp;
2794: crtBeginningAllStamp = crtAllStamp;
2795: if (Malfunction.MLF_ON) {
2796: Malfunction.mlfRaster (crtDataY);
2797: }
2798: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2799: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2800: crtStereoscopicDrawRaster (crtScreenY);
2801: }
2802: if (!XEiJ.PNL_USE_THREAD) {
2803: if (crtDirtyY0 < 0) {
2804: crtDirtyY0 = crtScreenY;
2805: }
2806: crtDirtyY1 = crtScreenY;
2807: }
2808: }
2809: if (SpriteScreen.SPR_THREE_STEPS) {
2810: if (SpriteScreen.sprActive) {
2811:
2812:
2813: SpriteScreen.sprStep1 (crtDataY + 1);
2814: SpriteScreen.sprSwap ();
2815: SpriteScreen.sprStep2 (crtDataY + 1);
2816: }
2817: }
2818: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenFront, crtClock += crtHDispLength);
2819: }
2820: };
2821:
2822: public static final TickerQueue.Ticker DuplicationOmitIdleFront = new TickerQueue.Ticker () {
2823: @Override protected void tick () {
2824: int n = ++crtRasterNumber;
2825: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2826: if (crtR04VFrontEndCurr < n) {
2827: n = crtRasterNumber = 0;
2828: }
2829: if (crtRasterCopyOn) {
2830: crtDoRasterCopy ();
2831: }
2832: if (RasterBreakPoint.RBP_ON) {
2833: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2834: RasterBreakPoint.rbpFire ();
2835: }
2836: }
2837: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2838: if (irq != MC68901.mfpGpipRint) {
2839: if (irq == 0) {
2840: if (RasterBreakPoint.RBP_ON) {
2841: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2842: RasterBreakPoint.rbpFire ();
2843: }
2844: }
2845: MC68901.mfpRintFall ();
2846: } else {
2847: MC68901.mfpRintRise ();
2848: }
2849: }
2850: if (n != crtVDispStart) {
2851: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2852: } else {
2853: MC68901.mfpVdispRise ();
2854: crtR11TxYZero = crtR11TxYCurr;
2855: crtR13GrYZero[0] = crtR13GrYCurr[0];
2856: crtR13GrYZero[1] = crtR13GrYCurr[1];
2857: crtR13GrYZero[2] = crtR13GrYCurr[2];
2858: crtR13GrYZero[3] = crtR13GrYCurr[3];
2859: if (crtR11TxYZeroLast != crtR11TxYZero ||
2860: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2861: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2862: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2863: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2864: crtR11TxYZeroLast = crtR11TxYZero;
2865: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2866: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2867: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2868: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2869: crtAllStamp += 2;
2870: }
2871: crtDataY = 0;
2872: if (crtClearFrames != 0) {
2873: crtClearFrames--;
2874: } else if (crtClearStandby) {
2875: crtClearStandby = false;
2876: crtClearFrames = 1;
2877: }
2878: if (XEiJ.PNL_USE_THREAD) {
2879: crtAllStamp += 2;
2880: }
2881: if (SpriteScreen.SPR_THREE_STEPS) {
2882: SpriteScreen.sprActive = SpriteScreen.sprLatched;
2883: if (SpriteScreen.sprActive) {
2884: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
2885: SpriteScreen.sprLatched = false;
2886: }
2887: if (!XEiJ.PNL_USE_THREAD) {
2888: crtAllStamp += 2;
2889: }
2890:
2891: SpriteScreen.sprStep1 (0);
2892: SpriteScreen.sprSwap ();
2893:
2894:
2895: SpriteScreen.sprStep1 (0);
2896: SpriteScreen.sprSwap ();
2897: SpriteScreen.sprStep2 (0);
2898: }
2899: }
2900: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2901: crtStereoscopicStart ();
2902: }
2903: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2904: }
2905: } else {
2906:
2907: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2908: }
2909: }
2910: };
2911:
2912: public static final TickerQueue.Ticker DuplicationOmitIdleSync = new TickerQueue.Ticker () {
2913: @Override protected void tick () {
2914: MC68901.mfpHsyncRise ();
2915: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleBackDisp, crtClock += crtHSyncLength);
2916: }
2917: };
2918:
2919: public static final TickerQueue.Ticker DuplicationOmitIdleBackDisp = new TickerQueue.Ticker () {
2920: @Override protected void tick () {
2921: MC68901.mfpHsyncFall ();
2922: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleFront, crtClock += crtHBackDispLength);
2923: }
2924: };
2925:
2926: public static final TickerQueue.Ticker DuplicationOmitDispEvenFront = new TickerQueue.Ticker () {
2927: @Override protected void tick () {
2928: int n = ++crtRasterNumber;
2929: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2930: if (crtRasterCopyOn) {
2931: crtDoRasterCopy ();
2932: }
2933: if (RasterBreakPoint.RBP_ON) {
2934: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2935: RasterBreakPoint.rbpFire ();
2936: }
2937: }
2938: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2939: if (irq != MC68901.mfpGpipRint) {
2940: if (irq == 0) {
2941: if (RasterBreakPoint.RBP_ON) {
2942: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2943: RasterBreakPoint.rbpFire ();
2944: }
2945: }
2946: MC68901.mfpRintFall ();
2947: } else {
2948: MC68901.mfpRintRise ();
2949: }
2950: }
2951: if (n != crtVIdleStart) {
2952: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2953: } else {
2954: MC68901.mfpVdispFall ();
2955: if (CRT_ENABLE_INTERMITTENT) {
2956: crtIntermittentCounter--;
2957: }
2958: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2959: crtDoFrameTask ();
2960: }
2961: if (XEiJ.PNL_USE_THREAD) {
2962: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
2963: }
2964: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2965: }
2966: } else {
2967:
2968: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2969: }
2970: }
2971: };
2972:
2973: public static final TickerQueue.Ticker DuplicationOmitDispOddFront = new TickerQueue.Ticker () {
2974: @Override protected void tick () {
2975: int n = ++crtRasterNumber;
2976: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2977: if (crtRasterCopyOn) {
2978: crtDoRasterCopy ();
2979: }
2980: if (RasterBreakPoint.RBP_ON) {
2981: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2982: RasterBreakPoint.rbpFire ();
2983: }
2984: }
2985: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2986: if (irq != MC68901.mfpGpipRint) {
2987: if (irq == 0) {
2988: if (RasterBreakPoint.RBP_ON) {
2989: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2990: RasterBreakPoint.rbpFire ();
2991: }
2992: }
2993: MC68901.mfpRintFall ();
2994: } else {
2995: MC68901.mfpRintRise ();
2996: }
2997: }
2998: if (n != crtVIdleStart) {
2999: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);
3000: } else {
3001: MC68901.mfpVdispFall ();
3002: if (CRT_ENABLE_INTERMITTENT) {
3003: crtIntermittentCounter--;
3004: }
3005: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3006: crtDoFrameTask ();
3007: }
3008: if (XEiJ.PNL_USE_THREAD) {
3009: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3010: }
3011: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
3012: }
3013: } else {
3014:
3015: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);
3016: }
3017: }
3018: };
3019:
3020: public static final TickerQueue.Ticker DuplicationOmitDispEvenSync = new TickerQueue.Ticker () {
3021: @Override protected void tick () {
3022: MC68901.mfpHsyncRise ();
3023: if (crtClearFrames != 0) {
3024: crtRapidClear (crtDataY);
3025: crtRasterStamp[crtDataY] = 0;
3026: }
3027: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenBackDisp, crtClock += crtHSyncLength);
3028: }
3029: };
3030:
3031: public static final TickerQueue.Ticker DuplicationOmitDispOddSync = new TickerQueue.Ticker () {
3032: @Override protected void tick () {
3033: MC68901.mfpHsyncRise ();
3034: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddBackDisp, crtClock += crtHSyncLength);
3035: }
3036: };
3037:
3038: public static final TickerQueue.Ticker DuplicationOmitDispEvenBackDisp = new TickerQueue.Ticker () {
3039: @Override protected void tick () {
3040: MC68901.mfpHsyncFall ();
3041: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddFront, crtClock += crtHBackDispLength);
3042: }
3043: };
3044:
3045: public static final TickerQueue.Ticker DuplicationOmitDispOddBackDisp = new TickerQueue.Ticker () {
3046: @Override protected void tick () {
3047: MC68901.mfpHsyncFall ();
3048: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenFront, crtClock += crtHBackDispLength);
3049: }
3050: };
3051:
3052:
3053:
3054:
3055: public static final TickerQueue.Ticker InterlaceStart = new TickerQueue.Ticker () {
3056: @Override protected void tick () {
3057: if (MC68901.mfpGpipHsync != 0) {
3058: MC68901.mfpHsyncFall ();
3059: }
3060: int n = crtRasterNumber = crtVIdleStart;
3061: if (crtRasterCopyOn) {
3062: crtDoRasterCopy ();
3063: }
3064: if (RasterBreakPoint.RBP_ON) {
3065: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3066: RasterBreakPoint.rbpFire ();
3067: }
3068: }
3069: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3070: if (irq != MC68901.mfpGpipRint) {
3071: if (irq == 0) {
3072: if (RasterBreakPoint.RBP_ON) {
3073: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3074: RasterBreakPoint.rbpFire ();
3075: }
3076: }
3077: MC68901.mfpRintFall ();
3078: } else {
3079: MC68901.mfpRintRise ();
3080: }
3081: }
3082: if (MC68901.mfpGpipVdisp != 0) {
3083: MC68901.mfpVdispFall ();
3084: }
3085: crtFrameParity = 0;
3086: crtClearFrames = 0;
3087: if (CRT_ENABLE_INTERMITTENT) {
3088: crtIntermittentCounter = 0;
3089: }
3090: if (!XEiJ.PNL_USE_THREAD) {
3091: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3092: crtDoFrameTask ();
3093: }
3094: }
3095: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3096: }
3097: };
3098:
3099: public static final TickerQueue.Ticker InterlaceDrawIdleFront = new TickerQueue.Ticker () {
3100: @Override protected void tick () {
3101: int n = ++crtRasterNumber;
3102: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3103: if (crtR04VFrontEndCurr < n) {
3104: n = crtRasterNumber = 0;
3105: }
3106: if (crtRasterCopyOn) {
3107: crtDoRasterCopy ();
3108: }
3109: if (RasterBreakPoint.RBP_ON) {
3110: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3111: RasterBreakPoint.rbpFire ();
3112: }
3113: }
3114: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3115: if (irq != MC68901.mfpGpipRint) {
3116: if (irq == 0) {
3117: if (RasterBreakPoint.RBP_ON) {
3118: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3119: RasterBreakPoint.rbpFire ();
3120: }
3121: }
3122: MC68901.mfpRintFall ();
3123: } else {
3124: MC68901.mfpRintRise ();
3125: }
3126: }
3127: if (n != crtVDispStart) {
3128: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3129: } else {
3130: MC68901.mfpVdispRise ();
3131: crtR11TxYZero = crtR11TxYCurr;
3132: crtR13GrYZero[0] = crtR13GrYCurr[0];
3133: crtR13GrYZero[1] = crtR13GrYCurr[1];
3134: crtR13GrYZero[2] = crtR13GrYCurr[2];
3135: crtR13GrYZero[3] = crtR13GrYCurr[3];
3136: if (crtR11TxYZeroLast != crtR11TxYZero ||
3137: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3138: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3139: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3140: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3141: crtR11TxYZeroLast = crtR11TxYZero;
3142: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3143: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3144: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3145: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3146: crtAllStamp += 2;
3147: }
3148: crtDataY = crtFrameParity;
3149: if (crtClearFrames != 0) {
3150: crtClearFrames--;
3151: } else if (crtClearStandby &&
3152: crtFrameParity == 0) {
3153: crtClearStandby = false;
3154: crtClearFrames = 2;
3155: }
3156: crtScreenY = crtFrameParity;
3157: if (!XEiJ.PNL_USE_THREAD) {
3158: crtDirtyY0 = -1;
3159: }
3160: if (XEiJ.PNL_USE_THREAD) {
3161: crtAllStamp += 2;
3162: }
3163: if (SpriteScreen.SPR_THREE_STEPS) {
3164: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3165: if (SpriteScreen.sprActive) {
3166: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3167: SpriteScreen.sprLatched = false;
3168: }
3169: if (!XEiJ.PNL_USE_THREAD) {
3170: crtAllStamp += 2;
3171: }
3172:
3173: SpriteScreen.sprStep1 (0);
3174: SpriteScreen.sprSwap ();
3175:
3176:
3177: SpriteScreen.sprStep1 (2);
3178: SpriteScreen.sprSwap ();
3179: SpriteScreen.sprStep2 (0);
3180: }
3181: }
3182: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3183: crtStereoscopicStart ();
3184: }
3185: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3186: }
3187: } else {
3188:
3189: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3190: }
3191: }
3192: };
3193:
3194: public static final TickerQueue.Ticker InterlaceDrawIdleSync = new TickerQueue.Ticker () {
3195: @Override protected void tick () {
3196: MC68901.mfpHsyncRise ();
3197: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleBackDisp, crtClock += crtHSyncLength);
3198: }
3199: };
3200:
3201: public static final TickerQueue.Ticker InterlaceDrawIdleBackDisp = new TickerQueue.Ticker () {
3202: @Override protected void tick () {
3203: MC68901.mfpHsyncFall ();
3204: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleFront, crtClock += crtHBackDispLength);
3205: }
3206: };
3207:
3208: public static final TickerQueue.Ticker InterlaceDrawDispFront = new TickerQueue.Ticker () {
3209: @Override protected void tick () {
3210: int n = ++crtRasterNumber;
3211: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3212: if (crtRasterCopyOn) {
3213: crtDoRasterCopy ();
3214: }
3215: if (RasterBreakPoint.RBP_ON) {
3216: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3217: RasterBreakPoint.rbpFire ();
3218: }
3219: }
3220: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3221: if (irq != MC68901.mfpGpipRint) {
3222: if (irq == 0) {
3223: if (RasterBreakPoint.RBP_ON) {
3224: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3225: RasterBreakPoint.rbpFire ();
3226: }
3227: }
3228: MC68901.mfpRintFall ();
3229: } else {
3230: MC68901.mfpRintRise ();
3231: }
3232: }
3233: if (n != crtVIdleStart) {
3234: if (crtBeginningAllStamp != crtAllStamp) {
3235: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3236: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3237: crtStereoscopicDrawRaster (crtScreenY);
3238: if (XEiJ.PNL_USE_THREAD) {
3239: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3240: }
3241: }
3242: }
3243: crtScreenY += 2;
3244: crtDataY += 2;
3245: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3246: } else {
3247: if (crtBeginningAllStamp != crtAllStamp) {
3248: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3249: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3250: crtStereoscopicDrawRaster (crtScreenY);
3251: if (XEiJ.PNL_USE_THREAD) {
3252: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3253: }
3254: }
3255: }
3256: MC68901.mfpVdispFall ();
3257: if (!XEiJ.PNL_USE_THREAD) {
3258: if (crtDirtyY0 >= 0) {
3259: crtUpdateScreen ();
3260: if (CRT_ENABLE_INTERMITTENT) {
3261: crtIntermittentCounter = crtIntermittentInterval;
3262: }
3263: }
3264: }
3265: crtFrameParity ^= 1;
3266: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3267: crtDoFrameTask ();
3268: }
3269: if (XEiJ.PNL_USE_THREAD) {
3270: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3271: }
3272: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3273: }
3274: } else {
3275:
3276: if (crtBeginningAllStamp != crtAllStamp) {
3277: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3278: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3279: crtStereoscopicDrawRaster (crtScreenY);
3280: if (XEiJ.PNL_USE_THREAD) {
3281: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3282: }
3283: }
3284: }
3285: crtScreenY += 2;
3286: crtDataY += 2;
3287: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3288: }
3289: }
3290: };
3291:
3292: public static final TickerQueue.Ticker InterlaceDrawDispSync = new TickerQueue.Ticker () {
3293: @Override protected void tick () {
3294: MC68901.mfpHsyncRise ();
3295: if (crtClearFrames != 0) {
3296: crtRapidClear (crtDataY);
3297: crtRasterStamp[crtDataY] = 0;
3298: }
3299: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispBack, crtClock += crtHSyncLength);
3300: }
3301: };
3302:
3303: public static final TickerQueue.Ticker InterlaceDrawDispBack = new TickerQueue.Ticker () {
3304: @Override protected void tick () {
3305: MC68901.mfpHsyncFall ();
3306: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispDisp, crtClock += crtHBackLength);
3307: }
3308: };
3309:
3310: public static final TickerQueue.Ticker InterlaceDrawDispDisp = new TickerQueue.Ticker () {
3311: @Override protected void tick () {
3312: if (crtRasterStamp[crtDataY] != crtAllStamp) {
3313: crtRasterStamp[crtDataY] = crtAllStamp;
3314: crtBeginningAllStamp = crtAllStamp;
3315: if (Malfunction.MLF_ON) {
3316: Malfunction.mlfRaster (crtDataY);
3317: }
3318: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
3319: if (XEiJ.PNL_USE_THREAD) {
3320: int[] prevBM = XEiJ.pnlBMLeftArray[(XEiJ.pnlBMWrite - 1) & 3];
3321: int da = (crtScreenY ^ 1) << XEiJ.PNL_BM_OFFSET_BITS;
3322: System.arraycopy (prevBM, da,
3323: XEiJ.pnlBM, da,
3324: XEiJ.pnlScreenWidth);
3325: }
3326: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3327: crtStereoscopicDrawRaster (crtScreenY);
3328: if (XEiJ.PNL_USE_THREAD) {
3329: crtStereoscopicDrawRaster (crtScreenY ^ 1);
3330: }
3331: }
3332: if (!XEiJ.PNL_USE_THREAD) {
3333: if (crtDirtyY0 < 0) {
3334: crtDirtyY0 = crtScreenY;
3335: }
3336: crtDirtyY1 = crtScreenY;
3337: }
3338: }
3339: if (SpriteScreen.SPR_THREE_STEPS) {
3340: if (SpriteScreen.sprActive) {
3341:
3342:
3343: SpriteScreen.sprStep1 (crtDataY + 4);
3344: SpriteScreen.sprSwap ();
3345: SpriteScreen.sprStep2 (crtDataY + 2);
3346: }
3347: }
3348: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispFront, crtClock += crtHDispLength);
3349: }
3350: };
3351:
3352: public static final TickerQueue.Ticker InterlaceOmitIdleFront = new TickerQueue.Ticker () {
3353: @Override protected void tick () {
3354: int n = ++crtRasterNumber;
3355: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3356: if (crtR04VFrontEndCurr < n) {
3357: n = crtRasterNumber = 0;
3358: }
3359: if (crtRasterCopyOn) {
3360: crtDoRasterCopy ();
3361: }
3362: if (RasterBreakPoint.RBP_ON) {
3363: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3364: RasterBreakPoint.rbpFire ();
3365: }
3366: }
3367: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3368: if (irq != MC68901.mfpGpipRint) {
3369: if (irq == 0) {
3370: if (RasterBreakPoint.RBP_ON) {
3371: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3372: RasterBreakPoint.rbpFire ();
3373: }
3374: }
3375: MC68901.mfpRintFall ();
3376: } else {
3377: MC68901.mfpRintRise ();
3378: }
3379: }
3380: if (n != crtVDispStart) {
3381: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3382: } else {
3383: MC68901.mfpVdispRise ();
3384: crtR11TxYZero = crtR11TxYCurr;
3385: crtR13GrYZero[0] = crtR13GrYCurr[0];
3386: crtR13GrYZero[1] = crtR13GrYCurr[1];
3387: crtR13GrYZero[2] = crtR13GrYCurr[2];
3388: crtR13GrYZero[3] = crtR13GrYCurr[3];
3389: if (crtR11TxYZeroLast != crtR11TxYZero ||
3390: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3391: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3392: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3393: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3394: crtR11TxYZeroLast = crtR11TxYZero;
3395: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3396: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3397: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3398: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3399: crtAllStamp += 2;
3400: }
3401: crtDataY = crtFrameParity;
3402: if (crtClearFrames != 0) {
3403: crtClearFrames--;
3404: } else if (crtClearStandby &&
3405: crtFrameParity == 0) {
3406: crtClearStandby = false;
3407: crtClearFrames = 2;
3408: }
3409: if (XEiJ.PNL_USE_THREAD) {
3410: crtAllStamp += 2;
3411: }
3412: if (SpriteScreen.SPR_THREE_STEPS) {
3413: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3414: if (SpriteScreen.sprActive) {
3415: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3416: SpriteScreen.sprLatched = false;
3417: }
3418: if (!XEiJ.PNL_USE_THREAD) {
3419: crtAllStamp += 2;
3420: }
3421:
3422: SpriteScreen.sprStep1 (0);
3423: SpriteScreen.sprSwap ();
3424:
3425:
3426: SpriteScreen.sprStep1 (2);
3427: SpriteScreen.sprSwap ();
3428: SpriteScreen.sprStep2 (0);
3429: }
3430: }
3431: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3432: crtStereoscopicStart ();
3433: }
3434: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3435: }
3436: } else {
3437:
3438: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3439: }
3440: }
3441: };
3442:
3443: public static final TickerQueue.Ticker InterlaceOmitIdleSync = new TickerQueue.Ticker () {
3444: @Override protected void tick () {
3445: MC68901.mfpHsyncRise ();
3446: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleBackDisp, crtClock += crtHSyncLength);
3447: }
3448: };
3449:
3450: public static final TickerQueue.Ticker InterlaceOmitIdleBackDisp = new TickerQueue.Ticker () {
3451: @Override protected void tick () {
3452: MC68901.mfpHsyncFall ();
3453: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleFront, crtClock += crtHBackDispLength);
3454: }
3455: };
3456:
3457: public static final TickerQueue.Ticker InterlaceOmitDispFront = new TickerQueue.Ticker () {
3458: @Override protected void tick () {
3459: int n = ++crtRasterNumber;
3460: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3461: if (crtRasterCopyOn) {
3462: crtDoRasterCopy ();
3463: }
3464: if (RasterBreakPoint.RBP_ON) {
3465: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3466: RasterBreakPoint.rbpFire ();
3467: }
3468: }
3469: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3470: if (irq != MC68901.mfpGpipRint) {
3471: if (irq == 0) {
3472: if (RasterBreakPoint.RBP_ON) {
3473: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3474: RasterBreakPoint.rbpFire ();
3475: }
3476: }
3477: MC68901.mfpRintFall ();
3478: } else {
3479: MC68901.mfpRintRise ();
3480: }
3481: }
3482: if (n != crtVIdleStart) {
3483: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3484: } else {
3485: MC68901.mfpVdispFall ();
3486: if (CRT_ENABLE_INTERMITTENT) {
3487: crtIntermittentCounter--;
3488: }
3489: crtFrameParity ^= 1;
3490: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3491: crtDoFrameTask ();
3492: }
3493: if (XEiJ.PNL_USE_THREAD) {
3494: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3495: }
3496: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3497: }
3498: } else {
3499:
3500: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3501: }
3502: }
3503: };
3504:
3505: public static final TickerQueue.Ticker InterlaceOmitDispSync = new TickerQueue.Ticker () {
3506: @Override protected void tick () {
3507: MC68901.mfpHsyncRise ();
3508: if (crtClearFrames != 0) {
3509: crtRapidClear (crtDataY);
3510: crtRasterStamp[crtDataY] = 0;
3511: }
3512: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispBackDisp, crtClock += crtHSyncLength);
3513: }
3514: };
3515:
3516: public static final TickerQueue.Ticker InterlaceOmitDispBackDisp = new TickerQueue.Ticker () {
3517: @Override protected void tick () {
3518: MC68901.mfpHsyncFall ();
3519: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispFront, crtClock += crtHBackDispLength);
3520: }
3521: };
3522:
3523:
3524:
3525:
3526: public static final TickerQueue.Ticker SlitStart = new TickerQueue.Ticker () {
3527: @Override protected void tick () {
3528: if (MC68901.mfpGpipHsync != 0) {
3529: MC68901.mfpHsyncFall ();
3530: }
3531: int n = crtRasterNumber = crtVIdleStart;
3532: if (crtRasterCopyOn) {
3533: crtDoRasterCopy ();
3534: }
3535: if (RasterBreakPoint.RBP_ON) {
3536: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3537: RasterBreakPoint.rbpFire ();
3538: }
3539: }
3540: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3541: if (irq != MC68901.mfpGpipRint) {
3542: if (irq == 0) {
3543: if (RasterBreakPoint.RBP_ON) {
3544: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3545: RasterBreakPoint.rbpFire ();
3546: }
3547: }
3548: MC68901.mfpRintFall ();
3549: } else {
3550: MC68901.mfpRintRise ();
3551: }
3552: }
3553: if (MC68901.mfpGpipVdisp != 0) {
3554: MC68901.mfpVdispFall ();
3555: }
3556: crtClearFrames = 0;
3557: if (CRT_ENABLE_INTERMITTENT) {
3558: crtIntermittentCounter = 0;
3559: }
3560: if (!XEiJ.PNL_USE_THREAD) {
3561: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3562: crtDoFrameTask ();
3563: }
3564: }
3565: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3566: }
3567: };
3568:
3569: public static final TickerQueue.Ticker SlitDrawIdleFront = new TickerQueue.Ticker () {
3570: @Override protected void tick () {
3571: int n = ++crtRasterNumber;
3572: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3573: if (crtR04VFrontEndCurr < n) {
3574: n = crtRasterNumber = 0;
3575: }
3576: if (crtRasterCopyOn) {
3577: crtDoRasterCopy ();
3578: }
3579: if (RasterBreakPoint.RBP_ON) {
3580: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3581: RasterBreakPoint.rbpFire ();
3582: }
3583: }
3584: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3585: if (irq != MC68901.mfpGpipRint) {
3586: if (irq == 0) {
3587: if (RasterBreakPoint.RBP_ON) {
3588: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3589: RasterBreakPoint.rbpFire ();
3590: }
3591: }
3592: MC68901.mfpRintFall ();
3593: } else {
3594: MC68901.mfpRintRise ();
3595: }
3596: }
3597: if (n != crtVDispStart) {
3598: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3599: } else {
3600: MC68901.mfpVdispRise ();
3601: crtR11TxYZero = crtR11TxYCurr;
3602: crtR13GrYZero[0] = crtR13GrYCurr[0];
3603: crtR13GrYZero[1] = crtR13GrYCurr[1];
3604: crtR13GrYZero[2] = crtR13GrYCurr[2];
3605: crtR13GrYZero[3] = crtR13GrYCurr[3];
3606: if (crtR11TxYZeroLast != crtR11TxYZero ||
3607: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3608: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3609: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3610: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3611: crtR11TxYZeroLast = crtR11TxYZero;
3612: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3613: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3614: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3615: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3616: crtAllStamp += 2;
3617: }
3618: crtDataY = 0;
3619: if (crtClearFrames != 0) {
3620: crtClearFrames--;
3621: } else if (crtClearStandby) {
3622: crtClearStandby = false;
3623: crtClearFrames = 1;
3624: }
3625: crtScreenY = 0;
3626: if (!XEiJ.PNL_USE_THREAD) {
3627: crtDirtyY0 = -1;
3628: }
3629: if (XEiJ.PNL_USE_THREAD) {
3630: crtAllStamp += 2;
3631: }
3632: if (SpriteScreen.SPR_THREE_STEPS) {
3633: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3634: if (SpriteScreen.sprActive) {
3635: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3636: SpriteScreen.sprLatched = false;
3637: }
3638: if (!XEiJ.PNL_USE_THREAD) {
3639: crtAllStamp += 2;
3640: }
3641:
3642: SpriteScreen.sprStep1 (0);
3643: SpriteScreen.sprSwap ();
3644:
3645:
3646: SpriteScreen.sprStep1 (1);
3647: SpriteScreen.sprSwap ();
3648: SpriteScreen.sprStep2 (0);
3649: }
3650: }
3651: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3652: crtStereoscopicStart ();
3653: }
3654: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3655: }
3656: } else {
3657:
3658: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3659: }
3660: }
3661: };
3662:
3663: public static final TickerQueue.Ticker SlitDrawIdleSync = new TickerQueue.Ticker () {
3664: @Override protected void tick () {
3665: MC68901.mfpHsyncRise ();
3666: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleBackDisp, crtClock += crtHSyncLength);
3667: }
3668: };
3669:
3670: public static final TickerQueue.Ticker SlitDrawIdleBackDisp = new TickerQueue.Ticker () {
3671: @Override protected void tick () {
3672: MC68901.mfpHsyncFall ();
3673: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleFront, crtClock += crtHBackDispLength);
3674: }
3675: };
3676:
3677: public static final TickerQueue.Ticker SlitDrawDispFront = new TickerQueue.Ticker () {
3678: @Override protected void tick () {
3679: int n = ++crtRasterNumber;
3680: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3681: if (crtRasterCopyOn) {
3682: crtDoRasterCopy ();
3683: }
3684: if (RasterBreakPoint.RBP_ON) {
3685: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3686: RasterBreakPoint.rbpFire ();
3687: }
3688: }
3689: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3690: if (irq != MC68901.mfpGpipRint) {
3691: if (irq == 0) {
3692: if (RasterBreakPoint.RBP_ON) {
3693: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3694: RasterBreakPoint.rbpFire ();
3695: }
3696: }
3697: MC68901.mfpRintFall ();
3698: } else {
3699: MC68901.mfpRintRise ();
3700: }
3701: }
3702: if (n != crtVIdleStart) {
3703: if (crtBeginningAllStamp != crtAllStamp) {
3704: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3705: crtScanlineEffect.drawRaster (crtScreenY + 1);
3706: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3707: crtStereoscopicDrawRaster (crtScreenY);
3708: crtStereoscopicDrawRaster (crtScreenY + 1);
3709: }
3710: }
3711: crtScreenY += 2;
3712: crtDataY++;
3713: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3714: } else {
3715: if (crtBeginningAllStamp != crtAllStamp) {
3716: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3717: crtScanlineEffect.drawRaster (crtScreenY + 1);
3718: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3719: crtStereoscopicDrawRaster (crtScreenY);
3720: crtStereoscopicDrawRaster (crtScreenY + 1);
3721: }
3722: }
3723: MC68901.mfpVdispFall ();
3724: if (!XEiJ.PNL_USE_THREAD) {
3725: if (crtDirtyY0 >= 0) {
3726: crtUpdateScreen ();
3727: if (CRT_ENABLE_INTERMITTENT) {
3728: crtIntermittentCounter = crtIntermittentInterval;
3729: }
3730: }
3731: }
3732: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3733: crtDoFrameTask ();
3734: }
3735: if (XEiJ.PNL_USE_THREAD) {
3736: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3737: }
3738: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3739: }
3740: } else {
3741:
3742: if (crtBeginningAllStamp != crtAllStamp) {
3743: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3744: crtScanlineEffect.drawRaster (crtScreenY + 1);
3745: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3746: crtStereoscopicDrawRaster (crtScreenY);
3747: crtStereoscopicDrawRaster (crtScreenY + 1);
3748: }
3749: }
3750: crtScreenY += 2;
3751: crtDataY++;
3752: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3753: }
3754: }
3755: };
3756:
3757: public static final TickerQueue.Ticker SlitDrawDispSync = new TickerQueue.Ticker () {
3758: @Override protected void tick () {
3759: MC68901.mfpHsyncRise ();
3760: if (crtClearFrames != 0) {
3761: crtRapidClear (crtDataY);
3762: crtRasterStamp[crtDataY] = 0;
3763: }
3764: TickerQueue.tkqAdd (crtTicker = SlitDrawDispBack, crtClock += crtHSyncLength);
3765: }
3766: };
3767:
3768: public static final TickerQueue.Ticker SlitDrawDispBack = new TickerQueue.Ticker () {
3769: @Override protected void tick () {
3770: MC68901.mfpHsyncFall ();
3771: TickerQueue.tkqAdd (crtTicker = SlitDrawDispDisp, crtClock += crtHBackLength);
3772: }
3773: };
3774:
3775: public static final TickerQueue.Ticker SlitDrawDispDisp = new TickerQueue.Ticker () {
3776: @Override protected void tick () {
3777: if (crtRasterStamp[crtDataY] != crtAllStamp) {
3778: crtRasterStamp[crtDataY] = crtAllStamp;
3779: crtBeginningAllStamp = crtAllStamp;
3780: if (Malfunction.MLF_ON) {
3781: Malfunction.mlfRaster (crtDataY);
3782: }
3783: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
3784: crtScanlineEffect.drawRaster (crtScreenY + 1);
3785: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3786: crtStereoscopicDrawRaster (crtScreenY);
3787: crtStereoscopicDrawRaster (crtScreenY + 1);
3788: }
3789: if (!XEiJ.PNL_USE_THREAD) {
3790: if (crtDirtyY0 < 0) {
3791: crtDirtyY0 = crtScreenY;
3792: }
3793: crtDirtyY1 = crtScreenY + 1;
3794: }
3795: }
3796: if (SpriteScreen.SPR_THREE_STEPS) {
3797: if (SpriteScreen.sprActive) {
3798:
3799:
3800: SpriteScreen.sprStep1 (crtDataY + 2);
3801: SpriteScreen.sprSwap ();
3802: SpriteScreen.sprStep2 (crtDataY + 1);
3803: }
3804: }
3805: TickerQueue.tkqAdd (crtTicker = SlitDrawDispFront, crtClock += crtHDispLength);
3806: }
3807: };
3808:
3809: public static final TickerQueue.Ticker SlitOmitIdleFront = new TickerQueue.Ticker () {
3810: @Override protected void tick () {
3811: int n = ++crtRasterNumber;
3812: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3813: if (crtR04VFrontEndCurr < n) {
3814: n = crtRasterNumber = 0;
3815: }
3816: if (crtRasterCopyOn) {
3817: crtDoRasterCopy ();
3818: }
3819: if (RasterBreakPoint.RBP_ON) {
3820: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3821: RasterBreakPoint.rbpFire ();
3822: }
3823: }
3824: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3825: if (irq != MC68901.mfpGpipRint) {
3826: if (irq == 0) {
3827: if (RasterBreakPoint.RBP_ON) {
3828: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3829: RasterBreakPoint.rbpFire ();
3830: }
3831: }
3832: MC68901.mfpRintFall ();
3833: } else {
3834: MC68901.mfpRintRise ();
3835: }
3836: }
3837: if (n != crtVDispStart) {
3838: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3839: } else {
3840: MC68901.mfpVdispRise ();
3841: crtR11TxYZero = crtR11TxYCurr;
3842: crtR13GrYZero[0] = crtR13GrYCurr[0];
3843: crtR13GrYZero[1] = crtR13GrYCurr[1];
3844: crtR13GrYZero[2] = crtR13GrYCurr[2];
3845: crtR13GrYZero[3] = crtR13GrYCurr[3];
3846: if (crtR11TxYZeroLast != crtR11TxYZero ||
3847: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3848: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3849: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3850: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3851: crtR11TxYZeroLast = crtR11TxYZero;
3852: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3853: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3854: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3855: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3856: crtAllStamp += 2;
3857: }
3858: crtDataY = 0;
3859: if (crtClearFrames != 0) {
3860: crtClearFrames--;
3861: } else if (crtClearStandby) {
3862: crtClearStandby = false;
3863: crtClearFrames = 1;
3864: }
3865: if (XEiJ.PNL_USE_THREAD) {
3866: crtAllStamp += 2;
3867: }
3868: if (SpriteScreen.SPR_THREE_STEPS) {
3869: SpriteScreen.sprActive = SpriteScreen.sprLatched;
3870: if (SpriteScreen.sprActive) {
3871: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
3872: SpriteScreen.sprLatched = false;
3873: }
3874: if (!XEiJ.PNL_USE_THREAD) {
3875: crtAllStamp += 2;
3876: }
3877:
3878: SpriteScreen.sprStep1 (0);
3879: SpriteScreen.sprSwap ();
3880:
3881:
3882: SpriteScreen.sprStep1 (1);
3883: SpriteScreen.sprSwap ();
3884: SpriteScreen.sprStep2 (0);
3885: }
3886: }
3887: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3888: crtStereoscopicStart ();
3889: }
3890: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3891: }
3892: } else {
3893:
3894: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3895: }
3896: }
3897: };
3898:
3899: public static final TickerQueue.Ticker SlitOmitIdleSync = new TickerQueue.Ticker () {
3900: @Override protected void tick () {
3901: MC68901.mfpHsyncRise ();
3902: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleBackDisp, crtClock += crtHSyncLength);
3903: }
3904: };
3905:
3906: public static final TickerQueue.Ticker SlitOmitIdleBackDisp = new TickerQueue.Ticker () {
3907: @Override protected void tick () {
3908: MC68901.mfpHsyncFall ();
3909: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleFront, crtClock += crtHBackDispLength);
3910: }
3911: };
3912:
3913: public static final TickerQueue.Ticker SlitOmitDispFront = new TickerQueue.Ticker () {
3914: @Override protected void tick () {
3915: int n = ++crtRasterNumber;
3916: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3917: if (crtRasterCopyOn) {
3918: crtDoRasterCopy ();
3919: }
3920: if (RasterBreakPoint.RBP_ON) {
3921: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3922: RasterBreakPoint.rbpFire ();
3923: }
3924: }
3925: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3926: if (irq != MC68901.mfpGpipRint) {
3927: if (irq == 0) {
3928: if (RasterBreakPoint.RBP_ON) {
3929: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3930: RasterBreakPoint.rbpFire ();
3931: }
3932: }
3933: MC68901.mfpRintFall ();
3934: } else {
3935: MC68901.mfpRintRise ();
3936: }
3937: }
3938: if (n != crtVIdleStart) {
3939: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3940: } else {
3941: MC68901.mfpVdispFall ();
3942: if (CRT_ENABLE_INTERMITTENT) {
3943: crtIntermittentCounter--;
3944: }
3945: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3946: crtDoFrameTask ();
3947: }
3948: if (XEiJ.PNL_USE_THREAD) {
3949: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
3950: }
3951: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3952: }
3953: } else {
3954:
3955: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3956: }
3957: }
3958: };
3959:
3960: public static final TickerQueue.Ticker SlitOmitDispSync = new TickerQueue.Ticker () {
3961: @Override protected void tick () {
3962: MC68901.mfpHsyncRise ();
3963: if (crtClearFrames != 0) {
3964: crtRapidClear (crtDataY);
3965: crtRasterStamp[crtDataY] = 0;
3966: }
3967: TickerQueue.tkqAdd (crtTicker = SlitOmitDispBackDisp, crtClock += crtHSyncLength);
3968: }
3969: };
3970:
3971: public static final TickerQueue.Ticker SlitOmitDispBackDisp = new TickerQueue.Ticker () {
3972: @Override protected void tick () {
3973: MC68901.mfpHsyncFall ();
3974: TickerQueue.tkqAdd (crtTicker = SlitOmitDispFront, crtClock += crtHBackDispLength);
3975: }
3976: };
3977:
3978:
3979:
3980:
3981: public static final TickerQueue.Ticker DupExceptSpStart = new TickerQueue.Ticker () {
3982: @Override protected void tick () {
3983: if (MC68901.mfpGpipHsync != 0) {
3984: MC68901.mfpHsyncFall ();
3985: }
3986: int n = crtRasterNumber = crtVIdleStart;
3987: if (crtRasterCopyOn) {
3988: crtDoRasterCopy ();
3989: }
3990: if (RasterBreakPoint.RBP_ON) {
3991: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3992: RasterBreakPoint.rbpFire ();
3993: }
3994: }
3995: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3996: if (irq != MC68901.mfpGpipRint) {
3997: if (irq == 0) {
3998: if (RasterBreakPoint.RBP_ON) {
3999: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4000: RasterBreakPoint.rbpFire ();
4001: }
4002: }
4003: MC68901.mfpRintFall ();
4004: } else {
4005: MC68901.mfpRintRise ();
4006: }
4007: }
4008: if (MC68901.mfpGpipVdisp != 0) {
4009: MC68901.mfpVdispFall ();
4010: }
4011: crtClearFrames = 0;
4012: if (CRT_ENABLE_INTERMITTENT) {
4013: crtIntermittentCounter = 0;
4014: }
4015: if (!XEiJ.PNL_USE_THREAD) {
4016: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4017: crtDoFrameTask ();
4018: }
4019: }
4020: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4021: }
4022: };
4023:
4024: public static final TickerQueue.Ticker DupExceptSpDrawIdleFront = new TickerQueue.Ticker () {
4025: @Override protected void tick () {
4026: int n = ++crtRasterNumber;
4027: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
4028: if (crtR04VFrontEndCurr < n) {
4029: n = crtRasterNumber = 0;
4030: }
4031: if (crtRasterCopyOn) {
4032: crtDoRasterCopy ();
4033: }
4034: if (RasterBreakPoint.RBP_ON) {
4035: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4036: RasterBreakPoint.rbpFire ();
4037: }
4038: }
4039: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4040: if (irq != MC68901.mfpGpipRint) {
4041: if (irq == 0) {
4042: if (RasterBreakPoint.RBP_ON) {
4043: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4044: RasterBreakPoint.rbpFire ();
4045: }
4046: }
4047: MC68901.mfpRintFall ();
4048: } else {
4049: MC68901.mfpRintRise ();
4050: }
4051: }
4052: if (n != crtVDispStart) {
4053: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4054: } else {
4055: MC68901.mfpVdispRise ();
4056: crtR11TxYZero = crtR11TxYCurr;
4057: crtR13GrYZero[0] = crtR13GrYCurr[0];
4058: crtR13GrYZero[1] = crtR13GrYCurr[1];
4059: crtR13GrYZero[2] = crtR13GrYCurr[2];
4060: crtR13GrYZero[3] = crtR13GrYCurr[3];
4061: if (crtR11TxYZeroLast != crtR11TxYZero ||
4062: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
4063: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
4064: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
4065: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
4066: crtR11TxYZeroLast = crtR11TxYZero;
4067: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
4068: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
4069: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
4070: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
4071: crtAllStamp += 2;
4072: }
4073: crtDataY = 0;
4074: if (crtClearFrames != 0) {
4075: crtClearFrames--;
4076: } else if (crtClearStandby) {
4077: crtClearStandby = false;
4078: crtClearFrames = 1;
4079: }
4080: crtScreenY = 0;
4081: if (!XEiJ.PNL_USE_THREAD) {
4082: crtDirtyY0 = -1;
4083: }
4084: if (XEiJ.PNL_USE_THREAD) {
4085: crtAllStamp += 2;
4086: }
4087: if (SpriteScreen.SPR_THREE_STEPS) {
4088: SpriteScreen.sprActive = SpriteScreen.sprLatched;
4089: if (SpriteScreen.sprActive) {
4090: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
4091: SpriteScreen.sprLatched = false;
4092: }
4093: if (!XEiJ.PNL_USE_THREAD) {
4094: crtAllStamp += 2;
4095: }
4096:
4097: SpriteScreen.sprStep1 (0);
4098: SpriteScreen.sprSwap ();
4099:
4100:
4101: SpriteScreen.sprStep1 (1);
4102: SpriteScreen.sprSwap ();
4103: SpriteScreen.sprStep2 (0);
4104: }
4105: }
4106: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4107: crtStereoscopicStart ();
4108: }
4109: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);
4110: }
4111: } else {
4112:
4113: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4114: }
4115: }
4116: };
4117:
4118: public static final TickerQueue.Ticker DupExceptSpDrawIdleSync = new TickerQueue.Ticker () {
4119: @Override protected void tick () {
4120: MC68901.mfpHsyncRise ();
4121: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleBackDisp, crtClock += crtHSyncLength);
4122: }
4123: };
4124:
4125: public static final TickerQueue.Ticker DupExceptSpDrawIdleBackDisp = new TickerQueue.Ticker () {
4126: @Override protected void tick () {
4127: MC68901.mfpHsyncFall ();
4128: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleFront, crtClock += crtHBackDispLength);
4129: }
4130: };
4131:
4132: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenFront = new TickerQueue.Ticker () {
4133: @Override protected void tick () {
4134: int n = ++crtRasterNumber;
4135: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4136: if (crtRasterCopyOn) {
4137: crtDoRasterCopy ();
4138: }
4139: if (RasterBreakPoint.RBP_ON) {
4140: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4141: RasterBreakPoint.rbpFire ();
4142: }
4143: }
4144: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4145: if (irq != MC68901.mfpGpipRint) {
4146: if (irq == 0) {
4147: if (RasterBreakPoint.RBP_ON) {
4148: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4149: RasterBreakPoint.rbpFire ();
4150: }
4151: }
4152: MC68901.mfpRintFall ();
4153: } else {
4154: MC68901.mfpRintRise ();
4155: }
4156: }
4157: if (n != crtVIdleStart) {
4158: if (crtBeginningAllStamp != crtAllStamp) {
4159: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4160: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4161: crtStereoscopicDrawRaster (crtScreenY);
4162: }
4163: }
4164: crtScreenY++;
4165: crtDataY++;
4166: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);
4167: } else {
4168: if (crtBeginningAllStamp != crtAllStamp) {
4169: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4170: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4171: crtStereoscopicDrawRaster (crtScreenY);
4172: }
4173: }
4174: MC68901.mfpVdispFall ();
4175: if (!XEiJ.PNL_USE_THREAD) {
4176: if (crtDirtyY0 >= 0) {
4177: crtUpdateScreen ();
4178: if (CRT_ENABLE_INTERMITTENT) {
4179: crtIntermittentCounter = crtIntermittentInterval;
4180: }
4181: }
4182: }
4183: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4184: crtDoFrameTask ();
4185: }
4186: if (XEiJ.PNL_USE_THREAD) {
4187: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4188: }
4189: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4190: }
4191: } else {
4192:
4193: if (crtBeginningAllStamp != crtAllStamp) {
4194: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4195: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4196: crtStereoscopicDrawRaster (crtScreenY);
4197: }
4198: }
4199: crtScreenY++;
4200: crtDataY++;
4201: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenSync, crtClock += crtHFrontLength);
4202: }
4203: }
4204: };
4205:
4206: public static final TickerQueue.Ticker DupExceptSpDrawDispOddFront = new TickerQueue.Ticker () {
4207: @Override protected void tick () {
4208: int n = ++crtRasterNumber;
4209: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4210: if (crtRasterCopyOn) {
4211: crtDoRasterCopy ();
4212: }
4213: if (RasterBreakPoint.RBP_ON) {
4214: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4215: RasterBreakPoint.rbpFire ();
4216: }
4217: }
4218: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4219: if (irq != MC68901.mfpGpipRint) {
4220: if (irq == 0) {
4221: if (RasterBreakPoint.RBP_ON) {
4222: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4223: RasterBreakPoint.rbpFire ();
4224: }
4225: }
4226: MC68901.mfpRintFall ();
4227: } else {
4228: MC68901.mfpRintRise ();
4229: }
4230: }
4231: if (n != crtVIdleStart) {
4232: if (crtBeginningAllStamp != crtAllStamp) {
4233: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4234: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4235: crtStereoscopicDrawRaster (crtScreenY);
4236: }
4237: }
4238: crtScreenY++;
4239: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddSync, crtClock += crtHFrontLength);
4240: } else {
4241: if (crtBeginningAllStamp != crtAllStamp) {
4242: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4243: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4244: crtStereoscopicDrawRaster (crtScreenY);
4245: }
4246: }
4247: MC68901.mfpVdispFall ();
4248: if (!XEiJ.PNL_USE_THREAD) {
4249: if (crtDirtyY0 >= 0) {
4250: crtUpdateScreen ();
4251: if (CRT_ENABLE_INTERMITTENT) {
4252: crtIntermittentCounter = crtIntermittentInterval;
4253: }
4254: }
4255: }
4256: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4257: crtDoFrameTask ();
4258: }
4259: if (XEiJ.PNL_USE_THREAD) {
4260: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4261: }
4262: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawIdleSync, crtClock += crtHFrontLength);
4263: }
4264: } else {
4265:
4266: if (crtBeginningAllStamp != crtAllStamp) {
4267: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
4268: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4269: crtStereoscopicDrawRaster (crtScreenY);
4270: }
4271: }
4272: crtScreenY++;
4273: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddSync, crtClock += crtHFrontLength);
4274: }
4275: }
4276: };
4277:
4278: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenSync = new TickerQueue.Ticker () {
4279: @Override protected void tick () {
4280: MC68901.mfpHsyncRise ();
4281: if (crtClearFrames != 0) {
4282: crtRapidClear (crtDataY);
4283: crtRasterStamp[crtDataY] = 0;
4284: }
4285: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenBack, crtClock += crtHSyncLength);
4286: }
4287: };
4288:
4289: public static final TickerQueue.Ticker DupExceptSpDrawDispOddSync = new TickerQueue.Ticker () {
4290: @Override protected void tick () {
4291: MC68901.mfpHsyncRise ();
4292: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddBack, crtClock += crtHSyncLength);
4293: }
4294: };
4295:
4296: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenBack = new TickerQueue.Ticker () {
4297: @Override protected void tick () {
4298: MC68901.mfpHsyncFall ();
4299: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenDisp, crtClock += crtHBackLength);
4300: }
4301: };
4302:
4303: public static final TickerQueue.Ticker DupExceptSpDrawDispOddBack = new TickerQueue.Ticker () {
4304: @Override protected void tick () {
4305: MC68901.mfpHsyncFall ();
4306: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddDisp, crtClock += crtHBackLength);
4307: }
4308: };
4309:
4310: public static final TickerQueue.Ticker DupExceptSpDrawDispEvenDisp = new TickerQueue.Ticker () {
4311: @Override protected void tick () {
4312: if (crtRasterStamp[crtDataY] != crtAllStamp) {
4313: crtBeginningAllStamp = crtAllStamp;
4314: if (Malfunction.MLF_ON) {
4315: Malfunction.mlfRaster (crtDataY);
4316: }
4317: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
4318: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4319: crtStereoscopicDrawRaster (crtScreenY);
4320: }
4321: if (!XEiJ.PNL_USE_THREAD) {
4322: if (crtDirtyY0 < 0) {
4323: crtDirtyY0 = crtScreenY;
4324: }
4325: crtDirtyY1 = crtScreenY;
4326: }
4327: }
4328: if (SpriteScreen.SPR_THREE_STEPS) {
4329: if (SpriteScreen.sprActive) {
4330:
4331:
4332: SpriteScreen.sprStep1 (crtScreenY + 2);
4333: SpriteScreen.sprSwap ();
4334: SpriteScreen.sprStep2 (crtScreenY + 1);
4335: }
4336: }
4337: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispOddFront, crtClock += crtHDispLength);
4338: }
4339: };
4340:
4341: public static final TickerQueue.Ticker DupExceptSpDrawDispOddDisp = new TickerQueue.Ticker () {
4342: @Override protected void tick () {
4343: if (crtRasterStamp[crtDataY] != crtAllStamp) {
4344: crtRasterStamp[crtDataY] = crtAllStamp;
4345: crtBeginningAllStamp = crtAllStamp;
4346: if (Malfunction.MLF_ON) {
4347: Malfunction.mlfRaster (crtDataY);
4348: }
4349: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
4350: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4351: crtStereoscopicDrawRaster (crtScreenY);
4352: }
4353: if (!XEiJ.PNL_USE_THREAD) {
4354: if (crtDirtyY0 < 0) {
4355: crtDirtyY0 = crtScreenY;
4356: }
4357: crtDirtyY1 = crtScreenY;
4358: }
4359: }
4360: if (SpriteScreen.SPR_THREE_STEPS) {
4361: if (SpriteScreen.sprActive) {
4362:
4363:
4364: SpriteScreen.sprStep1 (crtScreenY + 2);
4365: SpriteScreen.sprSwap ();
4366: SpriteScreen.sprStep2 (crtScreenY + 1);
4367: }
4368: }
4369: TickerQueue.tkqAdd (crtTicker = DupExceptSpDrawDispEvenFront, crtClock += crtHDispLength);
4370: }
4371: };
4372:
4373: public static final TickerQueue.Ticker DupExceptSpOmitIdleFront = new TickerQueue.Ticker () {
4374: @Override protected void tick () {
4375: int n = ++crtRasterNumber;
4376: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
4377: if (crtR04VFrontEndCurr < n) {
4378: n = crtRasterNumber = 0;
4379: }
4380: if (crtRasterCopyOn) {
4381: crtDoRasterCopy ();
4382: }
4383: if (RasterBreakPoint.RBP_ON) {
4384: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4385: RasterBreakPoint.rbpFire ();
4386: }
4387: }
4388: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4389: if (irq != MC68901.mfpGpipRint) {
4390: if (irq == 0) {
4391: if (RasterBreakPoint.RBP_ON) {
4392: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4393: RasterBreakPoint.rbpFire ();
4394: }
4395: }
4396: MC68901.mfpRintFall ();
4397: } else {
4398: MC68901.mfpRintRise ();
4399: }
4400: }
4401: if (n != crtVDispStart) {
4402: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4403: } else {
4404: MC68901.mfpVdispRise ();
4405: crtR11TxYZero = crtR11TxYCurr;
4406: crtR13GrYZero[0] = crtR13GrYCurr[0];
4407: crtR13GrYZero[1] = crtR13GrYCurr[1];
4408: crtR13GrYZero[2] = crtR13GrYCurr[2];
4409: crtR13GrYZero[3] = crtR13GrYCurr[3];
4410: if (crtR11TxYZeroLast != crtR11TxYZero ||
4411: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
4412: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
4413: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
4414: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
4415: crtR11TxYZeroLast = crtR11TxYZero;
4416: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
4417: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
4418: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
4419: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
4420: crtAllStamp += 2;
4421: }
4422: crtDataY = 0;
4423: if (crtClearFrames != 0) {
4424: crtClearFrames--;
4425: } else if (crtClearStandby) {
4426: crtClearStandby = false;
4427: crtClearFrames = 1;
4428: }
4429: if (XEiJ.PNL_USE_THREAD) {
4430: crtAllStamp += 2;
4431: }
4432: if (SpriteScreen.SPR_THREE_STEPS) {
4433: SpriteScreen.sprActive = SpriteScreen.sprLatched;
4434: if (SpriteScreen.sprActive) {
4435: if ((SpriteScreen.sprReg4BgCtrlCurr & 512) == 0) {
4436: SpriteScreen.sprLatched = false;
4437: }
4438: if (!XEiJ.PNL_USE_THREAD) {
4439: crtAllStamp += 2;
4440: }
4441:
4442: SpriteScreen.sprStep1 (0);
4443: SpriteScreen.sprSwap ();
4444:
4445:
4446: SpriteScreen.sprStep1 (1);
4447: SpriteScreen.sprSwap ();
4448: SpriteScreen.sprStep2 (0);
4449: }
4450: }
4451: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
4452: crtStereoscopicStart ();
4453: }
4454: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);
4455: }
4456: } else {
4457:
4458: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4459: }
4460: }
4461: };
4462:
4463: public static final TickerQueue.Ticker DupExceptSpOmitIdleSync = new TickerQueue.Ticker () {
4464: @Override protected void tick () {
4465: MC68901.mfpHsyncRise ();
4466: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleBackDisp, crtClock += crtHSyncLength);
4467: }
4468: };
4469:
4470: public static final TickerQueue.Ticker DupExceptSpOmitIdleBackDisp = new TickerQueue.Ticker () {
4471: @Override protected void tick () {
4472: MC68901.mfpHsyncFall ();
4473: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleFront, crtClock += crtHBackDispLength);
4474: }
4475: };
4476:
4477: public static final TickerQueue.Ticker DupExceptSpOmitDispEvenFront = new TickerQueue.Ticker () {
4478: @Override protected void tick () {
4479: int n = ++crtRasterNumber;
4480: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4481: if (crtRasterCopyOn) {
4482: crtDoRasterCopy ();
4483: }
4484: if (RasterBreakPoint.RBP_ON) {
4485: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4486: RasterBreakPoint.rbpFire ();
4487: }
4488: }
4489: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4490: if (irq != MC68901.mfpGpipRint) {
4491: if (irq == 0) {
4492: if (RasterBreakPoint.RBP_ON) {
4493: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4494: RasterBreakPoint.rbpFire ();
4495: }
4496: }
4497: MC68901.mfpRintFall ();
4498: } else {
4499: MC68901.mfpRintRise ();
4500: }
4501: }
4502: if (n != crtVIdleStart) {
4503: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);
4504: } else {
4505: MC68901.mfpVdispFall ();
4506: if (CRT_ENABLE_INTERMITTENT) {
4507: crtIntermittentCounter--;
4508: }
4509: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4510: crtDoFrameTask ();
4511: }
4512: if (XEiJ.PNL_USE_THREAD) {
4513: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4514: }
4515: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4516: }
4517: } else {
4518:
4519: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenSync, crtClock += crtHFrontLength);
4520: }
4521: }
4522: };
4523:
4524: public static final TickerQueue.Ticker DupExceptSpOmitDispOddFront = new TickerQueue.Ticker () {
4525: @Override protected void tick () {
4526: int n = ++crtRasterNumber;
4527: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
4528: if (crtRasterCopyOn) {
4529: crtDoRasterCopy ();
4530: }
4531: if (RasterBreakPoint.RBP_ON) {
4532: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
4533: RasterBreakPoint.rbpFire ();
4534: }
4535: }
4536: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
4537: if (irq != MC68901.mfpGpipRint) {
4538: if (irq == 0) {
4539: if (RasterBreakPoint.RBP_ON) {
4540: if (RasterBreakPoint.rbpIRQBreakEnabled) {
4541: RasterBreakPoint.rbpFire ();
4542: }
4543: }
4544: MC68901.mfpRintFall ();
4545: } else {
4546: MC68901.mfpRintRise ();
4547: }
4548: }
4549: if (n != crtVIdleStart) {
4550: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddSync, crtClock += crtHFrontLength);
4551: } else {
4552: MC68901.mfpVdispFall ();
4553: if (CRT_ENABLE_INTERMITTENT) {
4554: crtIntermittentCounter--;
4555: }
4556: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
4557: crtDoFrameTask ();
4558: }
4559: if (XEiJ.PNL_USE_THREAD) {
4560: XEiJ.pnlBM = XEiJ.pnlBMLeftArray[++XEiJ.pnlBMWrite & 3];
4561: }
4562: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitIdleSync, crtClock += crtHFrontLength);
4563: }
4564: } else {
4565:
4566: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddSync, crtClock += crtHFrontLength);
4567: }
4568: }
4569: };
4570:
4571: public static final TickerQueue.Ticker DupExceptSpOmitDispEvenSync = new TickerQueue.Ticker () {
4572: @Override protected void tick () {
4573: MC68901.mfpHsyncRise ();
4574: if (crtClearFrames != 0) {
4575: crtRapidClear (crtDataY);
4576: crtRasterStamp[crtDataY] = 0;
4577: }
4578: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenBackDisp, crtClock += crtHSyncLength);
4579: }
4580: };
4581:
4582: public static final TickerQueue.Ticker DupExceptSpOmitDispOddSync = new TickerQueue.Ticker () {
4583: @Override protected void tick () {
4584: MC68901.mfpHsyncRise ();
4585: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddBackDisp, crtClock += crtHSyncLength);
4586: }
4587: };
4588:
4589: public static final TickerQueue.Ticker DupExceptSpOmitDispEvenBackDisp = new TickerQueue.Ticker () {
4590: @Override protected void tick () {
4591: MC68901.mfpHsyncFall ();
4592: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispOddFront, crtClock += crtHBackDispLength);
4593: }
4594: };
4595:
4596: public static final TickerQueue.Ticker DupExceptSpOmitDispOddBackDisp = new TickerQueue.Ticker () {
4597: @Override protected void tick () {
4598: MC68901.mfpHsyncFall ();
4599: TickerQueue.tkqAdd (crtTicker = DupExceptSpOmitDispEvenFront, crtClock += crtHBackDispLength);
4600: }
4601: };
4602:
4603:
4604:
4605: }
4606:
4607:
4608: