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