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