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: public static final boolean CRT_INSTANT_DUPLICATION = false;
422:
423:
424:
425:
426: public static final boolean CRT_EXTENDED_GRAPHIC = true;
427: public static boolean crtExtendedGraphicRequest;
428: public static boolean crtExtendedGraphicOn;
429:
430:
431: public static final long CRT_RESTART_DELAY = XEiJ.TMR_FREQ / 5;
432:
433:
434:
435:
436:
437: public static final int CRT_R00_H_FRONT_END = 0x00e80000;
438: public static final int CRT_R01_H_SYNC_END = 0x00e80002;
439: public static final int CRT_R02_H_BACK_END = 0x00e80004;
440: public static final int CRT_R03_H_DISP_END = 0x00e80006;
441: public static final int CRT_R04_V_FRONT_END = 0x00e80008;
442: public static final int CRT_R05_V_SYNC_END = 0x00e8000a;
443: public static final int CRT_R06_V_BACK_END = 0x00e8000c;
444: public static final int CRT_R07_V_DISP_END = 0x00e8000e;
445: public static final int CRT_R08_ADJUST = 0x00e80010;
446: public static final int CRT_R09_IRQ_RASTER = 0x00e80012;
447: public static final int CRT_R10_TX_X = 0x00e80014;
448: public static final int CRT_R11_TX_Y = 0x00e80016;
449: public static final int CRT_R12_GR_X_0 = 0x00e80018;
450: public static final int CRT_R13_GR_Y_0 = 0x00e8001a;
451: public static final int CRT_R14_GR_X_1 = 0x00e8001c;
452: public static final int CRT_R15_GR_Y_1 = 0x00e8001e;
453: public static final int CRT_R16_GR_X_2 = 0x00e80020;
454: public static final int CRT_R17_GR_Y_2 = 0x00e80022;
455: public static final int CRT_R18_GR_X_3 = 0x00e80024;
456: public static final int CRT_R19_GR_Y_3 = 0x00e80026;
457: public static final int CRT_R20_MODE = 0x00e80028;
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470: public static final int CRT_R21_SELECT = 0x00e8002a;
471:
472:
473:
474:
475:
476:
477:
478:
479:
480: public static final int CRT_R22_BLOCK = 0x00e8002c;
481:
482: public static final int CRT_R23_MASK = 0x00e8002e;
483: public static final int CRT_R24 = 0x00e80030;
484: public static final int CRT_ACTION = 0x00e80480;
485:
486:
487:
488:
489:
490:
491:
492: public static final int[] CRT_OSCS = { 0, 0, 0, 0, 1, 1, 1, 2, 0, 0, 0, 0, 1, 1, 1, 2 };
493: public static final int[] CRT_DIVS = { 8, 4, 8, 8, 6, 3, 2, 2, 8, 4, 8, 8, 8, 4, 2, 2 };
494: public static final int CRT_MIN_FREQ = 10000000;
495: public static final int CRT_MAX_FREQ = 400000000;
496: public static final int[] CRT_DEFAULT_FREQS = { 38863632, 69551900, 50349800 };
497: public static final int[] crtFreqsRequest = new int[3];
498: public static final int[] crtFreqs = new int[3];
499:
500:
501:
502: public static int crtR00HFrontEndPort;
503: public static int crtR00HFrontEndMask;
504: public static int crtR00HFrontEndTest;
505: public static int crtR00HFrontEndCurr;
506: public static int crtR01HSyncEndPort;
507: public static int crtR01HSyncEndMask;
508: public static int crtR01HSyncEndTest;
509: public static int crtR01HSyncEndCurr;
510: public static int crtR02HBackEndPort;
511: public static int crtR02HBackEndMask;
512: public static int crtR02HBackEndTest;
513: public static int crtR02HBackEndCurr;
514: public static int crtR03HDispEndPort;
515: public static int crtR03HDispEndMask;
516: public static int crtR03HDispEndTest;
517: public static int crtR03HDispEndCurr;
518: public static int crtR04VFrontEndPort;
519: public static int crtR04VFrontEndMask;
520: public static int crtR04VFrontEndTest;
521: public static int crtR04VFrontEndCurr;
522: public static int crtR05VSyncEndPort;
523: public static int crtR05VSyncEndMask;
524: public static int crtR05VSyncEndTest;
525: public static int crtR05VSyncEndCurr;
526: public static int crtR06VBackEndPort;
527: public static int crtR06VBackEndMask;
528: public static int crtR06VBackEndTest;
529: public static int crtR06VBackEndCurr;
530: public static int crtVDispStart;
531: public static int crtR07VDispEndPort;
532: public static int crtR07VDispEndMask;
533: public static int crtR07VDispEndTest;
534: public static int crtR07VDispEndCurr;
535: public static int crtVIdleStart;
536: public static int crtR08Adjust;
537: public static int crtR09IRQRasterPort;
538: public static int crtR09IRQRasterMask;
539: public static int crtR09IRQRasterTest;
540: public static int crtR09IRQRasterCurr;
541: public static int crtR10TxXPort;
542: public static int crtR10TxXMask;
543: public static int crtR10TxXTest;
544: public static int crtR10TxXCurr;
545: public static int crtR11TxYPort;
546: public static int crtR11TxYMask;
547: public static int crtR11TxYTest;
548: public static int crtR11TxYCurr;
549: public static int crtR11TxYZero;
550: public static int crtR11TxYZeroLast;
551: public static final int[] crtR12GrXPort = new int[4];
552:
553:
554:
555: public static final int[] crtR12GrXMask = new int[4];
556: public static final int[] crtR12GrXTest = new int[4];
557: public static final int[] crtR12GrXCurr = new int[4];
558: public static final int[] crtR13GrYPort = new int[4];
559:
560:
561:
562: public static final int[] crtR13GrYMask = new int[4];
563: public static final int[] crtR13GrYTest = new int[4];
564: public static final int[] crtR13GrYCurr = new int[4];
565: public static final int[] crtR13GrYZero = new int[4];
566: public static final int[] crtR13GrYZeroLast = new int[4];
567: public static int crtTextStorage;
568: public static int crtGraphicStorage;
569: public static int crtMemoryModePort;
570: public static int crtMemoryModeMask;
571: public static int crtMemoryModeTest;
572: public static int crtMemoryModeCurr;
573: public static int crtHighResoPort;
574: public static int crtHighResoMask;
575: public static int crtHighResoTest;
576: public static int crtHighResoCurr;
577: public static int crtVResoPort;
578: public static int crtVResoMask;
579: public static int crtVResoTest;
580: public static int crtVResoCurr;
581: public static int crtHResoPort;
582: public static int crtHResoMask;
583: public static int crtHResoTest;
584: public static int crtHResoCurr;
585: public static boolean crtCCPlane0;
586: public static boolean crtCCPlane1;
587: public static boolean crtCCPlane2;
588: public static boolean crtCCPlane3;
589: public static boolean crtSimPlane0;
590: public static boolean crtSimPlane1;
591: public static boolean crtSimPlane2;
592: public static boolean crtSimPlane3;
593: public static boolean crtSimAccess;
594: public static boolean crtBitMask;
595: public static int crtR22SrcBlock;
596: public static int crtR22DstBlock;
597: public static int crtR23Mask;
598: public static boolean crtRasterCopyOn;
599: public static boolean crtClearStandby;
600: public static int crtClearFrames;
601:
602: public static int crtHRLPort;
603: public static int crtHRLMask;
604: public static int crtHRLTest;
605: public static int crtHRLCurr;
606:
607: public static boolean crtDuplication;
608: public static boolean crtInterlace;
609: public static boolean crtSlit;
610: public static int crtColumnTime;
611: public static int crtHSyncLength;
612: public static int crtHBackLength;
613: public static int crtHDispLength;
614: public static int crtHFrontLength;
615: public static int crtHBackDispLength;
616:
617:
618:
619:
620:
621:
622:
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: public static int crtDirtyY0;
648: public static int crtDirtyY1;
649:
650: public static final int[] crtRasterStamp = new int[1024 + 15];
651: public static int crtAllStamp;
652:
653:
654:
655:
656:
657:
658:
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: public static int crtBeginningAllStamp;
700:
701: public static int crtRasterNumber;
702: public static int crtDataY;
703: public static int crtScreenY;
704: public static int crtFrameParity;
705:
706:
707:
708:
709:
710:
711:
712:
713:
714:
715:
716:
717:
718:
719:
720:
721:
722:
723:
724:
725:
726: public static final boolean CRT_RASTER_HASH_ON = true;
727: public static final long CRT_RASTER_HASH_ZERO = 0x0000000000000000L;
728: public static final long CRT_RASTER_HASH_MSB = 0x8000000000000000L;
729: public static long crtRasterHashIdle;
730: public static long crtRasterHashDisp;
731:
732:
733:
734:
735:
736: public static TickerQueue.Ticker crtTicker;
737: public static long crtClock;
738:
739: public static long crtContrastClock;
740: public static long crtCaptureClock;
741: public static long crtFrameTaskClock;
742:
743:
744:
745:
746:
747:
748:
749:
750:
751:
752:
753:
754:
755:
756:
757:
758:
759:
760:
761:
762:
763:
764:
765:
766:
767:
768: public static final boolean CRT_ENABLE_INTERMITTENT = true;
769: public static int crtIntermittentInterval;
770: public static int crtIntermittentCounter;
771:
772:
773: enum ScanlineEffect {
774: OFF {
775: @Override public void drawRaster (int screenY) {
776: int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
777: System.arraycopy (XEiJ.pnlBM, da - XEiJ.PNL_BM_WIDTH,
778: XEiJ.pnlBM, da,
779: XEiJ.pnlScreenWidth);
780: }
781: },
782: WEAK {
783: @Override public void drawRaster (int screenY) {
784: int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
785: int db = da + XEiJ.pnlScreenWidth;
786: while (da < db) {
787: int t;
788: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH )];
789: XEiJ.pnlBM[da ] = t - ((t >> 3) & 0x001f1f1f);
790: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 1)];
791: XEiJ.pnlBM[da + 1] = t - ((t >> 3) & 0x001f1f1f);
792: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 2)];
793: XEiJ.pnlBM[da + 2] = t - ((t >> 3) & 0x001f1f1f);
794: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 3)];
795: XEiJ.pnlBM[da + 3] = t - ((t >> 3) & 0x001f1f1f);
796: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 4)];
797: XEiJ.pnlBM[da + 4] = t - ((t >> 3) & 0x001f1f1f);
798: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 5)];
799: XEiJ.pnlBM[da + 5] = t - ((t >> 3) & 0x001f1f1f);
800: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 6)];
801: XEiJ.pnlBM[da + 6] = t - ((t >> 3) & 0x001f1f1f);
802: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 7)];
803: XEiJ.pnlBM[da + 7] = t - ((t >> 3) & 0x001f1f1f);
804: da += 8;
805: }
806: }
807: },
808: MEDIUM {
809: @Override public void drawRaster (int screenY) {
810: int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
811: int db = da + XEiJ.pnlScreenWidth;
812: while (da < db) {
813: int t;
814: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH )];
815: XEiJ.pnlBM[da ] = t - ((t >> 2) & 0x003f3f3f);
816: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 1)];
817: XEiJ.pnlBM[da + 1] = t - ((t >> 2) & 0x003f3f3f);
818: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 2)];
819: XEiJ.pnlBM[da + 2] = t - ((t >> 2) & 0x003f3f3f);
820: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 3)];
821: XEiJ.pnlBM[da + 3] = t - ((t >> 2) & 0x003f3f3f);
822: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 4)];
823: XEiJ.pnlBM[da + 4] = t - ((t >> 2) & 0x003f3f3f);
824: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 5)];
825: XEiJ.pnlBM[da + 5] = t - ((t >> 2) & 0x003f3f3f);
826: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 6)];
827: XEiJ.pnlBM[da + 6] = t - ((t >> 2) & 0x003f3f3f);
828: t = XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 7)];
829: XEiJ.pnlBM[da + 7] = t - ((t >> 2) & 0x003f3f3f);
830: da += 8;
831: }
832: }
833: },
834: STRONG {
835: @Override public void drawRaster (int screenY) {
836: int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
837: int db = da + XEiJ.pnlScreenWidth;
838: while (da < db) {
839: XEiJ.pnlBM[da ] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH )] >> 1) & 0xff7f7f7f;
840: XEiJ.pnlBM[da + 1] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 1)] >> 1) & 0xff7f7f7f;
841: XEiJ.pnlBM[da + 2] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 2)] >> 1) & 0xff7f7f7f;
842: XEiJ.pnlBM[da + 3] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 3)] >> 1) & 0xff7f7f7f;
843: XEiJ.pnlBM[da + 4] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 4)] >> 1) & 0xff7f7f7f;
844: XEiJ.pnlBM[da + 5] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 5)] >> 1) & 0xff7f7f7f;
845: XEiJ.pnlBM[da + 6] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 6)] >> 1) & 0xff7f7f7f;
846: XEiJ.pnlBM[da + 7] = (XEiJ.pnlBM[da - (XEiJ.PNL_BM_WIDTH - 7)] >> 1) & 0xff7f7f7f;
847: da += 8;
848: }
849: }
850: },
851: BLACK {
852: @Override public void drawRaster (int screenY) {
853: int da = screenY << XEiJ.PNL_BM_OFFSET_BITS;
854: int db = da + XEiJ.pnlScreenWidth;
855: Arrays.fill (XEiJ.pnlBM,
856: da,
857: db,
858: 0xff000000);
859: }
860: };
861: public abstract void drawRaster (int screenY);
862: }
863: public static ScanlineEffect crtScanlineEffect;
864:
865:
866:
867:
868: public static boolean crtEleventhBitRequest;
869: public static boolean crtEleventhBit;
870: public static int crtVerticalMask;
871:
872:
873:
874:
875:
876:
877: public static boolean crtSphericalScrolling;
878: public static int crtMask3;
879: public static int crtMaskMinus4;
880: public static int crtMask511;
881: public static void crtSetSphericalScrolling (boolean spherical) {
882: crtSphericalScrolling = spherical;
883: crtMask3 = spherical ? 0 : 3;
884: crtMaskMinus4 = ~crtMask3;
885: crtMask511 = crtMask3 << 7 | 127;
886: crtAllStamp += 2;
887: }
888:
889:
890: public static boolean crtR00Bit0Zero;
891:
892:
893:
894: public static void crtInit () {
895:
896:
897:
898:
899:
900:
901:
902:
903:
904:
905:
906:
907:
908:
909:
910:
911: switch (Settings.sgsGetString ("scanline").toLowerCase ()) {
912: case "off":
913: crtScanlineEffect = ScanlineEffect.OFF;
914: break;
915: case "weak":
916: crtScanlineEffect = ScanlineEffect.WEAK;
917: break;
918: case "medium":
919: crtScanlineEffect = ScanlineEffect.MEDIUM;
920: break;
921: case "strong":
922: crtScanlineEffect = ScanlineEffect.STRONG;
923: break;
924: case "black":
925: crtScanlineEffect = ScanlineEffect.BLACK;
926: break;
927: }
928:
929:
930: {
931: String[] a = (Settings.sgsGetString ("dotclock") + ",,,0").split (",");
932: for (int i = 0; i < 3; i++) {
933: int freq = -1;
934: try {
935: freq = Integer.parseInt (a[i], 10);
936: } catch (NumberFormatException nfe) {
937: }
938: crtFreqsRequest[i] = CRT_MIN_FREQ <= freq && freq <= CRT_MAX_FREQ ? freq : CRT_DEFAULT_FREQS[i];
939: }
940: }
941:
942:
943: crtEleventhBitRequest = Settings.sgsGetOnOff ("eleventhbit");
944:
945:
946: crtSphericalScrolling = Settings.sgsGetOnOff ("sphericalscrolling");
947: crtMask3 = 3;
948: crtMaskMinus4 = -4;
949: crtMask511 = 511;
950:
951:
952: crtR00Bit0Zero = Settings.sgsGetOnOff ("r00bit0zero");
953:
954: if (true) {
955: crtCCPlane0 = false;
956: crtCCPlane1 = false;
957: crtCCPlane2 = false;
958: crtCCPlane3 = false;
959: crtSimPlane0 = false;
960: crtSimPlane1 = false;
961: crtSimPlane2 = false;
962: crtSimPlane3 = false;
963: crtSimAccess = false;
964: crtBitMask = false;
965: }
966: crtReset ();
967: }
968:
969:
970:
971: public static void crtTini () {
972:
973:
974: Settings.sgsPutString ("scanline",
975: crtScanlineEffect == ScanlineEffect.OFF ? "off" :
976: crtScanlineEffect == ScanlineEffect.WEAK ? "weak" :
977: crtScanlineEffect == ScanlineEffect.MEDIUM ? "medium" :
978: crtScanlineEffect == ScanlineEffect.STRONG ? "strong" :
979: crtScanlineEffect == ScanlineEffect.BLACK ? "black" :
980: "");
981:
982:
983: {
984: StringBuilder sb = new StringBuilder ();
985: for (int i = 0; i < 3; i++) {
986: if (0 < i) {
987: sb.append (',');
988: }
989: if (crtFreqsRequest[i] != CRT_DEFAULT_FREQS[i]) {
990: sb.append (crtFreqsRequest[i]);
991: }
992: }
993: Settings.sgsPutString ("dotclock", sb.toString ());
994: }
995:
996:
997: Settings.sgsPutOnOff ("eleventhbit", crtEleventhBitRequest);
998:
999:
1000: Settings.sgsPutOnOff ("sphericalscrolling", crtSphericalScrolling);
1001:
1002:
1003: Settings.sgsPutOnOff ("r00bit0zero", crtR00Bit0Zero);
1004:
1005: }
1006:
1007:
1008:
1009:
1010:
1011:
1012:
1013:
1014: public static void crtReset () {
1015: if (CRT_EXTENDED_GRAPHIC) {
1016: crtExtendedGraphicOn = crtExtendedGraphicRequest;
1017: if (crtExtendedGraphicOn) {
1018: System.out.println (Multilingual.mlnJapanese ?
1019: "拡張グラフィック画面が有効になりました" :
1020: "Extended graphic screen has been activated");
1021: }
1022: }
1023:
1024:
1025: for (int i = 0; i < 3; i++) {
1026: crtFreqs[i] = crtFreqsRequest[i];
1027: }
1028:
1029:
1030: crtEleventhBit = crtEleventhBitRequest;
1031: crtVerticalMask = crtEleventhBit ? 0x07ff : 0x03ff;
1032:
1033: crtR00HFrontEndPort = 0;
1034: crtR00HFrontEndMask = 0;
1035: crtR00HFrontEndTest = 0;
1036: crtR00HFrontEndCurr = 0;
1037: crtR01HSyncEndPort = 0;
1038: crtR01HSyncEndMask = 0;
1039: crtR01HSyncEndTest = 0;
1040: crtR01HSyncEndCurr = 0;
1041: crtR02HBackEndPort = 0;
1042: crtR02HBackEndMask = 0;
1043: crtR02HBackEndTest = 0;
1044: crtR02HBackEndCurr = 0;
1045: crtR03HDispEndPort = 0;
1046: crtR03HDispEndMask = 0;
1047: crtR03HDispEndTest = 0;
1048: crtR03HDispEndCurr = 0;
1049: crtR04VFrontEndPort = 0;
1050: crtR04VFrontEndMask = 0;
1051: crtR04VFrontEndTest = 0;
1052: crtR04VFrontEndCurr = 0;
1053: crtR05VSyncEndPort = 0;
1054: crtR05VSyncEndMask = 0;
1055: crtR05VSyncEndTest = 0;
1056: crtR05VSyncEndCurr = 0;
1057: crtR06VBackEndPort = 0;
1058: crtR06VBackEndMask = 0;
1059: crtR06VBackEndTest = 0;
1060: crtR06VBackEndCurr = 0;
1061: crtVDispStart = 0;
1062: crtR07VDispEndPort = 0;
1063: crtR07VDispEndMask = 0;
1064: crtR07VDispEndTest = 0;
1065: crtR07VDispEndCurr = 0;
1066: crtVIdleStart = 0;
1067: crtR08Adjust = 0;
1068: crtR09IRQRasterPort = 1023;
1069: crtR09IRQRasterMask = 0;
1070: crtR09IRQRasterTest = 1023;
1071: crtR09IRQRasterCurr = 1023;
1072: crtR10TxXPort = 0;
1073: crtR10TxXMask = 0;
1074: crtR10TxXTest = 0;
1075: crtR10TxXCurr = 0;
1076: crtR11TxYPort = 0;
1077: crtR11TxYMask = 0;
1078: crtR11TxYTest = 0;
1079: crtR11TxYCurr = 0;
1080: crtR11TxYZero = 0;
1081: crtR11TxYZeroLast = -1;
1082: for (int i = 0; i < 4; i++) {
1083: crtR12GrXPort[i] = 0;
1084: crtR12GrXMask[i] = 0;
1085: crtR12GrXTest[i] = 0;
1086: crtR12GrXCurr[i] = 0;
1087: crtR13GrYPort[i] = 0;
1088: crtR13GrYMask[i] = 0;
1089: crtR13GrYTest[i] = 0;
1090: crtR13GrYCurr[i] = 0;
1091: crtR13GrYZero[i] = 0;
1092: crtR13GrYZeroLast[i] = -1;
1093: }
1094: crtTextStorage = 0;
1095: crtGraphicStorage = 0;
1096: crtMemoryModePort = 0;
1097: crtMemoryModeMask = 0;
1098: crtMemoryModeTest = 0;
1099: crtMemoryModeCurr = 0;
1100: crtHighResoPort = 0;
1101: crtHighResoMask = 0;
1102: crtHighResoTest = 0;
1103: crtHighResoCurr = 0;
1104: crtVResoPort = 0;
1105: crtVResoMask = 0;
1106: crtVResoTest = 0;
1107: crtVResoCurr = 0;
1108: crtHResoPort = 0;
1109: crtHResoMask = 0;
1110: crtHResoTest = 0;
1111: crtHResoCurr = 0;
1112: if (false) {
1113: crtCCPlane0 = false;
1114: crtCCPlane1 = false;
1115: crtCCPlane2 = false;
1116: crtCCPlane3 = false;
1117: crtSimPlane0 = false;
1118: crtSimPlane1 = false;
1119: crtSimPlane2 = false;
1120: crtSimPlane3 = false;
1121: crtSimAccess = false;
1122: crtBitMask = false;
1123: }
1124: crtR22SrcBlock = 0;
1125: crtR22DstBlock = 0;
1126: crtR23Mask = 0x0000;
1127: crtRasterCopyOn = false;
1128: crtClearStandby = false;
1129: crtClearFrames = 0;
1130:
1131: crtHRLPort = 0;
1132: crtHRLMask = 0;
1133: crtHRLTest = 0;
1134: crtHRLCurr = 0;
1135: XEiJ.pnlStretchMode = 1.0F;
1136: XEiJ.pnlStereoscopicShutter = 0;
1137: crtDuplication = false;
1138: crtInterlace = false;
1139: crtSlit = false;
1140: crtColumnTime = 0;
1141: crtHSyncLength = 0;
1142: crtHBackLength = 0;
1143: crtHDispLength = 0;
1144: crtHFrontLength = 0;
1145: crtHBackDispLength = 0;
1146:
1147: crtDirtyY0 = -1;
1148: crtDirtyY1 = -1;
1149:
1150: Arrays.fill (crtRasterStamp, 0);
1151: crtAllStamp = 1;
1152:
1153: crtBeginningAllStamp = 1;
1154:
1155: crtRasterNumber = 0;
1156: crtDataY = 0;
1157: crtScreenY = 0;
1158: crtFrameParity = 0;
1159:
1160: crtRasterHashIdle = CRT_RASTER_HASH_ZERO;
1161: crtRasterHashDisp = CRT_RASTER_HASH_ZERO;
1162:
1163: crtContrastClock = XEiJ.FAR_FUTURE;
1164: crtCaptureClock = XEiJ.FAR_FUTURE;
1165: crtFrameTaskClock = Math.min (crtContrastClock, crtCaptureClock);
1166:
1167: if (CRT_ENABLE_INTERMITTENT) {
1168:
1169: crtIntermittentCounter = 0;
1170: }
1171:
1172: if (crtTicker != null) {
1173: TickerQueue.tkqRemove (crtTicker);
1174: crtTicker = null;
1175: }
1176: crtClock = XEiJ.FAR_FUTURE;
1177:
1178: }
1179:
1180:
1181:
1182: public static void crtRestart () {
1183: if (crtTicker != null) {
1184: TickerQueue.tkqRemove (crtTicker);
1185: }
1186: TickerQueue.tkqAdd (crtTicker = InitialStage, crtClock = XEiJ.mpuClockTime + CRT_RESTART_DELAY);
1187: }
1188:
1189:
1190:
1191: public static void crtStereoscopicStart () {
1192: XEiJ.pnlBM = (XEiJ.pnlStereoscopicShutter != 1 ? XEiJ.pnlBMLeft :
1193: XEiJ.pnlBMRight);
1194: crtAllStamp += 2;
1195: }
1196:
1197:
1198:
1199: public static void crtStereoscopicDrawRaster (int screenY) {
1200: if (XEiJ.pnlStereoscopicShutter == 0 ||
1201: XEiJ.pnlStereoscopicShutter == 3) {
1202: System.arraycopy (XEiJ.pnlBMLeft, screenY << XEiJ.PNL_BM_OFFSET_BITS,
1203: XEiJ.pnlBMRight, screenY << XEiJ.PNL_BM_OFFSET_BITS,
1204: XEiJ.pnlScreenWidth);
1205: }
1206: }
1207:
1208:
1209:
1210: public static void crtUpdateScreen () {
1211: if (XEiJ.pnlZoomRatioOut == 1 << 16) {
1212: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1 + crtDirtyY0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, crtDirtyY1 - crtDirtyY0 + 1);
1213: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
1214: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3 + crtDirtyY0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, crtDirtyY1 - crtDirtyY0 + 1);
1215: }
1216: } else {
1217: int y0 = (crtDirtyY0 - 1) * XEiJ.pnlZoomRatioOut >> 16;
1218: int y1 = (crtDirtyY1 + 2) * (XEiJ.pnlZoomRatioOut + 1) >> 16;
1219: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1 + y0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, y1 - y0);
1220: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
1221: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3 + y0, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, y1 - y0);
1222: }
1223: }
1224: crtDirtyY0 = -1;
1225: }
1226:
1227:
1228:
1229:
1230:
1231:
1232: public static void crtRepaint () {
1233: crtBeginningAllStamp = crtAllStamp;
1234: int l = Math.max (0, Math.min (1024, crtR07VDispEndCurr - crtR06VBackEndCurr));
1235: if (crtDuplication) {
1236: for (int screenY = 0; screenY < l; screenY += 2) {
1237: if (SpriteScreen.SPR_THREE_STEPS) {
1238: SpriteScreen.sprStep1 (screenY >> 1);
1239: SpriteScreen.sprStep2 (screenY >> 1);
1240: }
1241: VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);
1242: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1243: crtStereoscopicDrawRaster (screenY);
1244: }
1245:
1246: System.arraycopy (XEiJ.pnlBM, screenY << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlBM, screenY + 1 << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlScreenWidth);
1247: }
1248: } else if (crtSlit) {
1249: for (int screenY = 0; screenY < l; screenY += 2) {
1250: if (SpriteScreen.SPR_THREE_STEPS) {
1251: SpriteScreen.sprStep1 (screenY >> 1);
1252: SpriteScreen.sprStep2 (screenY >> 1);
1253: }
1254: VideoController.vcnMode.drawRaster (screenY >> 1, screenY, false);
1255: crtScanlineEffect.drawRaster (screenY + 1);
1256: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1257: crtStereoscopicDrawRaster (screenY);
1258: crtStereoscopicDrawRaster (screenY + 1);
1259: }
1260: }
1261: } else {
1262: for (int screenY = 0; screenY < l; screenY++) {
1263: if (SpriteScreen.SPR_THREE_STEPS) {
1264: SpriteScreen.sprStep1 (screenY);
1265: SpriteScreen.sprStep2 (screenY);
1266: }
1267: VideoController.vcnMode.drawRaster (screenY, screenY, false);
1268: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1269: crtStereoscopicDrawRaster (screenY);
1270: }
1271: }
1272: }
1273: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY1, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, l);
1274: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn && XEiJ.pnlStereoscopicMethod == XEiJ.PNL_TOP_AND_BOTTOM) {
1275: XEiJ.pnlPanel.repaint (0L, XEiJ.pnlScreenX1, XEiJ.pnlScreenY3, XEiJ.pnlScreenX4 - XEiJ.pnlScreenX1, l);
1276: }
1277: }
1278:
1279:
1280:
1281:
1282:
1283:
1284: public static void crtDoFrameTask () {
1285: if (XEiJ.mpuClockTime >= crtContrastClock) {
1286: VideoController.vcnCurrentScaledContrast += VideoController.vcnCurrentScaledContrast < VideoController.vcnTargetScaledContrast ? 1 : -1;
1287: VideoController.vcnSetContrast (VideoController.vcnCurrentScaledContrast);
1288: if (VideoController.vcnCurrentScaledContrast == VideoController.vcnTargetScaledContrast) {
1289: crtContrastClock = XEiJ.FAR_FUTURE;
1290: } else {
1291: crtContrastClock += VideoController.VCN_CONTRAST_DELAY;
1292: }
1293: }
1294: if (XEiJ.mpuClockTime >= crtCaptureClock) {
1295: GIFAnimation.gifCaptureFrame ();
1296: }
1297: crtFrameTaskClock = Math.min (crtContrastClock, crtCaptureClock);
1298: }
1299:
1300:
1301:
1302:
1303:
1304: public static void crtSetMemoryMode (int textStorage, int graphicStorage, int memoryMode) {
1305: boolean updateMemoryMap = false;
1306: textStorage &= 1;
1307: if (crtTextStorage != textStorage) {
1308: crtTextStorage = textStorage;
1309: }
1310: graphicStorage &= 1;
1311: if (crtGraphicStorage != graphicStorage) {
1312: crtGraphicStorage = graphicStorage;
1313: updateMemoryMap = true;
1314: }
1315: memoryMode &= 7;
1316: crtMemoryModePort = memoryMode;
1317: int curr = crtMemoryModeMask == 0 ? crtMemoryModePort : crtMemoryModeTest;
1318: if (crtMemoryModeCurr != curr) {
1319: crtMemoryModeCurr = curr;
1320: updateMemoryMap = true;
1321: }
1322: if (updateMemoryMap) {
1323: if (crtGraphicStorage != 0) {
1324: if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn &&
1325: (crtMemoryModeCurr == 5 || crtMemoryModeCurr == 7)) {
1326:
1327: XEiJ.busSuper (MemoryMappedDevice.MMD_GJ0, 0x00c00000, 0x00e00000);
1328: } else {
1329:
1330: XEiJ.busSuper (MemoryMappedDevice.MMD_GG0, 0x00c00000, 0x00c80000);
1331: XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00c80000, 0x00e00000);
1332: }
1333: } else {
1334: switch (crtMemoryModeCurr) {
1335: case 0:
1336:
1337: XEiJ.busSuper (MemoryMappedDevice.MMD_GE0, 0x00c00000, 0x00c80000);
1338: XEiJ.busSuper (MemoryMappedDevice.MMD_GE1, 0x00c80000, 0x00d00000);
1339: XEiJ.busSuper (MemoryMappedDevice.MMD_GE2, 0x00d00000, 0x00d80000);
1340: XEiJ.busSuper (MemoryMappedDevice.MMD_GE3, 0x00d80000, 0x00e00000);
1341: break;
1342: case 1:
1343:
1344: XEiJ.busSuper (MemoryMappedDevice.MMD_GF0, 0x00c00000, 0x00c80000);
1345: XEiJ.busSuper (MemoryMappedDevice.MMD_GF1, 0x00c80000, 0x00d00000);
1346: XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00d00000, 0x00e00000);
1347: break;
1348: case 2:
1349:
1350: XEiJ.busSuper (MemoryMappedDevice.MMD_GM2, 0x00c00000, 0x00e00000);
1351: break;
1352: case 3:
1353:
1354: XEiJ.busSuper (MemoryMappedDevice.MMD_GG0, 0x00c00000, 0x00c80000);
1355: XEiJ.busSuper (MemoryMappedDevice.MMD_NUL, 0x00c80000, 0x00e00000);
1356: break;
1357: case 4:
1358:
1359: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1360: break;
1361: case 5:
1362: if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn) {
1363:
1364: XEiJ.busSuper (MemoryMappedDevice.MMD_GI0, 0x00c00000, 0x00e00000);
1365: } else {
1366:
1367: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1368: }
1369: break;
1370: case 6:
1371:
1372: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1373: break;
1374: case 7:
1375: if (CRT_EXTENDED_GRAPHIC && crtExtendedGraphicOn) {
1376:
1377: XEiJ.busSuper (MemoryMappedDevice.MMD_GJ0, 0x00c00000, 0x00e00000);
1378: } else {
1379:
1380: XEiJ.busSuper (MemoryMappedDevice.MMD_GH0, 0x00c00000, 0x00e00000);
1381: }
1382: break;
1383: }
1384: }
1385: }
1386: }
1387:
1388:
1389:
1390:
1391:
1392:
1393:
1394:
1395:
1396:
1397:
1398: public static void crtUpdateRasterHash () {
1399: if (CRT_RASTER_HASH_ON) {
1400: long t = crtRasterCopyOn ? ~CRT_RASTER_HASH_ZERO : CRT_RASTER_HASH_ZERO;
1401:
1402: if (RasterBreakPoint.RBP_ON && RasterBreakPoint.rbpActiveBreakRaster >= 0) {
1403: t |= CRT_RASTER_HASH_MSB >>> RasterBreakPoint.rbpActiveBreakRaster;
1404: }
1405: if (crtR09IRQRasterCurr <= crtR04VFrontEndCurr) {
1406: t |= (CRT_RASTER_HASH_MSB >>> crtR09IRQRasterCurr |
1407: CRT_RASTER_HASH_MSB >>> (crtR09IRQRasterCurr < crtR04VFrontEndCurr ? crtR09IRQRasterCurr + 1 : 0));
1408: }
1409: crtRasterHashIdle = (t |
1410: CRT_RASTER_HASH_MSB >>> crtVDispStart |
1411: CRT_RASTER_HASH_MSB >>> crtR04VFrontEndCurr + 1);
1412: crtRasterHashDisp = (t |
1413: CRT_RASTER_HASH_MSB >>> crtVIdleStart);
1414: }
1415: }
1416:
1417:
1418:
1419:
1420: public static void crtRapidClear (int y) {
1421: if (crtMemoryModeCurr >= 4) {
1422: int a = 0x00c00000 | (y + crtR13GrYZero[0] & 1023) << 1 + 10;
1423: Arrays.fill (MainMemory.mmrM8, a, a + 2 * 1024, (byte) 0);
1424: } else {
1425: if (crtCCPlane0) {
1426: int a = 0x00c00000 | (y + crtR13GrYZero[0] & 511) << 1 + 9;
1427: Arrays.fill (MainMemory.mmrM8, a, a + 2 * 512, (byte) 0);
1428: }
1429: if (crtCCPlane1) {
1430: int a = 0x00c80000 | (y + crtR13GrYZero[1] & 511) << 1 + 9;
1431: Arrays.fill (MainMemory.mmrM8, a, a + 2 * 512, (byte) 0);
1432: }
1433: if (crtCCPlane2) {
1434: int a = 0x00d00000 | (y + crtR13GrYZero[2] & 511) << 1 + 9;
1435: Arrays.fill (MainMemory.mmrM8, a, a + 2 * 512, (byte) 0);
1436: }
1437: if (crtCCPlane3) {
1438: int a = 0x00d80000 | (y + crtR13GrYZero[3] & 511) << 1 + 9;
1439: Arrays.fill (MainMemory.mmrM8, a, a + 2 * 512, (byte) 0);
1440: }
1441: }
1442: }
1443:
1444:
1445:
1446: public static void crtDoRasterCopy () {
1447: int srcOffset = crtR22SrcBlock << 9;
1448: int dstOffset = crtR22DstBlock << 9;
1449: if (crtCCPlane0) {
1450: System.arraycopy (MainMemory.mmrM8, 0x00e00000 + srcOffset, MainMemory.mmrM8, 0x00e00000 + dstOffset, 512);
1451: }
1452: if (crtCCPlane1) {
1453: System.arraycopy (MainMemory.mmrM8, 0x00e20000 + srcOffset, MainMemory.mmrM8, 0x00e20000 + dstOffset, 512);
1454: }
1455: if (crtCCPlane2) {
1456: System.arraycopy (MainMemory.mmrM8, 0x00e40000 + srcOffset, MainMemory.mmrM8, 0x00e40000 + dstOffset, 512);
1457: }
1458: if (crtCCPlane3) {
1459: System.arraycopy (MainMemory.mmrM8, 0x00e60000 + srcOffset, MainMemory.mmrM8, 0x00e60000 + dstOffset, 512);
1460: }
1461: int y = (dstOffset >> 7) - crtR11TxYZero;
1462: crtRasterStamp[y & 1023] = 0;
1463: crtRasterStamp[y + 1 & 1023] = 0;
1464: crtRasterStamp[y + 2 & 1023] = 0;
1465: crtRasterStamp[y + 3 & 1023] = 0;
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:
1496:
1497:
1498:
1499:
1500:
1501:
1502:
1503:
1504:
1505:
1506:
1507:
1508:
1509:
1510:
1511:
1512:
1513:
1514:
1515:
1516:
1517:
1518:
1519:
1520:
1521:
1522:
1523:
1524:
1525:
1526:
1527:
1528:
1529:
1530:
1531:
1532:
1533:
1534:
1535:
1536:
1537:
1538:
1539:
1540:
1541:
1542:
1543:
1544:
1545:
1546:
1547:
1548:
1549:
1550:
1551:
1552:
1553:
1554:
1555:
1556:
1557:
1558:
1559:
1560:
1561:
1562:
1563:
1564:
1565:
1566:
1567:
1568:
1569:
1570:
1571:
1572:
1573:
1574:
1575:
1576:
1577:
1578:
1579:
1580:
1581:
1582:
1583:
1584:
1585:
1586:
1587:
1588:
1589:
1590:
1591:
1592:
1593:
1594:
1595:
1596:
1597:
1598:
1599:
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: public static final TickerQueue.Ticker InitialStage = new TickerQueue.Ticker () {
1735: @Override protected void tick () {
1736: ret:
1737: {
1738:
1739:
1740:
1741:
1742:
1743: if (!(crtR02HBackEndCurr < crtR03HDispEndCurr && crtR03HDispEndCurr - crtR02HBackEndCurr <= 128 &&
1744: crtR07VDispEndCurr < crtR04VFrontEndCurr && crtR07VDispEndCurr - crtR06VBackEndCurr <= 1024 &&
1745: crtR05VSyncEndCurr < crtR06VBackEndCurr &&
1746: crtR06VBackEndCurr < crtR07VDispEndCurr)) {
1747: crtRestart ();
1748: break ret;
1749: }
1750:
1751: if (CRT_RASTER_HASH_ON) {
1752: crtUpdateRasterHash ();
1753: }
1754:
1755:
1756:
1757:
1758:
1759:
1760: int hSync = crtR01HSyncEndCurr + 1;
1761: int hBack = crtR02HBackEndCurr - crtR01HSyncEndCurr + 4;
1762: int hDisp = crtR03HDispEndCurr - crtR02HBackEndCurr;
1763: int hFront = crtR00HFrontEndCurr - crtR03HDispEndCurr - 4;
1764: if (hSync + hBack + hDisp + hFront < hDisp + 3) {
1765: hSync = hBack = hFront = 1;
1766: } else {
1767: if (hBack <= 0) {
1768: hFront -= 1 - hBack;
1769: hBack = 1;
1770: if (hFront <= 0) {
1771: hSync -= 1 - hFront;
1772: hFront = 1;
1773: }
1774: } else if (hFront <= 0) {
1775: hBack -= 1 - hFront;
1776: hFront = 1;
1777: if (hBack <= 0) {
1778: hSync -= 1 - hBack;
1779: hBack = 1;
1780: }
1781: }
1782: }
1783: int k = crtHRLCurr << 3 | crtHighResoCurr << 2 | crtHResoCurr;
1784: crtColumnTime = (int) ((double) (XEiJ.TMR_FREQ * 8 * CRT_DIVS[k]) / (double) crtFreqs[CRT_OSCS[k]] + 0.5);
1785: crtHSyncLength = crtColumnTime * hSync;
1786: crtHBackLength = crtColumnTime * hBack;
1787: crtHDispLength = crtColumnTime * hDisp;
1788: crtHFrontLength = crtColumnTime * hFront;
1789: crtHBackDispLength = crtColumnTime * (hBack + hDisp);
1790:
1791: crtDuplication = crtHighResoCurr == 1 && crtVResoCurr == 0;
1792: crtInterlace = crtHighResoCurr + 1 <= crtVResoCurr;
1793: crtSlit = crtHighResoCurr == 0 && crtVResoCurr == 0;
1794:
1795: XEiJ.pnlUpdateArrangement ();
1796:
1797: crtAllStamp += 2;
1798: (crtDuplication ? DuplicationStart : crtInterlace ? InterlaceStart : crtSlit ? SlitStart : NormalStart).tick ();
1799: }
1800: }
1801: };
1802:
1803:
1804:
1805:
1806: public static final TickerQueue.Ticker NormalStart = new TickerQueue.Ticker () {
1807: @Override protected void tick () {
1808: if (MC68901.mfpGpipHsync != 0) {
1809: MC68901.mfpHsyncFall ();
1810: }
1811: int n = crtRasterNumber = crtVIdleStart;
1812: if (crtRasterCopyOn) {
1813: crtDoRasterCopy ();
1814: }
1815: if (RasterBreakPoint.RBP_ON) {
1816: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
1817: RasterBreakPoint.rbpFire ();
1818: }
1819: }
1820: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
1821: if (irq != MC68901.mfpGpipRint) {
1822: if (irq == 0) {
1823: if (RasterBreakPoint.RBP_ON) {
1824: if (RasterBreakPoint.rbpIRQBreakEnabled) {
1825: RasterBreakPoint.rbpFire ();
1826: }
1827: }
1828: MC68901.mfpRintFall ();
1829: } else {
1830: MC68901.mfpRintRise ();
1831: }
1832: }
1833: if (MC68901.mfpGpipVdisp != 0) {
1834: MC68901.mfpVdispFall ();
1835: }
1836: crtClearFrames = 0;
1837: if (CRT_ENABLE_INTERMITTENT) {
1838: crtIntermittentCounter = 0;
1839: }
1840: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
1841: crtDoFrameTask ();
1842: }
1843: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
1844: }
1845: };
1846:
1847: public static final TickerQueue.Ticker NormalDrawIdleFront = new TickerQueue.Ticker () {
1848: @Override protected void tick () {
1849: int n = ++crtRasterNumber;
1850: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
1851: if (crtR04VFrontEndCurr < n) {
1852: n = crtRasterNumber = 0;
1853: }
1854: if (crtRasterCopyOn) {
1855: crtDoRasterCopy ();
1856: }
1857: if (RasterBreakPoint.RBP_ON) {
1858: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
1859: RasterBreakPoint.rbpFire ();
1860: }
1861: }
1862: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
1863: if (irq != MC68901.mfpGpipRint) {
1864: if (irq == 0) {
1865: if (RasterBreakPoint.RBP_ON) {
1866: if (RasterBreakPoint.rbpIRQBreakEnabled) {
1867: RasterBreakPoint.rbpFire ();
1868: }
1869: }
1870: MC68901.mfpRintFall ();
1871: } else {
1872: MC68901.mfpRintRise ();
1873: }
1874: }
1875: if (n != crtVDispStart) {
1876: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
1877: } else {
1878: MC68901.mfpVdispRise ();
1879: crtR11TxYZero = crtR11TxYCurr;
1880: crtR13GrYZero[0] = crtR13GrYCurr[0];
1881: crtR13GrYZero[1] = crtR13GrYCurr[1];
1882: crtR13GrYZero[2] = crtR13GrYCurr[2];
1883: crtR13GrYZero[3] = crtR13GrYCurr[3];
1884: if (crtR11TxYZeroLast != crtR11TxYZero ||
1885: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
1886: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
1887: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
1888: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
1889: crtR11TxYZeroLast = crtR11TxYZero;
1890: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
1891: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
1892: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
1893: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
1894: crtAllStamp += 2;
1895: }
1896: crtDataY = 0;
1897: if (crtClearStandby) {
1898: crtClearStandby = false;
1899: crtClearFrames = 1;
1900: }
1901: crtScreenY = 0;
1902: crtDirtyY0 = -1;
1903: if (SpriteScreen.SPR_THREE_STEPS) {
1904: SpriteScreen.sprActive = (SpriteScreen.sprReg8ResoCurr & 10) == 0;
1905: if (SpriteScreen.sprActive) {
1906: crtAllStamp += 2;
1907:
1908: SpriteScreen.sprStep1 (0);
1909: SpriteScreen.sprSwap ();
1910:
1911:
1912: SpriteScreen.sprStep1 (1);
1913: SpriteScreen.sprSwap ();
1914: SpriteScreen.sprStep2 (0);
1915: }
1916: }
1917: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1918: crtStereoscopicStart ();
1919: }
1920: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
1921: }
1922: } else {
1923:
1924: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
1925: }
1926: }
1927: };
1928:
1929: public static final TickerQueue.Ticker NormalDrawIdleSync = new TickerQueue.Ticker () {
1930: @Override protected void tick () {
1931: MC68901.mfpHsyncRise ();
1932: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleBackDisp, crtClock += crtHSyncLength);
1933: }
1934: };
1935:
1936: public static final TickerQueue.Ticker NormalDrawIdleBackDisp = new TickerQueue.Ticker () {
1937: @Override protected void tick () {
1938: MC68901.mfpHsyncFall ();
1939: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleFront, crtClock += crtHBackDispLength);
1940: }
1941: };
1942:
1943: public static final TickerQueue.Ticker NormalDrawDispFront = new TickerQueue.Ticker () {
1944: @Override protected void tick () {
1945: int n = ++crtRasterNumber;
1946: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
1947: if (crtRasterCopyOn) {
1948: crtDoRasterCopy ();
1949: }
1950: if (RasterBreakPoint.RBP_ON) {
1951: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
1952: RasterBreakPoint.rbpFire ();
1953: }
1954: }
1955: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
1956: if (irq != MC68901.mfpGpipRint) {
1957: if (irq == 0) {
1958: if (RasterBreakPoint.RBP_ON) {
1959: if (RasterBreakPoint.rbpIRQBreakEnabled) {
1960: RasterBreakPoint.rbpFire ();
1961: }
1962: }
1963: MC68901.mfpRintFall ();
1964: } else {
1965: MC68901.mfpRintRise ();
1966: }
1967: }
1968: if (n != crtVIdleStart) {
1969: if (crtBeginningAllStamp != crtAllStamp) {
1970: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
1971: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1972: crtStereoscopicDrawRaster (crtScreenY);
1973: }
1974: }
1975: crtScreenY++;
1976: crtDataY++;
1977: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
1978: } else {
1979: if (crtBeginningAllStamp != crtAllStamp) {
1980: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
1981: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
1982: crtStereoscopicDrawRaster (crtScreenY);
1983: }
1984: }
1985: MC68901.mfpVdispFall ();
1986: if (crtClearFrames != 0) {
1987: crtClearFrames--;
1988: }
1989: if (crtDirtyY0 >= 0) {
1990: crtUpdateScreen ();
1991: if (CRT_ENABLE_INTERMITTENT) {
1992: crtIntermittentCounter = crtIntermittentInterval;
1993: }
1994: }
1995: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
1996: crtDoFrameTask ();
1997: }
1998: TickerQueue.tkqAdd (crtTicker = NormalDrawIdleSync, crtClock += crtHFrontLength);
1999: }
2000: } else {
2001:
2002: if (crtBeginningAllStamp != crtAllStamp) {
2003: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2004: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2005: crtStereoscopicDrawRaster (crtScreenY);
2006: }
2007: }
2008: crtScreenY++;
2009: crtDataY++;
2010: TickerQueue.tkqAdd (crtTicker = NormalDrawDispSync, crtClock += crtHFrontLength);
2011: }
2012: }
2013: };
2014:
2015: public static final TickerQueue.Ticker NormalDrawDispSync = new TickerQueue.Ticker () {
2016: @Override protected void tick () {
2017: MC68901.mfpHsyncRise ();
2018: if (crtClearFrames != 0) {
2019: crtRapidClear (crtDataY);
2020: crtRasterStamp[crtDataY] = 0;
2021: }
2022: TickerQueue.tkqAdd (crtTicker = NormalDrawDispBack, crtClock += crtHSyncLength);
2023: }
2024: };
2025:
2026: public static final TickerQueue.Ticker NormalDrawDispBack = new TickerQueue.Ticker () {
2027: @Override protected void tick () {
2028: MC68901.mfpHsyncFall ();
2029: TickerQueue.tkqAdd (crtTicker = NormalDrawDispDisp, crtClock += crtHBackLength);
2030: }
2031: };
2032:
2033: public static final TickerQueue.Ticker NormalDrawDispDisp = new TickerQueue.Ticker () {
2034: @Override protected void tick () {
2035: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2036: crtRasterStamp[crtDataY] = crtAllStamp;
2037: crtBeginningAllStamp = crtAllStamp;
2038: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2039: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2040: crtStereoscopicDrawRaster (crtScreenY);
2041: }
2042: if (crtDirtyY0 < 0) {
2043: crtDirtyY0 = crtScreenY;
2044: }
2045: crtDirtyY1 = crtScreenY;
2046: }
2047: if (SpriteScreen.SPR_THREE_STEPS) {
2048: if (SpriteScreen.sprActive) {
2049:
2050:
2051: SpriteScreen.sprStep1 (crtDataY + 2);
2052: SpriteScreen.sprSwap ();
2053: SpriteScreen.sprStep2 (crtDataY + 1);
2054: }
2055: }
2056: TickerQueue.tkqAdd (crtTicker = NormalDrawDispFront, crtClock += crtHDispLength);
2057: }
2058: };
2059:
2060: public static final TickerQueue.Ticker NormalOmitIdleFront = new TickerQueue.Ticker () {
2061: @Override protected void tick () {
2062: int n = ++crtRasterNumber;
2063: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2064: if (crtR04VFrontEndCurr < n) {
2065: n = crtRasterNumber = 0;
2066: }
2067: if (crtRasterCopyOn) {
2068: crtDoRasterCopy ();
2069: }
2070: if (RasterBreakPoint.RBP_ON) {
2071: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2072: RasterBreakPoint.rbpFire ();
2073: }
2074: }
2075: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2076: if (irq != MC68901.mfpGpipRint) {
2077: if (irq == 0) {
2078: if (RasterBreakPoint.RBP_ON) {
2079: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2080: RasterBreakPoint.rbpFire ();
2081: }
2082: }
2083: MC68901.mfpRintFall ();
2084: } else {
2085: MC68901.mfpRintRise ();
2086: }
2087: }
2088: if (n != crtVDispStart) {
2089: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2090: } else {
2091: MC68901.mfpVdispRise ();
2092: crtR11TxYZero = crtR11TxYCurr;
2093: crtR13GrYZero[0] = crtR13GrYCurr[0];
2094: crtR13GrYZero[1] = crtR13GrYCurr[1];
2095: crtR13GrYZero[2] = crtR13GrYCurr[2];
2096: crtR13GrYZero[3] = crtR13GrYCurr[3];
2097: if (crtR11TxYZeroLast != crtR11TxYZero ||
2098: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2099: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2100: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2101: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2102: crtR11TxYZeroLast = crtR11TxYZero;
2103: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2104: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2105: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2106: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2107: crtAllStamp += 2;
2108: }
2109: crtDataY = 0;
2110: if (crtClearStandby) {
2111: crtClearStandby = false;
2112: crtClearFrames = 1;
2113: }
2114: if (SpriteScreen.SPR_THREE_STEPS) {
2115: SpriteScreen.sprActive = (SpriteScreen.sprReg8ResoCurr & 10) == 0;
2116: if (SpriteScreen.sprActive) {
2117: crtAllStamp += 2;
2118:
2119: SpriteScreen.sprStep1 (0);
2120: SpriteScreen.sprSwap ();
2121:
2122:
2123: SpriteScreen.sprStep1 (1);
2124: SpriteScreen.sprSwap ();
2125: SpriteScreen.sprStep2 (0);
2126: }
2127: }
2128: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2129: crtStereoscopicStart ();
2130: }
2131: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2132: }
2133: } else {
2134:
2135: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2136: }
2137: }
2138: };
2139:
2140: public static final TickerQueue.Ticker NormalOmitIdleSync = new TickerQueue.Ticker () {
2141: @Override protected void tick () {
2142: MC68901.mfpHsyncRise ();
2143: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleBackDisp, crtClock += crtHSyncLength);
2144: }
2145: };
2146:
2147: public static final TickerQueue.Ticker NormalOmitIdleBackDisp = new TickerQueue.Ticker () {
2148: @Override protected void tick () {
2149: MC68901.mfpHsyncFall ();
2150: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleFront, crtClock += crtHBackDispLength);
2151: }
2152: };
2153:
2154: public static final TickerQueue.Ticker NormalOmitDispFront = new TickerQueue.Ticker () {
2155: @Override protected void tick () {
2156: int n = ++crtRasterNumber;
2157: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2158: if (crtRasterCopyOn) {
2159: crtDoRasterCopy ();
2160: }
2161: if (RasterBreakPoint.RBP_ON) {
2162: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2163: RasterBreakPoint.rbpFire ();
2164: }
2165: }
2166: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2167: if (irq != MC68901.mfpGpipRint) {
2168: if (irq == 0) {
2169: if (RasterBreakPoint.RBP_ON) {
2170: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2171: RasterBreakPoint.rbpFire ();
2172: }
2173: }
2174: MC68901.mfpRintFall ();
2175: } else {
2176: MC68901.mfpRintRise ();
2177: }
2178: }
2179: if (n != crtVIdleStart) {
2180: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2181: } else {
2182: MC68901.mfpVdispFall ();
2183: if (crtClearFrames != 0) {
2184: crtClearFrames--;
2185: }
2186: if (CRT_ENABLE_INTERMITTENT) {
2187: crtIntermittentCounter--;
2188: }
2189: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2190: crtDoFrameTask ();
2191: }
2192: TickerQueue.tkqAdd (crtTicker = NormalOmitIdleSync, crtClock += crtHFrontLength);
2193: }
2194: } else {
2195:
2196: TickerQueue.tkqAdd (crtTicker = NormalOmitDispSync, crtClock += crtHFrontLength);
2197: }
2198: }
2199: };
2200:
2201: public static final TickerQueue.Ticker NormalOmitDispSync = new TickerQueue.Ticker () {
2202: @Override protected void tick () {
2203: MC68901.mfpHsyncRise ();
2204: if (crtClearFrames != 0) {
2205: crtRapidClear (crtDataY);
2206: crtRasterStamp[crtDataY] = 0;
2207: }
2208: TickerQueue.tkqAdd (crtTicker = NormalOmitDispBackDisp, crtClock += crtHSyncLength);
2209: }
2210: };
2211:
2212: public static final TickerQueue.Ticker NormalOmitDispBackDisp = new TickerQueue.Ticker () {
2213: @Override protected void tick () {
2214: MC68901.mfpHsyncFall ();
2215: TickerQueue.tkqAdd (crtTicker = NormalOmitDispFront, crtClock += crtHBackDispLength);
2216: }
2217: };
2218:
2219:
2220:
2221:
2222: public static final TickerQueue.Ticker DuplicationStart = new TickerQueue.Ticker () {
2223: @Override protected void tick () {
2224: if (MC68901.mfpGpipHsync != 0) {
2225: MC68901.mfpHsyncFall ();
2226: }
2227: int n = crtRasterNumber = crtVIdleStart;
2228: if (crtRasterCopyOn) {
2229: crtDoRasterCopy ();
2230: }
2231: if (RasterBreakPoint.RBP_ON) {
2232: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2233: RasterBreakPoint.rbpFire ();
2234: }
2235: }
2236: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2237: if (irq != MC68901.mfpGpipRint) {
2238: if (irq == 0) {
2239: if (RasterBreakPoint.RBP_ON) {
2240: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2241: RasterBreakPoint.rbpFire ();
2242: }
2243: }
2244: MC68901.mfpRintFall ();
2245: } else {
2246: MC68901.mfpRintRise ();
2247: }
2248: }
2249: if (MC68901.mfpGpipVdisp != 0) {
2250: MC68901.mfpVdispFall ();
2251: }
2252: crtClearFrames = 0;
2253: if (CRT_ENABLE_INTERMITTENT) {
2254: crtIntermittentCounter = 0;
2255: }
2256: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2257: crtDoFrameTask ();
2258: }
2259: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2260: }
2261: };
2262:
2263: public static final TickerQueue.Ticker DuplicationDrawIdleFront = new TickerQueue.Ticker () {
2264: @Override protected void tick () {
2265: int n = ++crtRasterNumber;
2266: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2267: if (crtR04VFrontEndCurr < n) {
2268: n = crtRasterNumber = 0;
2269: }
2270: if (crtRasterCopyOn) {
2271: crtDoRasterCopy ();
2272: }
2273: if (RasterBreakPoint.RBP_ON) {
2274: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2275: RasterBreakPoint.rbpFire ();
2276: }
2277: }
2278: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2279: if (irq != MC68901.mfpGpipRint) {
2280: if (irq == 0) {
2281: if (RasterBreakPoint.RBP_ON) {
2282: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2283: RasterBreakPoint.rbpFire ();
2284: }
2285: }
2286: MC68901.mfpRintFall ();
2287: } else {
2288: MC68901.mfpRintRise ();
2289: }
2290: }
2291: if (n != crtVDispStart) {
2292: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2293: } else {
2294: MC68901.mfpVdispRise ();
2295: crtR11TxYZero = crtR11TxYCurr;
2296: crtR13GrYZero[0] = crtR13GrYCurr[0];
2297: crtR13GrYZero[1] = crtR13GrYCurr[1];
2298: crtR13GrYZero[2] = crtR13GrYCurr[2];
2299: crtR13GrYZero[3] = crtR13GrYCurr[3];
2300: if (crtR11TxYZeroLast != crtR11TxYZero ||
2301: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2302: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2303: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2304: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2305: crtR11TxYZeroLast = crtR11TxYZero;
2306: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2307: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2308: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2309: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2310: crtAllStamp += 2;
2311: }
2312: crtDataY = 0;
2313: if (crtClearStandby) {
2314: crtClearStandby = false;
2315: crtClearFrames = 1;
2316: }
2317: crtScreenY = 0;
2318: crtDirtyY0 = -1;
2319: if (SpriteScreen.SPR_THREE_STEPS) {
2320: SpriteScreen.sprActive = (SpriteScreen.sprReg8ResoCurr & 10) == 0;
2321: if (SpriteScreen.sprActive) {
2322: crtAllStamp += 2;
2323:
2324: SpriteScreen.sprStep1 (0);
2325: SpriteScreen.sprSwap ();
2326:
2327:
2328: SpriteScreen.sprStep1 (0);
2329: SpriteScreen.sprSwap ();
2330: SpriteScreen.sprStep2 (0);
2331: }
2332: }
2333: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2334: crtStereoscopicStart ();
2335: }
2336: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2337: }
2338: } else {
2339:
2340: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2341: }
2342: }
2343: };
2344:
2345: public static final TickerQueue.Ticker DuplicationDrawIdleSync = new TickerQueue.Ticker () {
2346: @Override protected void tick () {
2347: MC68901.mfpHsyncRise ();
2348: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleBackDisp, crtClock += crtHSyncLength);
2349: }
2350: };
2351:
2352: public static final TickerQueue.Ticker DuplicationDrawIdleBackDisp = new TickerQueue.Ticker () {
2353: @Override protected void tick () {
2354: MC68901.mfpHsyncFall ();
2355: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleFront, crtClock += crtHBackDispLength);
2356: }
2357: };
2358:
2359: public static final TickerQueue.Ticker DuplicationDrawDispEvenFront = new TickerQueue.Ticker () {
2360: @Override protected void tick () {
2361: int n = ++crtRasterNumber;
2362: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2363: if (crtRasterCopyOn) {
2364: crtDoRasterCopy ();
2365: }
2366: if (RasterBreakPoint.RBP_ON) {
2367: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2368: RasterBreakPoint.rbpFire ();
2369: }
2370: }
2371: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2372: if (irq != MC68901.mfpGpipRint) {
2373: if (irq == 0) {
2374: if (RasterBreakPoint.RBP_ON) {
2375: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2376: RasterBreakPoint.rbpFire ();
2377: }
2378: }
2379: MC68901.mfpRintFall ();
2380: } else {
2381: MC68901.mfpRintRise ();
2382: }
2383: }
2384: if (n != crtVIdleStart) {
2385: if (crtBeginningAllStamp != crtAllStamp) {
2386: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2387: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2388: crtStereoscopicDrawRaster (crtScreenY);
2389: }
2390: }
2391: crtScreenY++;
2392: crtDataY++;
2393: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2394: } else {
2395: if (crtBeginningAllStamp != crtAllStamp) {
2396: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2397: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2398: crtStereoscopicDrawRaster (crtScreenY);
2399: }
2400: }
2401: MC68901.mfpVdispFall ();
2402: if (crtClearFrames != 0) {
2403: crtClearFrames--;
2404: }
2405: if (crtDirtyY0 >= 0) {
2406: crtUpdateScreen ();
2407: if (CRT_ENABLE_INTERMITTENT) {
2408: crtIntermittentCounter = crtIntermittentInterval;
2409: }
2410: }
2411: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2412: crtDoFrameTask ();
2413: }
2414: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2415: }
2416: } else {
2417:
2418: if (crtBeginningAllStamp != crtAllStamp) {
2419: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2420: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2421: crtStereoscopicDrawRaster (crtScreenY);
2422: }
2423: }
2424: crtScreenY++;
2425: crtDataY++;
2426: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenSync, crtClock += crtHFrontLength);
2427: }
2428: }
2429: };
2430:
2431: public static final TickerQueue.Ticker DuplicationDrawDispOddFront = new TickerQueue.Ticker () {
2432: @Override protected void tick () {
2433: int n = ++crtRasterNumber;
2434: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2435: if (crtRasterCopyOn) {
2436: crtDoRasterCopy ();
2437: }
2438: if (RasterBreakPoint.RBP_ON) {
2439: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2440: RasterBreakPoint.rbpFire ();
2441: }
2442: }
2443: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2444: if (irq != MC68901.mfpGpipRint) {
2445: if (irq == 0) {
2446: if (RasterBreakPoint.RBP_ON) {
2447: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2448: RasterBreakPoint.rbpFire ();
2449: }
2450: }
2451: MC68901.mfpRintFall ();
2452: } else {
2453: MC68901.mfpRintRise ();
2454: }
2455: }
2456: if (n != crtVIdleStart) {
2457: if (crtBeginningAllStamp != crtAllStamp) {
2458: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2459: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2460: crtStereoscopicDrawRaster (crtScreenY);
2461: }
2462: }
2463: crtScreenY++;
2464: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);
2465: } else {
2466: if (crtBeginningAllStamp != crtAllStamp) {
2467: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2468: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2469: crtStereoscopicDrawRaster (crtScreenY);
2470: }
2471: }
2472: MC68901.mfpVdispFall ();
2473: if (crtClearFrames != 0) {
2474: crtClearFrames--;
2475: }
2476: if (crtDirtyY0 >= 0) {
2477: crtUpdateScreen ();
2478: if (CRT_ENABLE_INTERMITTENT) {
2479: crtIntermittentCounter = crtIntermittentInterval;
2480: }
2481: }
2482: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2483: crtDoFrameTask ();
2484: }
2485: TickerQueue.tkqAdd (crtTicker = DuplicationDrawIdleSync, crtClock += crtHFrontLength);
2486: }
2487: } else {
2488:
2489: if (crtBeginningAllStamp != crtAllStamp) {
2490: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2491: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2492: crtStereoscopicDrawRaster (crtScreenY);
2493: }
2494: }
2495: crtScreenY++;
2496: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddSync, crtClock += crtHFrontLength);
2497: }
2498: }
2499: };
2500:
2501: public static final TickerQueue.Ticker DuplicationDrawDispEvenSync = new TickerQueue.Ticker () {
2502: @Override protected void tick () {
2503: MC68901.mfpHsyncRise ();
2504: if (crtClearFrames != 0) {
2505: crtRapidClear (crtDataY);
2506: crtRasterStamp[crtDataY] = 0;
2507: }
2508: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenBack, crtClock += crtHSyncLength);
2509: }
2510: };
2511:
2512: public static final TickerQueue.Ticker DuplicationDrawDispOddSync = new TickerQueue.Ticker () {
2513: @Override protected void tick () {
2514: MC68901.mfpHsyncRise ();
2515: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddBack, crtClock += crtHSyncLength);
2516: }
2517: };
2518:
2519: public static final TickerQueue.Ticker DuplicationDrawDispEvenBack = new TickerQueue.Ticker () {
2520: @Override protected void tick () {
2521: MC68901.mfpHsyncFall ();
2522: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenDisp, crtClock += crtHBackLength);
2523: }
2524: };
2525:
2526: public static final TickerQueue.Ticker DuplicationDrawDispOddBack = new TickerQueue.Ticker () {
2527: @Override protected void tick () {
2528: MC68901.mfpHsyncFall ();
2529: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddDisp, crtClock += crtHBackLength);
2530: }
2531: };
2532:
2533: public static final TickerQueue.Ticker DuplicationDrawDispEvenDisp = new TickerQueue.Ticker () {
2534: @Override protected void tick () {
2535: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2536: crtBeginningAllStamp = crtAllStamp;
2537: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2538: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2539: crtStereoscopicDrawRaster (crtScreenY);
2540: }
2541: if (crtDirtyY0 < 0) {
2542: crtDirtyY0 = crtScreenY;
2543: }
2544: if (CRT_INSTANT_DUPLICATION) {
2545: crtRasterStamp[crtDataY] = crtAllStamp;
2546: crtDirtyY1 = crtScreenY + 1;
2547: System.arraycopy (XEiJ.pnlBM, crtScreenY << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlBM, crtScreenY + 1 << XEiJ.PNL_BM_OFFSET_BITS, XEiJ.pnlScreenWidth);
2548: } else {
2549: crtDirtyY1 = crtScreenY;
2550: }
2551: }
2552: if (SpriteScreen.SPR_THREE_STEPS) {
2553: if (SpriteScreen.sprActive) {
2554:
2555:
2556: SpriteScreen.sprStep1 (crtDataY + 1);
2557: SpriteScreen.sprSwap ();
2558: SpriteScreen.sprStep2 (crtDataY);
2559: }
2560: }
2561: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispOddFront, crtClock += crtHDispLength);
2562: }
2563: };
2564:
2565: public static final TickerQueue.Ticker DuplicationDrawDispOddDisp = new TickerQueue.Ticker () {
2566: @Override protected void tick () {
2567: if (!CRT_INSTANT_DUPLICATION) {
2568: if (crtRasterStamp[crtDataY] != crtAllStamp) {
2569: crtRasterStamp[crtDataY] = crtAllStamp;
2570: crtBeginningAllStamp = crtAllStamp;
2571: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
2572: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2573: crtStereoscopicDrawRaster (crtScreenY);
2574: }
2575: if (crtDirtyY0 < 0) {
2576: crtDirtyY0 = crtScreenY;
2577: }
2578: crtDirtyY1 = crtScreenY;
2579: }
2580: }
2581: if (SpriteScreen.SPR_THREE_STEPS) {
2582: if (SpriteScreen.sprActive) {
2583:
2584:
2585: SpriteScreen.sprStep1 (crtDataY + 1);
2586: SpriteScreen.sprSwap ();
2587: SpriteScreen.sprStep2 (crtDataY + 1);
2588: }
2589: }
2590: TickerQueue.tkqAdd (crtTicker = DuplicationDrawDispEvenFront, crtClock += crtHDispLength);
2591: }
2592: };
2593:
2594: public static final TickerQueue.Ticker DuplicationOmitIdleFront = new TickerQueue.Ticker () {
2595: @Override protected void tick () {
2596: int n = ++crtRasterNumber;
2597: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2598: if (crtR04VFrontEndCurr < n) {
2599: n = crtRasterNumber = 0;
2600: }
2601: if (crtRasterCopyOn) {
2602: crtDoRasterCopy ();
2603: }
2604: if (RasterBreakPoint.RBP_ON) {
2605: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2606: RasterBreakPoint.rbpFire ();
2607: }
2608: }
2609: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2610: if (irq != MC68901.mfpGpipRint) {
2611: if (irq == 0) {
2612: if (RasterBreakPoint.RBP_ON) {
2613: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2614: RasterBreakPoint.rbpFire ();
2615: }
2616: }
2617: MC68901.mfpRintFall ();
2618: } else {
2619: MC68901.mfpRintRise ();
2620: }
2621: }
2622: if (n != crtVDispStart) {
2623: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2624: } else {
2625: MC68901.mfpVdispRise ();
2626: crtR11TxYZero = crtR11TxYCurr;
2627: crtR13GrYZero[0] = crtR13GrYCurr[0];
2628: crtR13GrYZero[1] = crtR13GrYCurr[1];
2629: crtR13GrYZero[2] = crtR13GrYCurr[2];
2630: crtR13GrYZero[3] = crtR13GrYCurr[3];
2631: if (crtR11TxYZeroLast != crtR11TxYZero ||
2632: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2633: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2634: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2635: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2636: crtR11TxYZeroLast = crtR11TxYZero;
2637: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2638: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2639: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2640: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2641: crtAllStamp += 2;
2642: }
2643: crtDataY = 0;
2644: if (crtClearStandby) {
2645: crtClearStandby = false;
2646: crtClearFrames = 1;
2647: }
2648: if (SpriteScreen.SPR_THREE_STEPS) {
2649: SpriteScreen.sprActive = (SpriteScreen.sprReg8ResoCurr & 10) == 0;
2650: if (SpriteScreen.sprActive) {
2651: crtAllStamp += 2;
2652:
2653: SpriteScreen.sprStep1 (0);
2654: SpriteScreen.sprSwap ();
2655:
2656:
2657: SpriteScreen.sprStep1 (0);
2658: SpriteScreen.sprSwap ();
2659: SpriteScreen.sprStep2 (0);
2660: }
2661: }
2662: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2663: crtStereoscopicStart ();
2664: }
2665: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2666: }
2667: } else {
2668:
2669: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2670: }
2671: }
2672: };
2673:
2674: public static final TickerQueue.Ticker DuplicationOmitIdleSync = new TickerQueue.Ticker () {
2675: @Override protected void tick () {
2676: MC68901.mfpHsyncRise ();
2677: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleBackDisp, crtClock += crtHSyncLength);
2678: }
2679: };
2680:
2681: public static final TickerQueue.Ticker DuplicationOmitIdleBackDisp = new TickerQueue.Ticker () {
2682: @Override protected void tick () {
2683: MC68901.mfpHsyncFall ();
2684: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleFront, crtClock += crtHBackDispLength);
2685: }
2686: };
2687:
2688: public static final TickerQueue.Ticker DuplicationOmitDispEvenFront = new TickerQueue.Ticker () {
2689: @Override protected void tick () {
2690: int n = ++crtRasterNumber;
2691: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2692: if (crtRasterCopyOn) {
2693: crtDoRasterCopy ();
2694: }
2695: if (RasterBreakPoint.RBP_ON) {
2696: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2697: RasterBreakPoint.rbpFire ();
2698: }
2699: }
2700: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2701: if (irq != MC68901.mfpGpipRint) {
2702: if (irq == 0) {
2703: if (RasterBreakPoint.RBP_ON) {
2704: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2705: RasterBreakPoint.rbpFire ();
2706: }
2707: }
2708: MC68901.mfpRintFall ();
2709: } else {
2710: MC68901.mfpRintRise ();
2711: }
2712: }
2713: if (n != crtVIdleStart) {
2714: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2715: } else {
2716: MC68901.mfpVdispFall ();
2717: if (crtClearFrames != 0) {
2718: crtClearFrames--;
2719: }
2720: if (CRT_ENABLE_INTERMITTENT) {
2721: crtIntermittentCounter--;
2722: }
2723: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2724: crtDoFrameTask ();
2725: }
2726: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2727: }
2728: } else {
2729:
2730: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenSync, crtClock += crtHFrontLength);
2731: }
2732: }
2733: };
2734:
2735: public static final TickerQueue.Ticker DuplicationOmitDispOddFront = new TickerQueue.Ticker () {
2736: @Override protected void tick () {
2737: int n = ++crtRasterNumber;
2738: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2739: if (crtRasterCopyOn) {
2740: crtDoRasterCopy ();
2741: }
2742: if (RasterBreakPoint.RBP_ON) {
2743: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2744: RasterBreakPoint.rbpFire ();
2745: }
2746: }
2747: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2748: if (irq != MC68901.mfpGpipRint) {
2749: if (irq == 0) {
2750: if (RasterBreakPoint.RBP_ON) {
2751: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2752: RasterBreakPoint.rbpFire ();
2753: }
2754: }
2755: MC68901.mfpRintFall ();
2756: } else {
2757: MC68901.mfpRintRise ();
2758: }
2759: }
2760: if (n != crtVIdleStart) {
2761: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);
2762: } else {
2763: MC68901.mfpVdispFall ();
2764: if (crtClearFrames != 0) {
2765: crtClearFrames--;
2766: }
2767: if (CRT_ENABLE_INTERMITTENT) {
2768: crtIntermittentCounter--;
2769: }
2770: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2771: crtDoFrameTask ();
2772: }
2773: TickerQueue.tkqAdd (crtTicker = DuplicationOmitIdleSync, crtClock += crtHFrontLength);
2774: }
2775: } else {
2776:
2777: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddSync, crtClock += crtHFrontLength);
2778: }
2779: }
2780: };
2781:
2782: public static final TickerQueue.Ticker DuplicationOmitDispEvenSync = new TickerQueue.Ticker () {
2783: @Override protected void tick () {
2784: MC68901.mfpHsyncRise ();
2785: if (crtClearFrames != 0) {
2786: crtRapidClear (crtDataY);
2787: crtRasterStamp[crtDataY] = 0;
2788: }
2789: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenBackDisp, crtClock += crtHSyncLength);
2790: }
2791: };
2792:
2793: public static final TickerQueue.Ticker DuplicationOmitDispOddSync = new TickerQueue.Ticker () {
2794: @Override protected void tick () {
2795: MC68901.mfpHsyncRise ();
2796: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddBackDisp, crtClock += crtHSyncLength);
2797: }
2798: };
2799:
2800: public static final TickerQueue.Ticker DuplicationOmitDispEvenBackDisp = new TickerQueue.Ticker () {
2801: @Override protected void tick () {
2802: MC68901.mfpHsyncFall ();
2803: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispOddFront, crtClock += crtHBackDispLength);
2804: }
2805: };
2806:
2807: public static final TickerQueue.Ticker DuplicationOmitDispOddBackDisp = new TickerQueue.Ticker () {
2808: @Override protected void tick () {
2809: MC68901.mfpHsyncFall ();
2810: TickerQueue.tkqAdd (crtTicker = DuplicationOmitDispEvenFront, crtClock += crtHBackDispLength);
2811: }
2812: };
2813:
2814:
2815:
2816:
2817: public static final TickerQueue.Ticker InterlaceStart = new TickerQueue.Ticker () {
2818: @Override protected void tick () {
2819: if (MC68901.mfpGpipHsync != 0) {
2820: MC68901.mfpHsyncFall ();
2821: }
2822: int n = crtRasterNumber = crtVIdleStart;
2823: if (crtRasterCopyOn) {
2824: crtDoRasterCopy ();
2825: }
2826: if (RasterBreakPoint.RBP_ON) {
2827: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2828: RasterBreakPoint.rbpFire ();
2829: }
2830: }
2831: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2832: if (irq != MC68901.mfpGpipRint) {
2833: if (irq == 0) {
2834: if (RasterBreakPoint.RBP_ON) {
2835: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2836: RasterBreakPoint.rbpFire ();
2837: }
2838: }
2839: MC68901.mfpRintFall ();
2840: } else {
2841: MC68901.mfpRintRise ();
2842: }
2843: }
2844: if (MC68901.mfpGpipVdisp != 0) {
2845: MC68901.mfpVdispFall ();
2846: }
2847: crtFrameParity = 0;
2848: crtClearFrames = 0;
2849: if (CRT_ENABLE_INTERMITTENT) {
2850: crtIntermittentCounter = 0;
2851: }
2852: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
2853: crtDoFrameTask ();
2854: }
2855: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
2856: }
2857: };
2858:
2859: public static final TickerQueue.Ticker InterlaceDrawIdleFront = new TickerQueue.Ticker () {
2860: @Override protected void tick () {
2861: int n = ++crtRasterNumber;
2862: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
2863: if (crtR04VFrontEndCurr < n) {
2864: n = crtRasterNumber = 0;
2865: }
2866: if (crtRasterCopyOn) {
2867: crtDoRasterCopy ();
2868: }
2869: if (RasterBreakPoint.RBP_ON) {
2870: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2871: RasterBreakPoint.rbpFire ();
2872: }
2873: }
2874: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2875: if (irq != MC68901.mfpGpipRint) {
2876: if (irq == 0) {
2877: if (RasterBreakPoint.RBP_ON) {
2878: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2879: RasterBreakPoint.rbpFire ();
2880: }
2881: }
2882: MC68901.mfpRintFall ();
2883: } else {
2884: MC68901.mfpRintRise ();
2885: }
2886: }
2887: if (n != crtVDispStart) {
2888: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
2889: } else {
2890: MC68901.mfpVdispRise ();
2891: crtR11TxYZero = crtR11TxYCurr;
2892: crtR13GrYZero[0] = crtR13GrYCurr[0];
2893: crtR13GrYZero[1] = crtR13GrYCurr[1];
2894: crtR13GrYZero[2] = crtR13GrYCurr[2];
2895: crtR13GrYZero[3] = crtR13GrYCurr[3];
2896: if (crtR11TxYZeroLast != crtR11TxYZero ||
2897: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
2898: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
2899: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
2900: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
2901: crtR11TxYZeroLast = crtR11TxYZero;
2902: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
2903: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
2904: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
2905: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
2906: crtAllStamp += 2;
2907: }
2908: crtDataY = crtFrameParity;
2909: if (crtClearStandby) {
2910: crtClearStandby = false;
2911: crtClearFrames = 2;
2912: }
2913: crtScreenY = crtFrameParity;
2914: crtDirtyY0 = -1;
2915: if (SpriteScreen.SPR_THREE_STEPS) {
2916: SpriteScreen.sprActive = (SpriteScreen.sprReg8ResoCurr & 10) == 0;
2917: if (SpriteScreen.sprActive) {
2918: crtAllStamp += 2;
2919:
2920: SpriteScreen.sprStep1 (0);
2921: SpriteScreen.sprSwap ();
2922:
2923:
2924: SpriteScreen.sprStep1 (2);
2925: SpriteScreen.sprSwap ();
2926: SpriteScreen.sprStep2 (0);
2927: }
2928: }
2929: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2930: crtStereoscopicStart ();
2931: }
2932: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
2933: }
2934: } else {
2935:
2936: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
2937: }
2938: }
2939: };
2940:
2941: public static final TickerQueue.Ticker InterlaceDrawIdleSync = new TickerQueue.Ticker () {
2942: @Override protected void tick () {
2943: MC68901.mfpHsyncRise ();
2944: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleBackDisp, crtClock += crtHSyncLength);
2945: }
2946: };
2947:
2948: public static final TickerQueue.Ticker InterlaceDrawIdleBackDisp = new TickerQueue.Ticker () {
2949: @Override protected void tick () {
2950: MC68901.mfpHsyncFall ();
2951: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleFront, crtClock += crtHBackDispLength);
2952: }
2953: };
2954:
2955: public static final TickerQueue.Ticker InterlaceDrawDispFront = new TickerQueue.Ticker () {
2956: @Override protected void tick () {
2957: int n = ++crtRasterNumber;
2958: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
2959: if (crtRasterCopyOn) {
2960: crtDoRasterCopy ();
2961: }
2962: if (RasterBreakPoint.RBP_ON) {
2963: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
2964: RasterBreakPoint.rbpFire ();
2965: }
2966: }
2967: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
2968: if (irq != MC68901.mfpGpipRint) {
2969: if (irq == 0) {
2970: if (RasterBreakPoint.RBP_ON) {
2971: if (RasterBreakPoint.rbpIRQBreakEnabled) {
2972: RasterBreakPoint.rbpFire ();
2973: }
2974: }
2975: MC68901.mfpRintFall ();
2976: } else {
2977: MC68901.mfpRintRise ();
2978: }
2979: }
2980: if (n != crtVIdleStart) {
2981: if (crtBeginningAllStamp != crtAllStamp) {
2982: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2983: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2984: crtStereoscopicDrawRaster (crtScreenY);
2985: }
2986: }
2987: crtScreenY += 2;
2988: crtDataY += 2;
2989: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
2990: } else {
2991: if (crtBeginningAllStamp != crtAllStamp) {
2992: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
2993: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
2994: crtStereoscopicDrawRaster (crtScreenY);
2995: }
2996: }
2997: MC68901.mfpVdispFall ();
2998: if (crtClearFrames != 0) {
2999: crtClearFrames--;
3000: }
3001: if (crtDirtyY0 >= 0) {
3002: crtUpdateScreen ();
3003: if (CRT_ENABLE_INTERMITTENT) {
3004: crtIntermittentCounter = crtIntermittentInterval;
3005: }
3006: }
3007: crtFrameParity ^= 1;
3008: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3009: crtDoFrameTask ();
3010: }
3011: TickerQueue.tkqAdd (crtTicker = InterlaceDrawIdleSync, crtClock += crtHFrontLength);
3012: }
3013: } else {
3014:
3015: if (crtBeginningAllStamp != crtAllStamp) {
3016: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3017: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3018: crtStereoscopicDrawRaster (crtScreenY);
3019: }
3020: }
3021: crtScreenY += 2;
3022: crtDataY += 2;
3023: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispSync, crtClock += crtHFrontLength);
3024: }
3025: }
3026: };
3027:
3028: public static final TickerQueue.Ticker InterlaceDrawDispSync = new TickerQueue.Ticker () {
3029: @Override protected void tick () {
3030: MC68901.mfpHsyncRise ();
3031: if (crtClearFrames != 0) {
3032: crtRapidClear (crtDataY);
3033: crtRasterStamp[crtDataY] = 0;
3034: }
3035: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispBack, crtClock += crtHSyncLength);
3036: }
3037: };
3038:
3039: public static final TickerQueue.Ticker InterlaceDrawDispBack = new TickerQueue.Ticker () {
3040: @Override protected void tick () {
3041: MC68901.mfpHsyncFall ();
3042: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispDisp, crtClock += crtHBackLength);
3043: }
3044: };
3045:
3046: public static final TickerQueue.Ticker InterlaceDrawDispDisp = new TickerQueue.Ticker () {
3047: @Override protected void tick () {
3048: if (crtRasterStamp[crtDataY] != crtAllStamp) {
3049: crtRasterStamp[crtDataY] = crtAllStamp;
3050: crtBeginningAllStamp = crtAllStamp;
3051: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
3052: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3053: crtStereoscopicDrawRaster (crtScreenY);
3054: }
3055: if (crtDirtyY0 < 0) {
3056: crtDirtyY0 = crtScreenY;
3057: }
3058: crtDirtyY1 = crtScreenY;
3059: }
3060: if (SpriteScreen.SPR_THREE_STEPS) {
3061: if (SpriteScreen.sprActive) {
3062:
3063:
3064: SpriteScreen.sprStep1 (crtDataY + 4);
3065: SpriteScreen.sprSwap ();
3066: SpriteScreen.sprStep2 (crtDataY + 2);
3067: }
3068: }
3069: TickerQueue.tkqAdd (crtTicker = InterlaceDrawDispFront, crtClock += crtHDispLength);
3070: }
3071: };
3072:
3073: public static final TickerQueue.Ticker InterlaceOmitIdleFront = new TickerQueue.Ticker () {
3074: @Override protected void tick () {
3075: int n = ++crtRasterNumber;
3076: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3077: if (crtR04VFrontEndCurr < n) {
3078: n = crtRasterNumber = 0;
3079: }
3080: if (crtRasterCopyOn) {
3081: crtDoRasterCopy ();
3082: }
3083: if (RasterBreakPoint.RBP_ON) {
3084: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3085: RasterBreakPoint.rbpFire ();
3086: }
3087: }
3088: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3089: if (irq != MC68901.mfpGpipRint) {
3090: if (irq == 0) {
3091: if (RasterBreakPoint.RBP_ON) {
3092: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3093: RasterBreakPoint.rbpFire ();
3094: }
3095: }
3096: MC68901.mfpRintFall ();
3097: } else {
3098: MC68901.mfpRintRise ();
3099: }
3100: }
3101: if (n != crtVDispStart) {
3102: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3103: } else {
3104: MC68901.mfpVdispRise ();
3105: crtR11TxYZero = crtR11TxYCurr;
3106: crtR13GrYZero[0] = crtR13GrYCurr[0];
3107: crtR13GrYZero[1] = crtR13GrYCurr[1];
3108: crtR13GrYZero[2] = crtR13GrYCurr[2];
3109: crtR13GrYZero[3] = crtR13GrYCurr[3];
3110: if (crtR11TxYZeroLast != crtR11TxYZero ||
3111: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3112: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3113: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3114: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3115: crtR11TxYZeroLast = crtR11TxYZero;
3116: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3117: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3118: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3119: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3120: crtAllStamp += 2;
3121: }
3122: crtDataY = crtFrameParity;
3123: if (crtClearStandby) {
3124: crtClearStandby = false;
3125: crtClearFrames = 2;
3126: }
3127: if (SpriteScreen.SPR_THREE_STEPS) {
3128: SpriteScreen.sprActive = (SpriteScreen.sprReg8ResoCurr & 10) == 0;
3129: if (SpriteScreen.sprActive) {
3130: crtAllStamp += 2;
3131:
3132: SpriteScreen.sprStep1 (0);
3133: SpriteScreen.sprSwap ();
3134:
3135:
3136: SpriteScreen.sprStep1 (2);
3137: SpriteScreen.sprSwap ();
3138: SpriteScreen.sprStep2 (0);
3139: }
3140: }
3141: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3142: crtStereoscopicStart ();
3143: }
3144: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3145: }
3146: } else {
3147:
3148: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3149: }
3150: }
3151: };
3152:
3153: public static final TickerQueue.Ticker InterlaceOmitIdleSync = new TickerQueue.Ticker () {
3154: @Override protected void tick () {
3155: MC68901.mfpHsyncRise ();
3156: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleBackDisp, crtClock += crtHSyncLength);
3157: }
3158: };
3159:
3160: public static final TickerQueue.Ticker InterlaceOmitIdleBackDisp = new TickerQueue.Ticker () {
3161: @Override protected void tick () {
3162: MC68901.mfpHsyncFall ();
3163: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleFront, crtClock += crtHBackDispLength);
3164: }
3165: };
3166:
3167: public static final TickerQueue.Ticker InterlaceOmitDispFront = new TickerQueue.Ticker () {
3168: @Override protected void tick () {
3169: int n = ++crtRasterNumber;
3170: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3171: if (crtRasterCopyOn) {
3172: crtDoRasterCopy ();
3173: }
3174: if (RasterBreakPoint.RBP_ON) {
3175: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3176: RasterBreakPoint.rbpFire ();
3177: }
3178: }
3179: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3180: if (irq != MC68901.mfpGpipRint) {
3181: if (irq == 0) {
3182: if (RasterBreakPoint.RBP_ON) {
3183: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3184: RasterBreakPoint.rbpFire ();
3185: }
3186: }
3187: MC68901.mfpRintFall ();
3188: } else {
3189: MC68901.mfpRintRise ();
3190: }
3191: }
3192: if (n != crtVIdleStart) {
3193: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3194: } else {
3195: MC68901.mfpVdispFall ();
3196: if (crtClearFrames != 0) {
3197: crtClearFrames--;
3198: }
3199: if (CRT_ENABLE_INTERMITTENT) {
3200: crtIntermittentCounter--;
3201: }
3202: crtFrameParity ^= 1;
3203: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3204: crtDoFrameTask ();
3205: }
3206: TickerQueue.tkqAdd (crtTicker = InterlaceOmitIdleSync, crtClock += crtHFrontLength);
3207: }
3208: } else {
3209:
3210: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispSync, crtClock += crtHFrontLength);
3211: }
3212: }
3213: };
3214:
3215: public static final TickerQueue.Ticker InterlaceOmitDispSync = new TickerQueue.Ticker () {
3216: @Override protected void tick () {
3217: MC68901.mfpHsyncRise ();
3218: if (crtClearFrames != 0) {
3219: crtRapidClear (crtDataY);
3220: crtRasterStamp[crtDataY] = 0;
3221: }
3222: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispBackDisp, crtClock += crtHSyncLength);
3223: }
3224: };
3225:
3226: public static final TickerQueue.Ticker InterlaceOmitDispBackDisp = new TickerQueue.Ticker () {
3227: @Override protected void tick () {
3228: MC68901.mfpHsyncFall ();
3229: TickerQueue.tkqAdd (crtTicker = InterlaceOmitDispFront, crtClock += crtHBackDispLength);
3230: }
3231: };
3232:
3233:
3234:
3235:
3236: public static final TickerQueue.Ticker SlitStart = new TickerQueue.Ticker () {
3237: @Override protected void tick () {
3238: if (MC68901.mfpGpipHsync != 0) {
3239: MC68901.mfpHsyncFall ();
3240: }
3241: int n = crtRasterNumber = crtVIdleStart;
3242: if (crtRasterCopyOn) {
3243: crtDoRasterCopy ();
3244: }
3245: if (RasterBreakPoint.RBP_ON) {
3246: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3247: RasterBreakPoint.rbpFire ();
3248: }
3249: }
3250: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3251: if (irq != MC68901.mfpGpipRint) {
3252: if (irq == 0) {
3253: if (RasterBreakPoint.RBP_ON) {
3254: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3255: RasterBreakPoint.rbpFire ();
3256: }
3257: }
3258: MC68901.mfpRintFall ();
3259: } else {
3260: MC68901.mfpRintRise ();
3261: }
3262: }
3263: if (MC68901.mfpGpipVdisp != 0) {
3264: MC68901.mfpVdispFall ();
3265: }
3266: crtClearFrames = 0;
3267: if (CRT_ENABLE_INTERMITTENT) {
3268: crtIntermittentCounter = 0;
3269: }
3270: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3271: crtDoFrameTask ();
3272: }
3273: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3274: }
3275: };
3276:
3277: public static final TickerQueue.Ticker SlitDrawIdleFront = new TickerQueue.Ticker () {
3278: @Override protected void tick () {
3279: int n = ++crtRasterNumber;
3280: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3281: if (crtR04VFrontEndCurr < n) {
3282: n = crtRasterNumber = 0;
3283: }
3284: if (crtRasterCopyOn) {
3285: crtDoRasterCopy ();
3286: }
3287: if (RasterBreakPoint.RBP_ON) {
3288: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3289: RasterBreakPoint.rbpFire ();
3290: }
3291: }
3292: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3293: if (irq != MC68901.mfpGpipRint) {
3294: if (irq == 0) {
3295: if (RasterBreakPoint.RBP_ON) {
3296: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3297: RasterBreakPoint.rbpFire ();
3298: }
3299: }
3300: MC68901.mfpRintFall ();
3301: } else {
3302: MC68901.mfpRintRise ();
3303: }
3304: }
3305: if (n != crtVDispStart) {
3306: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3307: } else {
3308: MC68901.mfpVdispRise ();
3309: crtR11TxYZero = crtR11TxYCurr;
3310: crtR13GrYZero[0] = crtR13GrYCurr[0];
3311: crtR13GrYZero[1] = crtR13GrYCurr[1];
3312: crtR13GrYZero[2] = crtR13GrYCurr[2];
3313: crtR13GrYZero[3] = crtR13GrYCurr[3];
3314: if (crtR11TxYZeroLast != crtR11TxYZero ||
3315: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3316: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3317: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3318: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3319: crtR11TxYZeroLast = crtR11TxYZero;
3320: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3321: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3322: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3323: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3324: crtAllStamp += 2;
3325: }
3326: crtDataY = 0;
3327: if (crtClearStandby) {
3328: crtClearStandby = false;
3329: crtClearFrames = 1;
3330: }
3331: crtScreenY = 0;
3332: crtDirtyY0 = -1;
3333: if (SpriteScreen.SPR_THREE_STEPS) {
3334: SpriteScreen.sprActive = (SpriteScreen.sprReg8ResoCurr & 10) == 0;
3335: if (SpriteScreen.sprActive) {
3336: crtAllStamp += 2;
3337:
3338: SpriteScreen.sprStep1 (0);
3339: SpriteScreen.sprSwap ();
3340:
3341:
3342: SpriteScreen.sprStep1 (1);
3343: SpriteScreen.sprSwap ();
3344: SpriteScreen.sprStep2 (0);
3345: }
3346: }
3347: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3348: crtStereoscopicStart ();
3349: }
3350: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3351: }
3352: } else {
3353:
3354: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3355: }
3356: }
3357: };
3358:
3359: public static final TickerQueue.Ticker SlitDrawIdleSync = new TickerQueue.Ticker () {
3360: @Override protected void tick () {
3361: MC68901.mfpHsyncRise ();
3362: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleBackDisp, crtClock += crtHSyncLength);
3363: }
3364: };
3365:
3366: public static final TickerQueue.Ticker SlitDrawIdleBackDisp = new TickerQueue.Ticker () {
3367: @Override protected void tick () {
3368: MC68901.mfpHsyncFall ();
3369: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleFront, crtClock += crtHBackDispLength);
3370: }
3371: };
3372:
3373: public static final TickerQueue.Ticker SlitDrawDispFront = new TickerQueue.Ticker () {
3374: @Override protected void tick () {
3375: int n = ++crtRasterNumber;
3376: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3377: if (crtRasterCopyOn) {
3378: crtDoRasterCopy ();
3379: }
3380: if (RasterBreakPoint.RBP_ON) {
3381: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3382: RasterBreakPoint.rbpFire ();
3383: }
3384: }
3385: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3386: if (irq != MC68901.mfpGpipRint) {
3387: if (irq == 0) {
3388: if (RasterBreakPoint.RBP_ON) {
3389: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3390: RasterBreakPoint.rbpFire ();
3391: }
3392: }
3393: MC68901.mfpRintFall ();
3394: } else {
3395: MC68901.mfpRintRise ();
3396: }
3397: }
3398: if (n != crtVIdleStart) {
3399: if (crtBeginningAllStamp != crtAllStamp) {
3400: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3401: crtScanlineEffect.drawRaster (crtScreenY + 1);
3402: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3403: crtStereoscopicDrawRaster (crtScreenY);
3404: crtStereoscopicDrawRaster (crtScreenY + 1);
3405: }
3406: }
3407: crtScreenY += 2;
3408: crtDataY++;
3409: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3410: } else {
3411: if (crtBeginningAllStamp != crtAllStamp) {
3412: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3413: crtScanlineEffect.drawRaster (crtScreenY + 1);
3414: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3415: crtStereoscopicDrawRaster (crtScreenY);
3416: crtStereoscopicDrawRaster (crtScreenY + 1);
3417: }
3418: }
3419: MC68901.mfpVdispFall ();
3420: if (crtClearFrames != 0) {
3421: crtClearFrames--;
3422: }
3423: if (crtDirtyY0 >= 0) {
3424: crtUpdateScreen ();
3425: if (CRT_ENABLE_INTERMITTENT) {
3426: crtIntermittentCounter = crtIntermittentInterval;
3427: }
3428: }
3429: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3430: crtDoFrameTask ();
3431: }
3432: TickerQueue.tkqAdd (crtTicker = SlitDrawIdleSync, crtClock += crtHFrontLength);
3433: }
3434: } else {
3435:
3436: if (crtBeginningAllStamp != crtAllStamp) {
3437: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, true);
3438: crtScanlineEffect.drawRaster (crtScreenY + 1);
3439: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3440: crtStereoscopicDrawRaster (crtScreenY);
3441: crtStereoscopicDrawRaster (crtScreenY + 1);
3442: }
3443: }
3444: crtScreenY += 2;
3445: crtDataY++;
3446: TickerQueue.tkqAdd (crtTicker = SlitDrawDispSync, crtClock += crtHFrontLength);
3447: }
3448: }
3449: };
3450:
3451: public static final TickerQueue.Ticker SlitDrawDispSync = new TickerQueue.Ticker () {
3452: @Override protected void tick () {
3453: MC68901.mfpHsyncRise ();
3454: if (crtClearFrames != 0) {
3455: crtRapidClear (crtDataY);
3456: crtRasterStamp[crtDataY] = 0;
3457: }
3458: TickerQueue.tkqAdd (crtTicker = SlitDrawDispBack, crtClock += crtHSyncLength);
3459: }
3460: };
3461:
3462: public static final TickerQueue.Ticker SlitDrawDispBack = new TickerQueue.Ticker () {
3463: @Override protected void tick () {
3464: MC68901.mfpHsyncFall ();
3465: TickerQueue.tkqAdd (crtTicker = SlitDrawDispDisp, crtClock += crtHBackLength);
3466: }
3467: };
3468:
3469: public static final TickerQueue.Ticker SlitDrawDispDisp = new TickerQueue.Ticker () {
3470: @Override protected void tick () {
3471: if (crtRasterStamp[crtDataY] != crtAllStamp) {
3472: crtRasterStamp[crtDataY] = crtAllStamp;
3473: crtBeginningAllStamp = crtAllStamp;
3474: VideoController.vcnMode.drawRaster (crtDataY, crtScreenY, false);
3475: crtScanlineEffect.drawRaster (crtScreenY + 1);
3476: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3477: crtStereoscopicDrawRaster (crtScreenY);
3478: crtStereoscopicDrawRaster (crtScreenY + 1);
3479: }
3480: if (crtDirtyY0 < 0) {
3481: crtDirtyY0 = crtScreenY;
3482: }
3483: crtDirtyY1 = crtScreenY + 1;
3484: }
3485: if (SpriteScreen.SPR_THREE_STEPS) {
3486: if (SpriteScreen.sprActive) {
3487:
3488:
3489: SpriteScreen.sprStep1 (crtDataY + 2);
3490: SpriteScreen.sprSwap ();
3491: SpriteScreen.sprStep2 (crtDataY + 1);
3492: }
3493: }
3494: TickerQueue.tkqAdd (crtTicker = SlitDrawDispFront, crtClock += crtHDispLength);
3495: }
3496: };
3497:
3498: public static final TickerQueue.Ticker SlitOmitIdleFront = new TickerQueue.Ticker () {
3499: @Override protected void tick () {
3500: int n = ++crtRasterNumber;
3501: if (!CRT_RASTER_HASH_ON || crtRasterHashIdle << n < CRT_RASTER_HASH_ZERO) {
3502: if (crtR04VFrontEndCurr < n) {
3503: n = crtRasterNumber = 0;
3504: }
3505: if (crtRasterCopyOn) {
3506: crtDoRasterCopy ();
3507: }
3508: if (RasterBreakPoint.RBP_ON) {
3509: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3510: RasterBreakPoint.rbpFire ();
3511: }
3512: }
3513: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3514: if (irq != MC68901.mfpGpipRint) {
3515: if (irq == 0) {
3516: if (RasterBreakPoint.RBP_ON) {
3517: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3518: RasterBreakPoint.rbpFire ();
3519: }
3520: }
3521: MC68901.mfpRintFall ();
3522: } else {
3523: MC68901.mfpRintRise ();
3524: }
3525: }
3526: if (n != crtVDispStart) {
3527: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3528: } else {
3529: MC68901.mfpVdispRise ();
3530: crtR11TxYZero = crtR11TxYCurr;
3531: crtR13GrYZero[0] = crtR13GrYCurr[0];
3532: crtR13GrYZero[1] = crtR13GrYCurr[1];
3533: crtR13GrYZero[2] = crtR13GrYCurr[2];
3534: crtR13GrYZero[3] = crtR13GrYCurr[3];
3535: if (crtR11TxYZeroLast != crtR11TxYZero ||
3536: crtR13GrYZeroLast[0] != crtR13GrYZero[0] ||
3537: crtR13GrYZeroLast[1] != crtR13GrYZero[1] ||
3538: crtR13GrYZeroLast[2] != crtR13GrYZero[2] ||
3539: crtR13GrYZeroLast[3] != crtR13GrYZero[3]) {
3540: crtR11TxYZeroLast = crtR11TxYZero;
3541: crtR13GrYZeroLast[0] = crtR13GrYZero[0];
3542: crtR13GrYZeroLast[1] = crtR13GrYZero[1];
3543: crtR13GrYZeroLast[2] = crtR13GrYZero[2];
3544: crtR13GrYZeroLast[3] = crtR13GrYZero[3];
3545: crtAllStamp += 2;
3546: }
3547: crtDataY = 0;
3548: if (crtClearStandby) {
3549: crtClearStandby = false;
3550: crtClearFrames = 1;
3551: }
3552: if (SpriteScreen.SPR_THREE_STEPS) {
3553: SpriteScreen.sprActive = (SpriteScreen.sprReg8ResoCurr & 10) == 0;
3554: if (SpriteScreen.sprActive) {
3555: crtAllStamp += 2;
3556:
3557: SpriteScreen.sprStep1 (0);
3558: SpriteScreen.sprSwap ();
3559:
3560:
3561: SpriteScreen.sprStep1 (1);
3562: SpriteScreen.sprSwap ();
3563: SpriteScreen.sprStep2 (0);
3564: }
3565: }
3566: if (XEiJ.PNL_STEREOSCOPIC_ON && XEiJ.pnlStereoscopicOn) {
3567: crtStereoscopicStart ();
3568: }
3569: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3570: }
3571: } else {
3572:
3573: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3574: }
3575: }
3576: };
3577:
3578: public static final TickerQueue.Ticker SlitOmitIdleSync = new TickerQueue.Ticker () {
3579: @Override protected void tick () {
3580: MC68901.mfpHsyncRise ();
3581: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleBackDisp, crtClock += crtHSyncLength);
3582: }
3583: };
3584:
3585: public static final TickerQueue.Ticker SlitOmitIdleBackDisp = new TickerQueue.Ticker () {
3586: @Override protected void tick () {
3587: MC68901.mfpHsyncFall ();
3588: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleFront, crtClock += crtHBackDispLength);
3589: }
3590: };
3591:
3592: public static final TickerQueue.Ticker SlitOmitDispFront = new TickerQueue.Ticker () {
3593: @Override protected void tick () {
3594: int n = ++crtRasterNumber;
3595: if (!CRT_RASTER_HASH_ON || crtRasterHashDisp << n < CRT_RASTER_HASH_ZERO) {
3596: if (crtRasterCopyOn) {
3597: crtDoRasterCopy ();
3598: }
3599: if (RasterBreakPoint.RBP_ON) {
3600: if (n == RasterBreakPoint.rbpActiveBreakRaster) {
3601: RasterBreakPoint.rbpFire ();
3602: }
3603: }
3604: int irq = n == crtR09IRQRasterCurr ? 0 : MC68901.MFP_GPIP_RINT_MASK;
3605: if (irq != MC68901.mfpGpipRint) {
3606: if (irq == 0) {
3607: if (RasterBreakPoint.RBP_ON) {
3608: if (RasterBreakPoint.rbpIRQBreakEnabled) {
3609: RasterBreakPoint.rbpFire ();
3610: }
3611: }
3612: MC68901.mfpRintFall ();
3613: } else {
3614: MC68901.mfpRintRise ();
3615: }
3616: }
3617: if (n != crtVIdleStart) {
3618: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3619: } else {
3620: MC68901.mfpVdispFall ();
3621: if (crtClearFrames != 0) {
3622: crtClearFrames--;
3623: }
3624: if (CRT_ENABLE_INTERMITTENT) {
3625: crtIntermittentCounter--;
3626: }
3627: if (XEiJ.mpuClockTime >= crtFrameTaskClock) {
3628: crtDoFrameTask ();
3629: }
3630: TickerQueue.tkqAdd (crtTicker = SlitOmitIdleSync, crtClock += crtHFrontLength);
3631: }
3632: } else {
3633:
3634: TickerQueue.tkqAdd (crtTicker = SlitOmitDispSync, crtClock += crtHFrontLength);
3635: }
3636: }
3637: };
3638:
3639: public static final TickerQueue.Ticker SlitOmitDispSync = new TickerQueue.Ticker () {
3640: @Override protected void tick () {
3641: MC68901.mfpHsyncRise ();
3642: if (crtClearFrames != 0) {
3643: crtRapidClear (crtDataY);
3644: crtRasterStamp[crtDataY] = 0;
3645: }
3646: TickerQueue.tkqAdd (crtTicker = SlitOmitDispBackDisp, crtClock += crtHSyncLength);
3647: }
3648: };
3649:
3650: public static final TickerQueue.Ticker SlitOmitDispBackDisp = new TickerQueue.Ticker () {
3651: @Override protected void tick () {
3652: MC68901.mfpHsyncFall ();
3653: TickerQueue.tkqAdd (crtTicker = SlitOmitDispFront, crtClock += crtHBackDispLength);
3654: }
3655: };
3656:
3657:
3658:
3659: }
3660:
3661:
3662: