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