DrawingMode.java
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13: package xeij;
14:
15: public enum DrawingMode {
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:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602:
603:
604:
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645:
646:
647:
648:
649:
650:
651:
652:
653:
654:
655:
656:
657:
658:
659:
660:
661:
662:
663:
664:
665:
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691:
692:
693:
694:
695:
696:
697:
698:
699:
700:
701:
702:
703:
704:
705:
706:
707:
708:
709:
710:
711:
712:
713:
714:
715:
716:
717:
718:
719:
720:
721:
722:
723:
724:
725:
726:
727:
728:
729:
730:
731:
732:
733:
734:
735:
736:
737:
738:
739:
740:
741:
742:
743:
744:
745:
746:
747:
748:
749:
750:
751:
752:
753:
754:
755:
756:
757:
758:
759:
760:
761:
762:
763:
764:
765:
766:
767:
768:
769:
770:
771:
772:
773:
774:
775:
776:
777:
778:
779:
780:
781:
782:
783:
784:
785:
786:
787:
788:
789:
790:
791:
792:
793:
794:
795:
796:
797:
798:
799:
800:
801:
802:
803:
804:
805:
806:
807:
808:
809:
810:
811:
812:
813:
814:
815:
816:
817:
818:
819:
820:
821:
822:
823:
824:
825:
826:
827:
828:
829:
830:
831:
832:
833:
834:
835:
836:
837:
838:
839:
840:
841:
842:
843:
844:
845:
846:
847:
848:
849:
850:
851:
852:
853:
854:
855:
856:
857:
858:
859:
860:
861:
862:
863:
864:
865:
866:
867:
868:
869:
870:
871:
872:
873:
874:
875:
876:
877:
878:
879:
880:
881:
882:
883:
884:
885:
886:
887:
888:
889:
890:
891:
892:
893:
894:
895:
896:
897:
898:
899:
900:
901:
902:
903:
904:
905:
906:
907:
908:
909:
910:
911:
912:
913:
914:
915:
916:
917:
918:
919:
920:
921:
922:
923:
924:
925:
926:
927:
928:
929:
930:
931:
932:
933:
934:
935:
936:
937:
938:
939:
940:
941:
942:
943:
944:
945:
946:
947:
948:
949:
950:
951:
952:
953:
954:
955:
956:
957:
958:
959:
960:
961:
962:
963:
964:
965:
966:
967:
968:
969:
970:
971:
972:
973:
974:
975:
976:
977:
978:
979:
980:
981:
982:
983:
984:
985:
986:
987:
988:
989:
990:
991:
992:
993:
994:
995:
996:
997:
998:
999:
1000:
1001:
1002:
1003:
1004:
1005:
1006:
1007:
1008:
1009:
1010:
1011:
1012:
1013:
1014:
1015:
1016:
1017:
1018:
1019:
1020:
1021:
1022:
1023:
1024:
1025:
1026:
1027:
1028:
1029:
1030:
1031:
1032:
1033:
1034:
1035:
1036:
1037:
1038:
1039:
1040:
1041:
1042:
1043:
1044:
1045:
1046:
1047:
1048:
1049:
1050:
1051:
1052:
1053:
1054:
1055:
1056:
1057:
1058:
1059:
1060:
1061:
1062:
1063:
1064:
1065:
1066:
1067:
1068:
1069:
1070:
1071:
1072:
1073:
1074:
1075:
1076:
1077:
1078:
1079:
1080:
1081:
1082:
1083:
1084:
1085:
1086:
1087:
1088:
1089:
1090:
1091:
1092:
1093:
1094:
1095:
1096:
1097:
1098:
1099:
1100:
1101:
1102:
1103:
1104:
1105:
1106:
1107:
1108:
1109:
1110:
1111:
1112:
1113:
1114:
1115:
1116:
1117:
1118:
1119:
1120:
1121:
1122:
1123:
1124:
1125:
1126:
1127:
1128:
1129:
1130:
1131:
1132:
1133:
1134:
1135:
1136:
1137:
1138:
1139:
1140:
1141:
1142:
1143:
1144:
1145:
1146:
1147:
1148:
1149:
1150:
1151:
1152:
1153:
1154:
1155:
1156:
1157:
1158:
1159:
1160:
1161:
1162:
1163:
1164:
1165:
1166:
1167:
1168:
1169:
1170:
1171:
1172:
1173:
1174:
1175:
1176:
1177:
1178:
1179:
1180:
1181:
1182:
1183:
1184:
1185:
1186:
1187:
1188:
1189:
1190:
1191:
1192:
1193:
1194:
1195:
1196:
1197:
1198:
1199:
1200:
1201:
1202:
1203:
1204:
1205:
1206:
1207:
1208:
1209:
1210:
1211:
1212:
1213:
1214:
1215:
1216:
1217:
1218:
1219:
1220:
1221:
1222:
1223:
1224:
1225:
1226:
1227:
1228:
1229:
1230:
1231:
1232:
1233:
1234:
1235:
1236:
1237:
1238:
1239:
1240:
1241:
1242:
1243:
1244:
1245:
1246:
1247:
1248:
1249:
1250:
1251:
1252:
1253:
1254:
1255:
1256:
1257:
1258:
1259:
1260:
1261:
1262:
1263:
1264:
1265:
1266:
1267:
1268:
1269:
1270:
1271:
1272:
1273:
1274:
1275:
1276:
1277:
1278:
1279:
1280:
1281:
1282:
1283:
1284:
1285:
1286:
1287:
1288:
1289:
1290:
1291:
1292:
1293:
1294:
1295:
1296:
1297:
1298:
1299:
1300:
1301:
1302:
1303:
1304:
1305:
1306:
1307:
1308:
1309:
1310:
1311:
1312:
1313:
1314:
1315:
1316:
1317:
1318:
1319:
1320:
1321:
1322:
1323:
1324:
1325:
1326:
1327:
1328:
1329:
1330:
1331:
1332:
1333:
1334:
1335:
1336:
1337:
1338:
1339:
1340:
1341:
1342:
1343:
1344:
1345:
1346:
1347:
1348:
1349:
1350:
1351:
1352:
1353:
1354:
1355:
1356:
1357:
1358:
1359:
1360:
1361:
1362:
1363:
1364:
1365:
1366:
1367:
1368:
1369:
1370:
1371:
1372:
1373:
1374:
1375:
1376:
1377:
1378:
1379:
1380:
1381:
1382:
1383:
1384:
1385:
1386:
1387:
1388:
1389:
1390:
1391:
1392:
1393:
1394:
1395:
1396:
1397:
1398:
1399:
1400:
1401:
1402:
1403:
1404:
1405:
1406:
1407:
1408:
1409:
1410:
1411: N {
1412: @Override public void drawRaster (int src, int dst) {
1413: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
1414: int db = da + XEiJ.pnlScreenWidth;
1415: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
1416: int half = XEiJ.pnlScreenWidth >> 4 << 3;
1417: da += half;
1418: }
1419: while (da < db) {
1420: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[0]);
1421: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[0]);
1422: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[0]);
1423: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[0]);
1424: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[0]);
1425: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[0]);
1426: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[0]);
1427: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[0]);
1428: da += 8;
1429: }
1430: }
1431: },
1432:
1433:
1434:
1435:
1436:
1437:
1438: XN {
1439: @Override public void drawRaster (int src, int dst) {
1440: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
1441:
1442: case 0b00010000:
1443: case 0b00010001:
1444: case 0b00010010:
1445: case 0b00010011:
1446: N.drawRaster (src, dst);
1447: break;
1448:
1449: case 0b00010100:
1450: case 0b00010101:
1451: case 0b00010110:
1452: case 0b00010111:
1453: N.drawRaster (src, dst);
1454: break;
1455:
1456: case 0b00011000:
1457: N.drawRaster (src, dst);
1458: break;
1459:
1460: case 0b00011001:
1461: N.drawRaster (src, dst);
1462: break;
1463:
1464: case 0b00011010:
1465: N.drawRaster (src, dst);
1466: break;
1467:
1468: case 0b00011011:
1469: N.drawRaster (src, dst);
1470: break;
1471:
1472: case 0b00011101:
1473: N.drawRaster (src, dst);
1474: break;
1475:
1476: case 0b00011110:
1477: N.drawRaster (src, dst);
1478: break;
1479:
1480: case 0b00011111:
1481: N.drawRaster (src, dst);
1482: break;
1483:
1484: case 0b01000000:
1485: case 0b01000001:
1486: case 0b01000010:
1487: case 0b01000011:
1488: case 0b01000100:
1489: case 0b01000101:
1490: case 0b01000110:
1491: case 0b01000111:
1492: case 0b01001000:
1493: case 0b01001001:
1494: case 0b01001010:
1495: case 0b01001011:
1496: case 0b01001100:
1497: case 0b01001101:
1498: case 0b01001110:
1499: case 0b01001111:
1500: case 0b01010000:
1501: case 0b01010001:
1502: case 0b01010010:
1503: case 0b01010011:
1504: case 0b01010100:
1505: case 0b01010101:
1506: case 0b01010110:
1507: case 0b01010111:
1508: case 0b01011000:
1509: case 0b01011001:
1510: case 0b01011010:
1511: case 0b01011011:
1512: case 0b01011100:
1513: case 0b01011101:
1514: case 0b01011110:
1515: case 0b01011111:
1516: N.drawRaster (src, dst);
1517: break;
1518: default:
1519: N.drawRaster (src, dst);
1520: VideoController.vcnReportUnimplemented (XN);
1521: }
1522: }
1523: },
1524:
1525:
1526:
1527:
1528:
1529:
1530:
1531:
1532:
1533:
1534:
1535:
1536:
1537:
1538:
1539:
1540:
1541:
1542:
1543:
1544: S {
1545: @Override public void drawRaster (int src, int dst) {
1546: SpriteScreen.sprStep3 ();
1547: int sx = 16;
1548: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
1549: int db = da + XEiJ.pnlScreenWidth;
1550: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
1551: int half = XEiJ.pnlScreenWidth >> 4 << 3;
1552: sx += half;
1553: da += half;
1554: }
1555: while (da < db) {
1556: XEiJ.pnlBM[da] = (VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx]]);
1557: XEiJ.pnlBM[da + 1] = (VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 1]]);
1558: XEiJ.pnlBM[da + 2] = (VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 2]]);
1559: XEiJ.pnlBM[da + 3] = (VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 3]]);
1560: XEiJ.pnlBM[da + 4] = (VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 4]]);
1561: XEiJ.pnlBM[da + 5] = (VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 5]]);
1562: XEiJ.pnlBM[da + 6] = (VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 6]]);
1563: XEiJ.pnlBM[da + 7] = (VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 7]]);
1564: sx += 8;
1565: da += 8;
1566: }
1567: }
1568: },
1569:
1570:
1571:
1572:
1573:
1574:
1575: XS {
1576: @Override public void drawRaster (int src, int dst) {
1577: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
1578:
1579: case 0b00010000:
1580: case 0b00010001:
1581: case 0b00010010:
1582: case 0b00010011:
1583: S.drawRaster (src, dst);
1584: break;
1585:
1586: case 0b00010100:
1587: case 0b00010101:
1588: case 0b00010110:
1589: case 0b00010111:
1590: S.drawRaster (src, dst);
1591: break;
1592:
1593: case 0b00011000:
1594: S.drawRaster (src, dst);
1595: break;
1596:
1597: case 0b00011001:
1598: S.drawRaster (src, dst);
1599: break;
1600:
1601: case 0b00011010:
1602: S.drawRaster (src, dst);
1603: break;
1604:
1605: case 0b00011011:
1606: S.drawRaster (src, dst);
1607: break;
1608:
1609: case 0b00011101:
1610: S.drawRaster (src, dst);
1611: break;
1612:
1613: case 0b00011110:
1614: S.drawRaster (src, dst);
1615: break;
1616:
1617: case 0b00011111:
1618: S.drawRaster (src, dst);
1619: break;
1620:
1621: case 0b01000000:
1622: case 0b01000001:
1623: case 0b01000010:
1624: case 0b01000011:
1625: case 0b01000100:
1626: case 0b01000101:
1627: case 0b01000110:
1628: case 0b01000111:
1629: case 0b01001000:
1630: case 0b01001001:
1631: case 0b01001010:
1632: case 0b01001011:
1633: case 0b01001100:
1634: case 0b01001101:
1635: case 0b01001110:
1636: case 0b01001111:
1637: case 0b01010000:
1638: case 0b01010001:
1639: case 0b01010010:
1640: case 0b01010011:
1641: case 0b01010100:
1642: case 0b01010101:
1643: case 0b01010110:
1644: case 0b01010111:
1645: case 0b01011000:
1646: case 0b01011001:
1647: case 0b01011010:
1648: case 0b01011011:
1649: case 0b01011100:
1650: case 0b01011101:
1651: case 0b01011110:
1652: case 0b01011111:
1653: N.drawRaster (src, dst);
1654: break;
1655: default:
1656: S.drawRaster (src, dst);
1657: VideoController.vcnReportUnimplemented (XS);
1658: }
1659: }
1660: },
1661:
1662:
1663:
1664:
1665:
1666:
1667:
1668:
1669:
1670:
1671:
1672:
1673:
1674:
1675:
1676:
1677:
1678:
1679:
1680:
1681: T {
1682: @Override public void drawRaster (int src, int dst) {
1683: int tc = CRTC.crtR10TxXCurr >> 3;
1684: int ta0 = 0x00e00000 + ((CRTC.crtR11TxYZero + src & 1023) << 7);
1685: int ta1 = 0x00020000 + ta0;
1686: int ta2 = 0x00040000 + ta0;
1687: int ta3 = 0x00060000 + ta0;
1688: int ts = CRTC.crtR10TxXCurr & 7;
1689: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
1690: int db = da + XEiJ.pnlScreenWidth;
1691: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
1692: int half = XEiJ.pnlScreenWidth >> 4 << 3;
1693: tc = tc + (half >> 3) & 127;
1694: da += half;
1695: }
1696: if (ts == 0) {
1697: while (da < db) {
1698: int tp = (VideoController.VCN_TXP3[MainMemory.mmrM8[ta3 + tc] & 255] |
1699: VideoController.VCN_TXP2[MainMemory.mmrM8[ta2 + tc] & 255] |
1700: VideoController.VCN_TXP1[MainMemory.mmrM8[ta1 + tc] & 255] |
1701: VideoController.VCN_TXP0[MainMemory.mmrM8[ta0 + tc] & 255]);
1702: tc = tc + 1 & 127;
1703: XEiJ.pnlBM[da] = (VideoController.vcnPal32TS[tp >>> 28]);
1704: XEiJ.pnlBM[da + 1] = (VideoController.vcnPal32TS[tp >>> 24 & 15]);
1705: XEiJ.pnlBM[da + 2] = (VideoController.vcnPal32TS[tp >>> 20 & 15]);
1706: XEiJ.pnlBM[da + 3] = (VideoController.vcnPal32TS[tp >>> 16 & 15]);
1707: XEiJ.pnlBM[da + 4] = (VideoController.vcnPal32TS[tp >>> 12 & 15]);
1708: XEiJ.pnlBM[da + 5] = (VideoController.vcnPal32TS[tp >>> 8 & 15]);
1709: XEiJ.pnlBM[da + 6] = (VideoController.vcnPal32TS[tp >>> 4 & 15]);
1710: XEiJ.pnlBM[da + 7] = (VideoController.vcnPal32TS[tp & 15]);
1711: da += 8;
1712: }
1713: } else {
1714:
1715: int tt = ts + 8;
1716: ts += 16;
1717:
1718: int p0 = MainMemory.mmrM8[ta0 + tc] << ts;
1719: int p1 = MainMemory.mmrM8[ta1 + tc] << ts;
1720: int p2 = MainMemory.mmrM8[ta2 + tc] << ts;
1721: int p3 = MainMemory.mmrM8[ta3 + tc] << ts;
1722: tc = tc + 1 & 127;
1723: while (da < db) {
1724:
1725:
1726: p0 = (p0 >> tt | MainMemory.mmrM8[ta0 + tc] & 255) << ts;
1727: p1 = (p1 >> tt | MainMemory.mmrM8[ta1 + tc] & 255) << ts;
1728: p2 = (p2 >> tt | MainMemory.mmrM8[ta2 + tc] & 255) << ts;
1729: p3 = (p3 >> tt | MainMemory.mmrM8[ta3 + tc] & 255) << ts;
1730: int tp = (VideoController.VCN_TXP3[p3 >>> 24] |
1731: VideoController.VCN_TXP2[p2 >>> 24] |
1732: VideoController.VCN_TXP1[p1 >>> 24] |
1733: VideoController.VCN_TXP0[p0 >>> 24]);
1734: tc = tc + 1 & 127;
1735: XEiJ.pnlBM[da] = (VideoController.vcnPal32TS[tp >>> 28]);
1736: XEiJ.pnlBM[da + 1] = (VideoController.vcnPal32TS[tp >>> 24 & 15]);
1737: XEiJ.pnlBM[da + 2] = (VideoController.vcnPal32TS[tp >>> 20 & 15]);
1738: XEiJ.pnlBM[da + 3] = (VideoController.vcnPal32TS[tp >>> 16 & 15]);
1739: XEiJ.pnlBM[da + 4] = (VideoController.vcnPal32TS[tp >>> 12 & 15]);
1740: XEiJ.pnlBM[da + 5] = (VideoController.vcnPal32TS[tp >>> 8 & 15]);
1741: XEiJ.pnlBM[da + 6] = (VideoController.vcnPal32TS[tp >>> 4 & 15]);
1742: XEiJ.pnlBM[da + 7] = (VideoController.vcnPal32TS[tp & 15]);
1743: da += 8;
1744: }
1745: }
1746: }
1747: },
1748:
1749:
1750:
1751:
1752:
1753:
1754: XT {
1755: @Override public void drawRaster (int src, int dst) {
1756: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
1757:
1758: case 0b00010000:
1759: case 0b00010001:
1760: case 0b00010010:
1761: case 0b00010011:
1762: T.drawRaster (src, dst);
1763: break;
1764:
1765: case 0b00010100:
1766: case 0b00010101:
1767: case 0b00010110:
1768: case 0b00010111:
1769: T.drawRaster (src, dst);
1770: break;
1771:
1772: case 0b00011000:
1773: T.drawRaster (src, dst);
1774: break;
1775:
1776: case 0b00011001:
1777: T.drawRaster (src, dst);
1778: break;
1779:
1780: case 0b00011010:
1781: T.drawRaster (src, dst);
1782: break;
1783:
1784: case 0b00011011:
1785: T.drawRaster (src, dst);
1786: break;
1787:
1788: case 0b00011101:
1789: T.drawRaster (src, dst);
1790: break;
1791:
1792: case 0b00011110:
1793: T.drawRaster (src, dst);
1794: break;
1795:
1796: case 0b00011111:
1797: T.drawRaster (src, dst);
1798: break;
1799:
1800: case 0b01000000:
1801: case 0b01000001:
1802: case 0b01000010:
1803: case 0b01000011:
1804: case 0b01000100:
1805: case 0b01000101:
1806: case 0b01000110:
1807: case 0b01000111:
1808: case 0b01001000:
1809: case 0b01001001:
1810: case 0b01001010:
1811: case 0b01001011:
1812: case 0b01001100:
1813: case 0b01001101:
1814: case 0b01001110:
1815: case 0b01001111:
1816: case 0b01010000:
1817: case 0b01010001:
1818: case 0b01010010:
1819: case 0b01010011:
1820: case 0b01010100:
1821: case 0b01010101:
1822: case 0b01010110:
1823: case 0b01010111:
1824: case 0b01011000:
1825: case 0b01011001:
1826: case 0b01011010:
1827: case 0b01011011:
1828: case 0b01011100:
1829: case 0b01011101:
1830: case 0b01011110:
1831: case 0b01011111:
1832: N.drawRaster (src, dst);
1833: break;
1834: default:
1835: T.drawRaster (src, dst);
1836: VideoController.vcnReportUnimplemented (XT);
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: ST {
1864: @Override public void drawRaster (int src, int dst) {
1865: SpriteScreen.sprStep3 ();
1866: int sx = 16;
1867: int tc = CRTC.crtR10TxXCurr >> 3;
1868: int ta0 = 0x00e00000 + ((CRTC.crtR11TxYZero + src & 1023) << 7);
1869: int ta1 = 0x00020000 + ta0;
1870: int ta2 = 0x00040000 + ta0;
1871: int ta3 = 0x00060000 + ta0;
1872: int ts = CRTC.crtR10TxXCurr & 7;
1873: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
1874: int db = da + XEiJ.pnlScreenWidth;
1875: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
1876: int half = XEiJ.pnlScreenWidth >> 4 << 3;
1877: sx += half;
1878: tc = tc + (half >> 3) & 127;
1879: da += half;
1880: }
1881: if (ts == 0) {
1882: while (da < db) {
1883: int tp = (VideoController.VCN_TXP3[MainMemory.mmrM8[ta3 + tc] & 255] |
1884: VideoController.VCN_TXP2[MainMemory.mmrM8[ta2 + tc] & 255] |
1885: VideoController.VCN_TXP1[MainMemory.mmrM8[ta1 + tc] & 255] |
1886: VideoController.VCN_TXP0[MainMemory.mmrM8[ta0 + tc] & 255]);
1887: tc = tc + 1 & 127;
1888: int p, q;
1889: XEiJ.pnlBM[da] = (((p = SpriteScreen.sprBuffer[sx]) & 15) != 0 || (q = tp >>> 28) == 0 ?
1890: VideoController.vcnPal32TS[p] :
1891: VideoController.vcnPal32TS[q]);
1892: XEiJ.pnlBM[da + 1] = (((p = SpriteScreen.sprBuffer[sx + 1]) & 15) != 0 || (q = tp >>> 24 & 15) == 0 ?
1893: VideoController.vcnPal32TS[p] :
1894: VideoController.vcnPal32TS[q]);
1895: XEiJ.pnlBM[da + 2] = (((p = SpriteScreen.sprBuffer[sx + 2]) & 15) != 0 || (q = tp >>> 20 & 15) == 0 ?
1896: VideoController.vcnPal32TS[p] :
1897: VideoController.vcnPal32TS[q]);
1898: XEiJ.pnlBM[da + 3] = (((p = SpriteScreen.sprBuffer[sx + 3]) & 15) != 0 || (q = tp >>> 16 & 15) == 0 ?
1899: VideoController.vcnPal32TS[p] :
1900: VideoController.vcnPal32TS[q]);
1901: XEiJ.pnlBM[da + 4] = (((p = SpriteScreen.sprBuffer[sx + 4]) & 15) != 0 || (q = tp >>> 12 & 15) == 0 ?
1902: VideoController.vcnPal32TS[p] :
1903: VideoController.vcnPal32TS[q]);
1904: XEiJ.pnlBM[da + 5] = (((p = SpriteScreen.sprBuffer[sx + 5]) & 15) != 0 || (q = tp >>> 8 & 15) == 0 ?
1905: VideoController.vcnPal32TS[p] :
1906: VideoController.vcnPal32TS[q]);
1907: XEiJ.pnlBM[da + 6] = (((p = SpriteScreen.sprBuffer[sx + 6]) & 15) != 0 || (q = tp >>> 4 & 15) == 0 ?
1908: VideoController.vcnPal32TS[p] :
1909: VideoController.vcnPal32TS[q]);
1910: XEiJ.pnlBM[da + 7] = (((p = SpriteScreen.sprBuffer[sx + 7]) & 15) != 0 || (q = tp & 15) == 0 ?
1911: VideoController.vcnPal32TS[p] :
1912: VideoController.vcnPal32TS[q]);
1913: sx += 8;
1914: da += 8;
1915: }
1916: } else {
1917:
1918: int tt = ts + 8;
1919: ts += 16;
1920:
1921: int p0 = MainMemory.mmrM8[ta0 + tc] << ts;
1922: int p1 = MainMemory.mmrM8[ta1 + tc] << ts;
1923: int p2 = MainMemory.mmrM8[ta2 + tc] << ts;
1924: int p3 = MainMemory.mmrM8[ta3 + tc] << ts;
1925: tc = tc + 1 & 127;
1926: while (da < db) {
1927:
1928:
1929: p0 = (p0 >> tt | MainMemory.mmrM8[ta0 + tc] & 255) << ts;
1930: p1 = (p1 >> tt | MainMemory.mmrM8[ta1 + tc] & 255) << ts;
1931: p2 = (p2 >> tt | MainMemory.mmrM8[ta2 + tc] & 255) << ts;
1932: p3 = (p3 >> tt | MainMemory.mmrM8[ta3 + tc] & 255) << ts;
1933: int tp = (VideoController.VCN_TXP3[p3 >>> 24] |
1934: VideoController.VCN_TXP2[p2 >>> 24] |
1935: VideoController.VCN_TXP1[p1 >>> 24] |
1936: VideoController.VCN_TXP0[p0 >>> 24]);
1937: tc = tc + 1 & 127;
1938: int p, q;
1939: XEiJ.pnlBM[da] = (((p = SpriteScreen.sprBuffer[sx]) & 15) != 0 || (q = tp >>> 28) == 0 ?
1940: VideoController.vcnPal32TS[p] :
1941: VideoController.vcnPal32TS[q]);
1942: XEiJ.pnlBM[da + 1] = (((p = SpriteScreen.sprBuffer[sx + 1]) & 15) != 0 || (q = tp >>> 24 & 15) == 0 ?
1943: VideoController.vcnPal32TS[p] :
1944: VideoController.vcnPal32TS[q]);
1945: XEiJ.pnlBM[da + 2] = (((p = SpriteScreen.sprBuffer[sx + 2]) & 15) != 0 || (q = tp >>> 20 & 15) == 0 ?
1946: VideoController.vcnPal32TS[p] :
1947: VideoController.vcnPal32TS[q]);
1948: XEiJ.pnlBM[da + 3] = (((p = SpriteScreen.sprBuffer[sx + 3]) & 15) != 0 || (q = tp >>> 16 & 15) == 0 ?
1949: VideoController.vcnPal32TS[p] :
1950: VideoController.vcnPal32TS[q]);
1951: XEiJ.pnlBM[da + 4] = (((p = SpriteScreen.sprBuffer[sx + 4]) & 15) != 0 || (q = tp >>> 12 & 15) == 0 ?
1952: VideoController.vcnPal32TS[p] :
1953: VideoController.vcnPal32TS[q]);
1954: XEiJ.pnlBM[da + 5] = (((p = SpriteScreen.sprBuffer[sx + 5]) & 15) != 0 || (q = tp >>> 8 & 15) == 0 ?
1955: VideoController.vcnPal32TS[p] :
1956: VideoController.vcnPal32TS[q]);
1957: XEiJ.pnlBM[da + 6] = (((p = SpriteScreen.sprBuffer[sx + 6]) & 15) != 0 || (q = tp >>> 4 & 15) == 0 ?
1958: VideoController.vcnPal32TS[p] :
1959: VideoController.vcnPal32TS[q]);
1960: XEiJ.pnlBM[da + 7] = (((p = SpriteScreen.sprBuffer[sx + 7]) & 15) != 0 || (q = tp & 15) == 0 ?
1961: VideoController.vcnPal32TS[p] :
1962: VideoController.vcnPal32TS[q]);
1963: sx += 8;
1964: da += 8;
1965: }
1966: }
1967: }
1968: },
1969:
1970:
1971:
1972:
1973:
1974:
1975: XST {
1976: @Override public void drawRaster (int src, int dst) {
1977: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
1978:
1979: case 0b00010000:
1980: case 0b00010001:
1981: case 0b00010010:
1982: case 0b00010011:
1983: ST.drawRaster (src, dst);
1984: break;
1985:
1986: case 0b00010100:
1987: case 0b00010101:
1988: case 0b00010110:
1989: case 0b00010111:
1990: ST.drawRaster (src, dst);
1991: break;
1992:
1993: case 0b00011000:
1994: ST.drawRaster (src, dst);
1995: break;
1996:
1997: case 0b00011001:
1998: ST.drawRaster (src, dst);
1999: break;
2000:
2001: case 0b00011010:
2002: ST.drawRaster (src, dst);
2003: break;
2004:
2005: case 0b00011011:
2006: ST.drawRaster (src, dst);
2007: break;
2008:
2009: case 0b00011101:
2010: ST.drawRaster (src, dst);
2011: break;
2012:
2013: case 0b00011110:
2014: ST.drawRaster (src, dst);
2015: break;
2016:
2017: case 0b00011111:
2018: ST.drawRaster (src, dst);
2019: break;
2020:
2021: case 0b01000000:
2022: case 0b01000001:
2023: case 0b01000010:
2024: case 0b01000011:
2025: case 0b01000100:
2026: case 0b01000101:
2027: case 0b01000110:
2028: case 0b01000111:
2029: case 0b01001000:
2030: case 0b01001001:
2031: case 0b01001010:
2032: case 0b01001011:
2033: case 0b01001100:
2034: case 0b01001101:
2035: case 0b01001110:
2036: case 0b01001111:
2037: case 0b01010000:
2038: case 0b01010001:
2039: case 0b01010010:
2040: case 0b01010011:
2041: case 0b01010100:
2042: case 0b01010101:
2043: case 0b01010110:
2044: case 0b01010111:
2045: case 0b01011000:
2046: case 0b01011001:
2047: case 0b01011010:
2048: case 0b01011011:
2049: case 0b01011100:
2050: case 0b01011101:
2051: case 0b01011110:
2052: case 0b01011111:
2053: N.drawRaster (src, dst);
2054: break;
2055: default:
2056: ST.drawRaster (src, dst);
2057: VideoController.vcnReportUnimplemented (XST);
2058: }
2059: }
2060: },
2061:
2062:
2063:
2064:
2065:
2066:
2067:
2068:
2069:
2070:
2071:
2072:
2073:
2074:
2075:
2076:
2077:
2078:
2079:
2080:
2081:
2082:
2083:
2084: TS {
2085: @Override public void drawRaster (int src, int dst) {
2086: SpriteScreen.sprStep3 ();
2087: int sx = 16;
2088: int tc = CRTC.crtR10TxXCurr >> 3;
2089: int ta0 = 0x00e00000 + ((CRTC.crtR11TxYZero + src & 1023) << 7);
2090: int ta1 = 0x00020000 + ta0;
2091: int ta2 = 0x00040000 + ta0;
2092: int ta3 = 0x00060000 + ta0;
2093: int ts = CRTC.crtR10TxXCurr & 7;
2094: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2095: int db = da + XEiJ.pnlScreenWidth;
2096: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
2097: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2098: sx += half;
2099: tc = tc + (half >> 3) & 127;
2100: da += half;
2101: }
2102: if (ts == 0) {
2103: while (da < db) {
2104: int tp = (VideoController.VCN_TXP3[MainMemory.mmrM8[ta3 + tc] & 255] |
2105: VideoController.VCN_TXP2[MainMemory.mmrM8[ta2 + tc] & 255] |
2106: VideoController.VCN_TXP1[MainMemory.mmrM8[ta1 + tc] & 255] |
2107: VideoController.VCN_TXP0[MainMemory.mmrM8[ta0 + tc] & 255]);
2108: tc = tc + 1 & 127;
2109: int p;
2110: XEiJ.pnlBM[da] = ((p = tp >>> 28) != 0 ?
2111: VideoController.vcnPal32TS[p] :
2112: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx]]);
2113: XEiJ.pnlBM[da + 1] = ((p = tp >>> 24 & 15) != 0 ?
2114: VideoController.vcnPal32TS[p] :
2115: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 1]]);
2116: XEiJ.pnlBM[da + 2] = ((p = tp >>> 20 & 15) != 0 ?
2117: VideoController.vcnPal32TS[p] :
2118: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 2]]);
2119: XEiJ.pnlBM[da + 3] = ((p = tp >>> 16 & 15) != 0 ?
2120: VideoController.vcnPal32TS[p] :
2121: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 3]]);
2122: XEiJ.pnlBM[da + 4] = ((p = tp >>> 12 & 15) != 0 ?
2123: VideoController.vcnPal32TS[p] :
2124: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 4]]);
2125: XEiJ.pnlBM[da + 5] = ((p = tp >>> 8 & 15) != 0 ?
2126: VideoController.vcnPal32TS[p] :
2127: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 5]]);
2128: XEiJ.pnlBM[da + 6] = ((p = tp >>> 4 & 15) != 0 ?
2129: VideoController.vcnPal32TS[p] :
2130: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 6]]);
2131: XEiJ.pnlBM[da + 7] = ((p = tp & 15) != 0 ?
2132: VideoController.vcnPal32TS[p] :
2133: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 7]]);
2134: sx += 8;
2135: da += 8;
2136: }
2137: } else {
2138:
2139: int tt = ts + 8;
2140: ts += 16;
2141:
2142: int p0 = MainMemory.mmrM8[ta0 + tc] << ts;
2143: int p1 = MainMemory.mmrM8[ta1 + tc] << ts;
2144: int p2 = MainMemory.mmrM8[ta2 + tc] << ts;
2145: int p3 = MainMemory.mmrM8[ta3 + tc] << ts;
2146: tc = tc + 1 & 127;
2147: while (da < db) {
2148:
2149:
2150: p0 = (p0 >> tt | MainMemory.mmrM8[ta0 + tc] & 255) << ts;
2151: p1 = (p1 >> tt | MainMemory.mmrM8[ta1 + tc] & 255) << ts;
2152: p2 = (p2 >> tt | MainMemory.mmrM8[ta2 + tc] & 255) << ts;
2153: p3 = (p3 >> tt | MainMemory.mmrM8[ta3 + tc] & 255) << ts;
2154: int tp = (VideoController.VCN_TXP3[p3 >>> 24] |
2155: VideoController.VCN_TXP2[p2 >>> 24] |
2156: VideoController.VCN_TXP1[p1 >>> 24] |
2157: VideoController.VCN_TXP0[p0 >>> 24]);
2158: tc = tc + 1 & 127;
2159: int p;
2160: XEiJ.pnlBM[da] = ((p = tp >>> 28) != 0 ?
2161: VideoController.vcnPal32TS[p] :
2162: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx]]);
2163: XEiJ.pnlBM[da + 1] = ((p = tp >>> 24 & 15) != 0 ?
2164: VideoController.vcnPal32TS[p] :
2165: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 1]]);
2166: XEiJ.pnlBM[da + 2] = ((p = tp >>> 20 & 15) != 0 ?
2167: VideoController.vcnPal32TS[p] :
2168: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 2]]);
2169: XEiJ.pnlBM[da + 3] = ((p = tp >>> 16 & 15) != 0 ?
2170: VideoController.vcnPal32TS[p] :
2171: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 3]]);
2172: XEiJ.pnlBM[da + 4] = ((p = tp >>> 12 & 15) != 0 ?
2173: VideoController.vcnPal32TS[p] :
2174: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 4]]);
2175: XEiJ.pnlBM[da + 5] = ((p = tp >>> 8 & 15) != 0 ?
2176: VideoController.vcnPal32TS[p] :
2177: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 5]]);
2178: XEiJ.pnlBM[da + 6] = ((p = tp >>> 4 & 15) != 0 ?
2179: VideoController.vcnPal32TS[p] :
2180: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 6]]);
2181: XEiJ.pnlBM[da + 7] = ((p = tp & 15) != 0 ?
2182: VideoController.vcnPal32TS[p] :
2183: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 7]]);
2184: sx += 8;
2185: da += 8;
2186: }
2187: }
2188: }
2189: },
2190:
2191:
2192:
2193:
2194:
2195:
2196: XTS {
2197: @Override public void drawRaster (int src, int dst) {
2198: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
2199:
2200: case 0b00010000:
2201: case 0b00010001:
2202: case 0b00010010:
2203: case 0b00010011:
2204: TS.drawRaster (src, dst);
2205: break;
2206:
2207: case 0b00010100:
2208: case 0b00010101:
2209: case 0b00010110:
2210: case 0b00010111:
2211: TS.drawRaster (src, dst);
2212: break;
2213:
2214: case 0b00011000:
2215: TS.drawRaster (src, dst);
2216: break;
2217:
2218: case 0b00011001:
2219: TS.drawRaster (src, dst);
2220: break;
2221:
2222: case 0b00011010:
2223: TS.drawRaster (src, dst);
2224: break;
2225:
2226: case 0b00011011:
2227: TS.drawRaster (src, dst);
2228: break;
2229:
2230: case 0b00011101:
2231: TS.drawRaster (src, dst);
2232: break;
2233:
2234: case 0b00011110:
2235: TS.drawRaster (src, dst);
2236: break;
2237:
2238: case 0b00011111:
2239: TS.drawRaster (src, dst);
2240: break;
2241:
2242: case 0b01000000:
2243: case 0b01000001:
2244: case 0b01000010:
2245: case 0b01000011:
2246: case 0b01000100:
2247: case 0b01000101:
2248: case 0b01000110:
2249: case 0b01000111:
2250: case 0b01001000:
2251: case 0b01001001:
2252: case 0b01001010:
2253: case 0b01001011:
2254: case 0b01001100:
2255: case 0b01001101:
2256: case 0b01001110:
2257: case 0b01001111:
2258: case 0b01010000:
2259: case 0b01010001:
2260: case 0b01010010:
2261: case 0b01010011:
2262: case 0b01010100:
2263: case 0b01010101:
2264: case 0b01010110:
2265: case 0b01010111:
2266: case 0b01011000:
2267: case 0b01011001:
2268: case 0b01011010:
2269: case 0b01011011:
2270: case 0b01011100:
2271: case 0b01011101:
2272: case 0b01011110:
2273: case 0b01011111:
2274: N.drawRaster (src, dst);
2275: break;
2276: default:
2277: TS.drawRaster (src, dst);
2278: VideoController.vcnReportUnimplemented (XTS);
2279: }
2280: }
2281: },
2282:
2283:
2284:
2285:
2286:
2287:
2288:
2289:
2290:
2291:
2292:
2293:
2294:
2295:
2296:
2297:
2298:
2299:
2300:
2301:
2302: E1 {
2303: @Override public void drawRaster (int src, int dst) {
2304: int pn = VideoController.vcnReg2Curr & 3;
2305: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2306: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2307: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2308: int db = da + XEiJ.pnlScreenWidth;
2309: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
2310: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2311: gx1st += half << 1;
2312: da += half;
2313: }
2314: while (da < db) {
2315: XEiJ.pnlBM[da] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st & 1023]]);
2316: XEiJ.pnlBM[da + 1] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]]);
2317: XEiJ.pnlBM[da + 2] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]]);
2318: XEiJ.pnlBM[da + 3] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]]);
2319: XEiJ.pnlBM[da + 4] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]]);
2320: XEiJ.pnlBM[da + 5] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]]);
2321: XEiJ.pnlBM[da + 6] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]]);
2322: XEiJ.pnlBM[da + 7] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]]);
2323: gx1st += 16;
2324: da += 8;
2325: }
2326: }
2327: },
2328:
2329:
2330:
2331:
2332:
2333:
2334: XE1 {
2335: @Override public void drawRaster (int src, int dst) {
2336: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
2337:
2338: case 0b00010000:
2339: case 0b00010001:
2340: case 0b00010010:
2341: case 0b00010011:
2342: E1.drawRaster (src, dst);
2343: break;
2344:
2345: case 0b00010100:
2346: case 0b00010101:
2347: case 0b00010110:
2348: case 0b00010111:
2349: E1_XWP.drawRaster (src, dst);
2350: break;
2351:
2352: case 0b00011000:
2353: E1.drawRaster (src, dst);
2354: break;
2355:
2356: case 0b00011001:
2357: E1_XHCT.drawRaster (src, dst);
2358: break;
2359:
2360: case 0b00011010:
2361: E1_XHCG.drawRaster (src, dst);
2362: break;
2363:
2364: case 0b00011011:
2365: E1_XHCGT.drawRaster (src, dst);
2366: break;
2367:
2368: case 0b00011101:
2369: E1_XHPT.drawRaster (src, dst);
2370: break;
2371:
2372: case 0b00011110:
2373: E1_XHPG.drawRaster (src, dst);
2374: break;
2375:
2376: case 0b00011111:
2377: E1_XHPGT.drawRaster (src, dst);
2378: break;
2379:
2380: case 0b01000000:
2381: case 0b01000001:
2382: case 0b01000010:
2383: case 0b01000011:
2384: case 0b01000100:
2385: case 0b01000101:
2386: case 0b01000110:
2387: case 0b01000111:
2388: case 0b01001000:
2389: case 0b01001001:
2390: case 0b01001010:
2391: case 0b01001011:
2392: case 0b01001100:
2393: case 0b01001101:
2394: case 0b01001110:
2395: case 0b01001111:
2396: case 0b01010000:
2397: case 0b01010001:
2398: case 0b01010010:
2399: case 0b01010011:
2400: case 0b01010100:
2401: case 0b01010101:
2402: case 0b01010110:
2403: case 0b01010111:
2404: case 0b01011000:
2405: case 0b01011001:
2406: case 0b01011010:
2407: case 0b01011011:
2408: case 0b01011100:
2409: case 0b01011101:
2410: case 0b01011110:
2411: case 0b01011111:
2412: E1_A.drawRaster (src, dst);
2413: break;
2414: default:
2415: E1.drawRaster (src, dst);
2416: VideoController.vcnReportUnimplemented (XE1);
2417: }
2418: }
2419: },
2420:
2421:
2422:
2423:
2424:
2425:
2426:
2427:
2428:
2429:
2430:
2431:
2432:
2433:
2434:
2435:
2436:
2437:
2438:
2439:
2440:
2441:
2442:
2443:
2444:
2445: E1_XWP {
2446: @Override public void drawRaster (int src, int dst) {
2447: int pn = VideoController.vcnReg2Curr & 3;
2448: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2449: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2450: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2451: int db = da + XEiJ.pnlScreenWidth;
2452: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
2453: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2454: gx1st += half << 1;
2455: da += half;
2456: }
2457: while (da < db) {
2458: int p;
2459: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) <= 1 ?
2460: VideoController.vcnPal32G8[0] :
2461: (p & 1) == 0 ?
2462: VideoController.vcnPal32G8[p] :
2463: VideoController.vcnPal32G8[p & -2]);
2464: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) <= 1 ?
2465: VideoController.vcnPal32G8[0] :
2466: (p & 1) == 0 ?
2467: VideoController.vcnPal32G8[p] :
2468: VideoController.vcnPal32G8[p & -2]);
2469: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) <= 1 ?
2470: VideoController.vcnPal32G8[0] :
2471: (p & 1) == 0 ?
2472: VideoController.vcnPal32G8[p] :
2473: VideoController.vcnPal32G8[p & -2]);
2474: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) <= 1 ?
2475: VideoController.vcnPal32G8[0] :
2476: (p & 1) == 0 ?
2477: VideoController.vcnPal32G8[p] :
2478: VideoController.vcnPal32G8[p & -2]);
2479: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) <= 1 ?
2480: VideoController.vcnPal32G8[0] :
2481: (p & 1) == 0 ?
2482: VideoController.vcnPal32G8[p] :
2483: VideoController.vcnPal32G8[p & -2]);
2484: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) <= 1 ?
2485: VideoController.vcnPal32G8[0] :
2486: (p & 1) == 0 ?
2487: VideoController.vcnPal32G8[p] :
2488: VideoController.vcnPal32G8[p & -2]);
2489: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) <= 1 ?
2490: VideoController.vcnPal32G8[0] :
2491: (p & 1) == 0 ?
2492: VideoController.vcnPal32G8[p] :
2493: VideoController.vcnPal32G8[p & -2]);
2494: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) <= 1 ?
2495: VideoController.vcnPal32G8[0] :
2496: (p & 1) == 0 ?
2497: VideoController.vcnPal32G8[p] :
2498: VideoController.vcnPal32G8[p & -2]);
2499: gx1st += 16;
2500: da += 8;
2501: }
2502: }
2503: },
2504:
2505:
2506:
2507:
2508:
2509:
2510:
2511:
2512:
2513:
2514:
2515:
2516:
2517:
2518:
2519:
2520:
2521:
2522:
2523:
2524:
2525:
2526:
2527: E1_XHCT {
2528: @Override public void drawRaster (int src, int dst) {
2529: int pn = VideoController.vcnReg2Curr & 3;
2530: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2531: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2532: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2533: int db = da + XEiJ.pnlScreenWidth;
2534: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
2535: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2536: gx1st += half << 1;
2537: da += half;
2538: }
2539: while (da < db) {
2540: int p;
2541: XEiJ.pnlBM[da] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st & 1023]) & -2] & 1) != 0 ?
2542: VideoController.vcnPalTbl[
2543: VideoController.vcnMix2 (
2544: VideoController.vcnPal16G8[p],
2545: 0)] :
2546: VideoController.vcnPal32G8[p]);
2547: XEiJ.pnlBM[da + 1] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) & -2] & 1) != 0 ?
2548: VideoController.vcnPalTbl[
2549: VideoController.vcnMix2 (
2550: VideoController.vcnPal16G8[p],
2551: 0)] :
2552: VideoController.vcnPal32G8[p]);
2553: XEiJ.pnlBM[da + 2] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) & -2] & 1) != 0 ?
2554: VideoController.vcnPalTbl[
2555: VideoController.vcnMix2 (
2556: VideoController.vcnPal16G8[p],
2557: 0)] :
2558: VideoController.vcnPal32G8[p]);
2559: XEiJ.pnlBM[da + 3] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) & -2] & 1) != 0 ?
2560: VideoController.vcnPalTbl[
2561: VideoController.vcnMix2 (
2562: VideoController.vcnPal16G8[p],
2563: 0)] :
2564: VideoController.vcnPal32G8[p]);
2565: XEiJ.pnlBM[da + 4] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) & -2] & 1) != 0 ?
2566: VideoController.vcnPalTbl[
2567: VideoController.vcnMix2 (
2568: VideoController.vcnPal16G8[p],
2569: 0)] :
2570: VideoController.vcnPal32G8[p]);
2571: XEiJ.pnlBM[da + 5] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) & -2] & 1) != 0 ?
2572: VideoController.vcnPalTbl[
2573: VideoController.vcnMix2 (
2574: VideoController.vcnPal16G8[p],
2575: 0)] :
2576: VideoController.vcnPal32G8[p]);
2577: XEiJ.pnlBM[da + 6] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) & -2] & 1) != 0 ?
2578: VideoController.vcnPalTbl[
2579: VideoController.vcnMix2 (
2580: VideoController.vcnPal16G8[p],
2581: 0)] :
2582: VideoController.vcnPal32G8[p]);
2583: XEiJ.pnlBM[da + 7] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) & -2] & 1) != 0 ?
2584: VideoController.vcnPalTbl[
2585: VideoController.vcnMix2 (
2586: VideoController.vcnPal16G8[p],
2587: 0)] :
2588: VideoController.vcnPal32G8[p]);
2589: gx1st += 16;
2590: da += 8;
2591: }
2592: }
2593: },
2594:
2595:
2596:
2597:
2598:
2599:
2600:
2601:
2602:
2603:
2604:
2605:
2606:
2607:
2608:
2609:
2610:
2611:
2612:
2613:
2614:
2615:
2616:
2617:
2618:
2619:
2620: E1_XHCG {
2621: @Override public void drawRaster (int src, int dst) {
2622: int pn = VideoController.vcnReg2Curr & 3;
2623: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2624: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2625: pn = VideoController.vcnReg2Curr >> 2 & 3;
2626: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
2627: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2628: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2629: int db = da + XEiJ.pnlScreenWidth;
2630: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
2631: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2632: gx1st += half << 1;
2633: gx2nd += half << 1;
2634: da += half;
2635: }
2636: while (da < db) {
2637: int p, q;
2638: XEiJ.pnlBM[da] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st & 1023]) & -2]) & 1) != 0 ?
2639: VideoController.vcnPalTbl[
2640: VideoController.vcnMix2 (
2641: p,
2642: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
2643: (q & 1) != 0 ?
2644: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
2645: VideoController.vcnPal32G8[q]);
2646: XEiJ.pnlBM[da + 1] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) & -2]) & 1) != 0 ?
2647: VideoController.vcnPalTbl[
2648: VideoController.vcnMix2 (
2649: p,
2650: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
2651: (q & 1) != 0 ?
2652: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
2653: VideoController.vcnPal32G8[q]);
2654: XEiJ.pnlBM[da + 2] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) & -2]) & 1) != 0 ?
2655: VideoController.vcnPalTbl[
2656: VideoController.vcnMix2 (
2657: p,
2658: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
2659: (q & 1) != 0 ?
2660: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
2661: VideoController.vcnPal32G8[q]);
2662: XEiJ.pnlBM[da + 3] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) & -2]) & 1) != 0 ?
2663: VideoController.vcnPalTbl[
2664: VideoController.vcnMix2 (
2665: p,
2666: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
2667: (q & 1) != 0 ?
2668: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
2669: VideoController.vcnPal32G8[q]);
2670: XEiJ.pnlBM[da + 4] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) & -2]) & 1) != 0 ?
2671: VideoController.vcnPalTbl[
2672: VideoController.vcnMix2 (
2673: p,
2674: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
2675: (q & 1) != 0 ?
2676: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
2677: VideoController.vcnPal32G8[q]);
2678: XEiJ.pnlBM[da + 5] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) & -2]) & 1) != 0 ?
2679: VideoController.vcnPalTbl[
2680: VideoController.vcnMix2 (
2681: p,
2682: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
2683: (q & 1) != 0 ?
2684: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
2685: VideoController.vcnPal32G8[q]);
2686: XEiJ.pnlBM[da + 6] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) & -2]) & 1) != 0 ?
2687: VideoController.vcnPalTbl[
2688: VideoController.vcnMix2 (
2689: p,
2690: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
2691: (q & 1) != 0 ?
2692: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
2693: VideoController.vcnPal32G8[q]);
2694: XEiJ.pnlBM[da + 7] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) & -2]) & 1) != 0 ?
2695: VideoController.vcnPalTbl[
2696: VideoController.vcnMix2 (
2697: p,
2698: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
2699: (q & 1) != 0 ?
2700: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
2701: VideoController.vcnPal32G8[q]);
2702: gx1st += 16;
2703: gx2nd += 16;
2704: da += 8;
2705: }
2706: }
2707: },
2708:
2709:
2710:
2711:
2712:
2713:
2714:
2715:
2716:
2717:
2718:
2719:
2720:
2721:
2722:
2723:
2724:
2725:
2726:
2727:
2728:
2729:
2730:
2731:
2732:
2733:
2734: E1_XHCGT {
2735: @Override public void drawRaster (int src, int dst) {
2736: int pn = VideoController.vcnReg2Curr & 3;
2737: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2738: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2739: pn = VideoController.vcnReg2Curr >> 2 & 3;
2740: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
2741: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2742: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2743: int db = da + XEiJ.pnlScreenWidth;
2744: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
2745: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2746: gx1st += half << 1;
2747: gx2nd += half << 1;
2748: da += half;
2749: }
2750: while (da < db) {
2751: int p, q;
2752: XEiJ.pnlBM[da] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st & 1023]) & -2]) & 1) != 0 ?
2753: VideoController.vcnPalTbl[
2754: VideoController.vcnMix2 (
2755: VideoController.vcnMix2 (
2756: p,
2757: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
2758: 0)] :
2759: (q & 1) != 0 ?
2760: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
2761: VideoController.vcnPal32G8[q]);
2762: XEiJ.pnlBM[da + 1] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) & -2]) & 1) != 0 ?
2763: VideoController.vcnPalTbl[
2764: VideoController.vcnMix2 (
2765: VideoController.vcnMix2 (
2766: p,
2767: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
2768: 0)] :
2769: (q & 1) != 0 ?
2770: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
2771: VideoController.vcnPal32G8[q]);
2772: XEiJ.pnlBM[da + 2] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) & -2]) & 1) != 0 ?
2773: VideoController.vcnPalTbl[
2774: VideoController.vcnMix2 (
2775: VideoController.vcnMix2 (
2776: p,
2777: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
2778: 0)] :
2779: (q & 1) != 0 ?
2780: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
2781: VideoController.vcnPal32G8[q]);
2782: XEiJ.pnlBM[da + 3] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) & -2]) & 1) != 0 ?
2783: VideoController.vcnPalTbl[
2784: VideoController.vcnMix2 (
2785: VideoController.vcnMix2 (
2786: p,
2787: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
2788: 0)] :
2789: (q & 1) != 0 ?
2790: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
2791: VideoController.vcnPal32G8[q]);
2792: XEiJ.pnlBM[da + 4] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) & -2]) & 1) != 0 ?
2793: VideoController.vcnPalTbl[
2794: VideoController.vcnMix2 (
2795: VideoController.vcnMix2 (
2796: p,
2797: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
2798: 0)] :
2799: (q & 1) != 0 ?
2800: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
2801: VideoController.vcnPal32G8[q]);
2802: XEiJ.pnlBM[da + 5] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) & -2]) & 1) != 0 ?
2803: VideoController.vcnPalTbl[
2804: VideoController.vcnMix2 (
2805: VideoController.vcnMix2 (
2806: p,
2807: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
2808: 0)] :
2809: (q & 1) != 0 ?
2810: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
2811: VideoController.vcnPal32G8[q]);
2812: XEiJ.pnlBM[da + 6] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) & -2]) & 1) != 0 ?
2813: VideoController.vcnPalTbl[
2814: VideoController.vcnMix2 (
2815: VideoController.vcnMix2 (
2816: p,
2817: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
2818: 0)] :
2819: (q & 1) != 0 ?
2820: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
2821: VideoController.vcnPal32G8[q]);
2822: XEiJ.pnlBM[da + 7] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) & -2]) & 1) != 0 ?
2823: VideoController.vcnPalTbl[
2824: VideoController.vcnMix2 (
2825: VideoController.vcnMix2 (
2826: p,
2827: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
2828: 0)] :
2829: (q & 1) != 0 ?
2830: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
2831: VideoController.vcnPal32G8[q]);
2832: gx1st += 16;
2833: gx2nd += 16;
2834: da += 8;
2835: }
2836: }
2837: },
2838:
2839:
2840:
2841:
2842:
2843:
2844:
2845:
2846:
2847:
2848:
2849:
2850:
2851:
2852:
2853:
2854:
2855:
2856:
2857:
2858:
2859:
2860:
2861:
2862:
2863: E1_XHPT {
2864: @Override public void drawRaster (int src, int dst) {
2865: int pn = VideoController.vcnReg2Curr & 3;
2866: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2867: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2868: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2869: int db = da + XEiJ.pnlScreenWidth;
2870: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
2871: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2872: gx1st += half << 1;
2873: da += half;
2874: }
2875: while (da < db) {
2876: int p;
2877: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) <= 1 ?
2878: VideoController.vcnPal32G8[0] :
2879: (p & 1) == 0 ?
2880: VideoController.vcnPal32G8[p] :
2881: VideoController.vcnPalTbl[
2882: VideoController.vcnMix2 (
2883: VideoController.vcnPal16G8[p & -2],
2884: 0)]);
2885: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) <= 1 ?
2886: VideoController.vcnPal32G8[0] :
2887: (p & 1) == 0 ?
2888: VideoController.vcnPal32G8[p] :
2889: VideoController.vcnPalTbl[
2890: VideoController.vcnMix2 (
2891: VideoController.vcnPal16G8[p & -2],
2892: 0)]);
2893: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) <= 1 ?
2894: VideoController.vcnPal32G8[0] :
2895: (p & 1) == 0 ?
2896: VideoController.vcnPal32G8[p] :
2897: VideoController.vcnPalTbl[
2898: VideoController.vcnMix2 (
2899: VideoController.vcnPal16G8[p & -2],
2900: 0)]);
2901: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) <= 1 ?
2902: VideoController.vcnPal32G8[0] :
2903: (p & 1) == 0 ?
2904: VideoController.vcnPal32G8[p] :
2905: VideoController.vcnPalTbl[
2906: VideoController.vcnMix2 (
2907: VideoController.vcnPal16G8[p & -2],
2908: 0)]);
2909: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) <= 1 ?
2910: VideoController.vcnPal32G8[0] :
2911: (p & 1) == 0 ?
2912: VideoController.vcnPal32G8[p] :
2913: VideoController.vcnPalTbl[
2914: VideoController.vcnMix2 (
2915: VideoController.vcnPal16G8[p & -2],
2916: 0)]);
2917: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) <= 1 ?
2918: VideoController.vcnPal32G8[0] :
2919: (p & 1) == 0 ?
2920: VideoController.vcnPal32G8[p] :
2921: VideoController.vcnPalTbl[
2922: VideoController.vcnMix2 (
2923: VideoController.vcnPal16G8[p & -2],
2924: 0)]);
2925: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) <= 1 ?
2926: VideoController.vcnPal32G8[0] :
2927: (p & 1) == 0 ?
2928: VideoController.vcnPal32G8[p] :
2929: VideoController.vcnPalTbl[
2930: VideoController.vcnMix2 (
2931: VideoController.vcnPal16G8[p & -2],
2932: 0)]);
2933: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) <= 1 ?
2934: VideoController.vcnPal32G8[0] :
2935: (p & 1) == 0 ?
2936: VideoController.vcnPal32G8[p] :
2937: VideoController.vcnPalTbl[
2938: VideoController.vcnMix2 (
2939: VideoController.vcnPal16G8[p & -2],
2940: 0)]);
2941: gx1st += 16;
2942: da += 8;
2943: }
2944: }
2945: },
2946:
2947:
2948:
2949:
2950:
2951:
2952:
2953:
2954:
2955:
2956:
2957:
2958:
2959:
2960:
2961:
2962:
2963:
2964:
2965:
2966:
2967:
2968:
2969:
2970:
2971: E1_XHPG {
2972: @Override public void drawRaster (int src, int dst) {
2973: int pn = VideoController.vcnReg2Curr & 3;
2974: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2975: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2976: pn = VideoController.vcnReg2Curr >> 2 & 3;
2977: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
2978: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2979: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2980: int db = da + XEiJ.pnlScreenWidth;
2981: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
2982: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2983: gx1st += half << 1;
2984: gx2nd += half << 1;
2985: da += half;
2986: }
2987: while (da < db) {
2988: int p;
2989: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) <= 1 ?
2990: VideoController.vcnPal32G8[0] :
2991: (p & 1) == 0 ?
2992: VideoController.vcnPal32G8[p] :
2993: VideoController.vcnPalTbl[
2994: VideoController.vcnMix2 (
2995: VideoController.vcnPal16G8[p & -2],
2996: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])]);
2997: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) <= 1 ?
2998: VideoController.vcnPal32G8[0] :
2999: (p & 1) == 0 ?
3000: VideoController.vcnPal32G8[p] :
3001: VideoController.vcnPalTbl[
3002: VideoController.vcnMix2 (
3003: VideoController.vcnPal16G8[p & -2],
3004: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])]);
3005: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) <= 1 ?
3006: VideoController.vcnPal32G8[0] :
3007: (p & 1) == 0 ?
3008: VideoController.vcnPal32G8[p] :
3009: VideoController.vcnPalTbl[
3010: VideoController.vcnMix2 (
3011: VideoController.vcnPal16G8[p & -2],
3012: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])]);
3013: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) <= 1 ?
3014: VideoController.vcnPal32G8[0] :
3015: (p & 1) == 0 ?
3016: VideoController.vcnPal32G8[p] :
3017: VideoController.vcnPalTbl[
3018: VideoController.vcnMix2 (
3019: VideoController.vcnPal16G8[p & -2],
3020: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])]);
3021: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) <= 1 ?
3022: VideoController.vcnPal32G8[0] :
3023: (p & 1) == 0 ?
3024: VideoController.vcnPal32G8[p] :
3025: VideoController.vcnPalTbl[
3026: VideoController.vcnMix2 (
3027: VideoController.vcnPal16G8[p & -2],
3028: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])]);
3029: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) <= 1 ?
3030: VideoController.vcnPal32G8[0] :
3031: (p & 1) == 0 ?
3032: VideoController.vcnPal32G8[p] :
3033: VideoController.vcnPalTbl[
3034: VideoController.vcnMix2 (
3035: VideoController.vcnPal16G8[p & -2],
3036: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])]);
3037: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) <= 1 ?
3038: VideoController.vcnPal32G8[0] :
3039: (p & 1) == 0 ?
3040: VideoController.vcnPal32G8[p] :
3041: VideoController.vcnPalTbl[
3042: VideoController.vcnMix2 (
3043: VideoController.vcnPal16G8[p & -2],
3044: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])]);
3045: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) <= 1 ?
3046: VideoController.vcnPal32G8[0] :
3047: (p & 1) == 0 ?
3048: VideoController.vcnPal32G8[p] :
3049: VideoController.vcnPalTbl[
3050: VideoController.vcnMix2 (
3051: VideoController.vcnPal16G8[p & -2],
3052: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])]);
3053: gx1st += 16;
3054: gx2nd += 16;
3055: da += 8;
3056: }
3057: }
3058: },
3059:
3060:
3061:
3062:
3063:
3064:
3065:
3066:
3067:
3068:
3069:
3070:
3071:
3072:
3073:
3074:
3075:
3076:
3077:
3078:
3079:
3080:
3081:
3082:
3083:
3084: E1_XHPGT {
3085: @Override public void drawRaster (int src, int dst) {
3086: int pn = VideoController.vcnReg2Curr & 3;
3087: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3088: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3089: pn = VideoController.vcnReg2Curr >> 2 & 3;
3090: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3091: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3092: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3093: int db = da + XEiJ.pnlScreenWidth;
3094: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
3095: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3096: gx1st += half << 1;
3097: gx2nd += half << 1;
3098: da += half;
3099: }
3100: while (da < db) {
3101: int p;
3102: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) <= 1 ?
3103: VideoController.vcnPal32G8[0] :
3104: (p & 1) == 0 ?
3105: VideoController.vcnPal32G8[p] :
3106: VideoController.vcnPalTbl[
3107: VideoController.vcnMix2 (
3108: VideoController.vcnMix2 (
3109: VideoController.vcnPal16G8[p & -2],
3110: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
3111: 0)]);
3112: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) <= 1 ?
3113: VideoController.vcnPal32G8[0] :
3114: (p & 1) == 0 ?
3115: VideoController.vcnPal32G8[p] :
3116: VideoController.vcnPalTbl[
3117: VideoController.vcnMix2 (
3118: VideoController.vcnMix2 (
3119: VideoController.vcnPal16G8[p & -2],
3120: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
3121: 0)]);
3122: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) <= 1 ?
3123: VideoController.vcnPal32G8[0] :
3124: (p & 1) == 0 ?
3125: VideoController.vcnPal32G8[p] :
3126: VideoController.vcnPalTbl[
3127: VideoController.vcnMix2 (
3128: VideoController.vcnMix2 (
3129: VideoController.vcnPal16G8[p & -2],
3130: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
3131: 0)]);
3132: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) <= 1 ?
3133: VideoController.vcnPal32G8[0] :
3134: (p & 1) == 0 ?
3135: VideoController.vcnPal32G8[p] :
3136: VideoController.vcnPalTbl[
3137: VideoController.vcnMix2 (
3138: VideoController.vcnMix2 (
3139: VideoController.vcnPal16G8[p & -2],
3140: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
3141: 0)]);
3142: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) <= 1 ?
3143: VideoController.vcnPal32G8[0] :
3144: (p & 1) == 0 ?
3145: VideoController.vcnPal32G8[p] :
3146: VideoController.vcnPalTbl[
3147: VideoController.vcnMix2 (
3148: VideoController.vcnMix2 (
3149: VideoController.vcnPal16G8[p & -2],
3150: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
3151: 0)]);
3152: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) <= 1 ?
3153: VideoController.vcnPal32G8[0] :
3154: (p & 1) == 0 ?
3155: VideoController.vcnPal32G8[p] :
3156: VideoController.vcnPalTbl[
3157: VideoController.vcnMix2 (
3158: VideoController.vcnMix2 (
3159: VideoController.vcnPal16G8[p & -2],
3160: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
3161: 0)]);
3162: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) <= 1 ?
3163: VideoController.vcnPal32G8[0] :
3164: (p & 1) == 0 ?
3165: VideoController.vcnPal32G8[p] :
3166: VideoController.vcnPalTbl[
3167: VideoController.vcnMix2 (
3168: VideoController.vcnMix2 (
3169: VideoController.vcnPal16G8[p & -2],
3170: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
3171: 0)]);
3172: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) <= 1 ?
3173: VideoController.vcnPal32G8[0] :
3174: (p & 1) == 0 ?
3175: VideoController.vcnPal32G8[p] :
3176: VideoController.vcnPalTbl[
3177: VideoController.vcnMix2 (
3178: VideoController.vcnMix2 (
3179: VideoController.vcnPal16G8[p & -2],
3180: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
3181: 0)]);
3182: gx1st += 16;
3183: gx2nd += 16;
3184: da += 8;
3185: }
3186: }
3187: },
3188:
3189:
3190:
3191:
3192:
3193:
3194:
3195:
3196:
3197:
3198:
3199:
3200:
3201:
3202:
3203:
3204:
3205:
3206:
3207:
3208: E1_A {
3209: @Override public void drawRaster (int src, int dst) {
3210: int pn = VideoController.vcnReg2Curr & 3;
3211: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3212: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3213: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3214: int db = da + XEiJ.pnlScreenWidth;
3215: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
3216: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3217: gx1st += half << 1;
3218: da += half;
3219: }
3220: while (da < db) {
3221: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
3222: VideoController.vcnMix2 (
3223: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st & 1023]],
3224: VideoController.vcnPal16TS[0])]);
3225: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
3226: VideoController.vcnMix2 (
3227: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]],
3228: VideoController.vcnPal16TS[0])]);
3229: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
3230: VideoController.vcnMix2 (
3231: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]],
3232: VideoController.vcnPal16TS[0])]);
3233: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
3234: VideoController.vcnMix2 (
3235: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]],
3236: VideoController.vcnPal16TS[0])]);
3237: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
3238: VideoController.vcnMix2 (
3239: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]],
3240: VideoController.vcnPal16TS[0])]);
3241: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
3242: VideoController.vcnMix2 (
3243: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]],
3244: VideoController.vcnPal16TS[0])]);
3245: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
3246: VideoController.vcnMix2 (
3247: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]],
3248: VideoController.vcnPal16TS[0])]);
3249: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
3250: VideoController.vcnMix2 (
3251: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]],
3252: VideoController.vcnPal16TS[0])]);
3253: gx1st += 16;
3254: da += 8;
3255: }
3256: }
3257: },
3258:
3259:
3260:
3261:
3262:
3263:
3264:
3265:
3266:
3267:
3268:
3269:
3270:
3271:
3272:
3273:
3274:
3275:
3276:
3277:
3278:
3279:
3280:
3281: E2 {
3282: @Override public void drawRaster (int src, int dst) {
3283: int pn = VideoController.vcnReg2Curr & 3;
3284: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3285: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3286: pn = VideoController.vcnReg2Curr >> 2 & 3;
3287: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3288: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3289: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3290: int db = da + XEiJ.pnlScreenWidth;
3291: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
3292: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3293: gx1st += half << 1;
3294: gx2nd += half << 1;
3295: da += half;
3296: }
3297: while (da < db) {
3298: int p;
3299: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
3300: VideoController.vcnPal32G8[p] :
3301: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023]]);
3302: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
3303: VideoController.vcnPal32G8[p] :
3304: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]]);
3305: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
3306: VideoController.vcnPal32G8[p] :
3307: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]]);
3308: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
3309: VideoController.vcnPal32G8[p] :
3310: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]]);
3311: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
3312: VideoController.vcnPal32G8[p] :
3313: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]]);
3314: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
3315: VideoController.vcnPal32G8[p] :
3316: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]]);
3317: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
3318: VideoController.vcnPal32G8[p] :
3319: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]]);
3320: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
3321: VideoController.vcnPal32G8[p] :
3322: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]]);
3323: gx1st += 16;
3324: gx2nd += 16;
3325: da += 8;
3326: }
3327: }
3328: },
3329:
3330:
3331:
3332:
3333:
3334:
3335: XE2 {
3336: @Override public void drawRaster (int src, int dst) {
3337: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
3338:
3339: case 0b00010000:
3340: case 0b00010001:
3341: case 0b00010010:
3342: case 0b00010011:
3343: E2.drawRaster (src, dst);
3344: break;
3345:
3346: case 0b00010100:
3347: case 0b00010101:
3348: case 0b00010110:
3349: case 0b00010111:
3350: E2_XWP.drawRaster (src, dst);
3351: break;
3352:
3353: case 0b00011000:
3354: E2.drawRaster (src, dst);
3355: break;
3356:
3357: case 0b00011001:
3358: E2_XHCT.drawRaster (src, dst);
3359: break;
3360:
3361: case 0b00011010:
3362: E2_XHCG.drawRaster (src, dst);
3363: break;
3364:
3365: case 0b00011011:
3366: E2_XHCGT.drawRaster (src, dst);
3367: break;
3368:
3369: case 0b00011101:
3370: E2_XHPT.drawRaster (src, dst);
3371: break;
3372:
3373: case 0b00011110:
3374: E2_XHPG.drawRaster (src, dst);
3375: break;
3376:
3377: case 0b00011111:
3378: E2_XHPGT.drawRaster (src, dst);
3379: break;
3380:
3381: case 0b01000000:
3382: case 0b01000001:
3383: case 0b01000010:
3384: case 0b01000011:
3385: case 0b01000100:
3386: case 0b01000101:
3387: case 0b01000110:
3388: case 0b01000111:
3389: case 0b01001000:
3390: case 0b01001001:
3391: case 0b01001010:
3392: case 0b01001011:
3393: case 0b01001100:
3394: case 0b01001101:
3395: case 0b01001110:
3396: case 0b01001111:
3397: case 0b01010000:
3398: case 0b01010001:
3399: case 0b01010010:
3400: case 0b01010011:
3401: case 0b01010100:
3402: case 0b01010101:
3403: case 0b01010110:
3404: case 0b01010111:
3405: case 0b01011000:
3406: case 0b01011001:
3407: case 0b01011010:
3408: case 0b01011011:
3409: case 0b01011100:
3410: case 0b01011101:
3411: case 0b01011110:
3412: case 0b01011111:
3413: E2_A.drawRaster (src, dst);
3414: break;
3415: default:
3416: E2.drawRaster (src, dst);
3417: VideoController.vcnReportUnimplemented (XE2);
3418: }
3419: }
3420: },
3421:
3422:
3423:
3424:
3425:
3426:
3427:
3428:
3429:
3430:
3431:
3432:
3433:
3434:
3435:
3436:
3437:
3438:
3439:
3440:
3441:
3442:
3443:
3444:
3445:
3446:
3447:
3448: E2_XWP {
3449: @Override public void drawRaster (int src, int dst) {
3450: int pn = VideoController.vcnReg2Curr & 3;
3451: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3452: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3453: pn = VideoController.vcnReg2Curr >> 2 & 3;
3454: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3455: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3456: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3457: int db = da + XEiJ.pnlScreenWidth;
3458: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
3459: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3460: gx1st += half << 1;
3461: gx2nd += half << 1;
3462: da += half;
3463: }
3464: while (da < db) {
3465: int p;
3466: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
3467: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2] :
3468: p == 1 ?
3469: VideoController.vcnPal32G8[0] :
3470: (p & 1) == 0 ?
3471: VideoController.vcnPal32G8[p] :
3472: VideoController.vcnPal32G8[p & -2]);
3473: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
3474: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2] :
3475: p == 1 ?
3476: VideoController.vcnPal32G8[0] :
3477: (p & 1) == 0 ?
3478: VideoController.vcnPal32G8[p] :
3479: VideoController.vcnPal32G8[p & -2]);
3480: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
3481: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2] :
3482: p == 1 ?
3483: VideoController.vcnPal32G8[0] :
3484: (p & 1) == 0 ?
3485: VideoController.vcnPal32G8[p] :
3486: VideoController.vcnPal32G8[p & -2]);
3487: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
3488: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2] :
3489: p == 1 ?
3490: VideoController.vcnPal32G8[0] :
3491: (p & 1) == 0 ?
3492: VideoController.vcnPal32G8[p] :
3493: VideoController.vcnPal32G8[p & -2]);
3494: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
3495: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2] :
3496: p == 1 ?
3497: VideoController.vcnPal32G8[0] :
3498: (p & 1) == 0 ?
3499: VideoController.vcnPal32G8[p] :
3500: VideoController.vcnPal32G8[p & -2]);
3501: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
3502: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2] :
3503: p == 1 ?
3504: VideoController.vcnPal32G8[0] :
3505: (p & 1) == 0 ?
3506: VideoController.vcnPal32G8[p] :
3507: VideoController.vcnPal32G8[p & -2]);
3508: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
3509: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2] :
3510: p == 1 ?
3511: VideoController.vcnPal32G8[0] :
3512: (p & 1) == 0 ?
3513: VideoController.vcnPal32G8[p] :
3514: VideoController.vcnPal32G8[p & -2]);
3515: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
3516: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2] :
3517: p == 1 ?
3518: VideoController.vcnPal32G8[0] :
3519: (p & 1) == 0 ?
3520: VideoController.vcnPal32G8[p] :
3521: VideoController.vcnPal32G8[p & -2]);
3522: gx1st += 16;
3523: gx2nd += 16;
3524: da += 8;
3525: }
3526: }
3527: },
3528:
3529:
3530:
3531:
3532:
3533:
3534:
3535:
3536:
3537:
3538:
3539:
3540:
3541:
3542:
3543:
3544:
3545:
3546:
3547:
3548:
3549:
3550:
3551:
3552:
3553:
3554:
3555:
3556:
3557: E2_XHCT {
3558: @Override public void drawRaster (int src, int dst) {
3559: int pn = VideoController.vcnReg2Curr & 3;
3560: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3561: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3562: pn = VideoController.vcnReg2Curr >> 2 & 3;
3563: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3564: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3565: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3566: int db = da + XEiJ.pnlScreenWidth;
3567: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
3568: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3569: gx1st += half << 1;
3570: gx2nd += half << 1;
3571: da += half;
3572: }
3573: while (da < db) {
3574: int p;
3575: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
3576: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3577: VideoController.vcnPalTbl[
3578: VideoController.vcnMix2 (
3579: VideoController.vcnPal16G8[p],
3580: 0)] :
3581: VideoController.vcnPal32G8[p] :
3582: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) & -2] & 1) != 0 ?
3583: VideoController.vcnPalTbl[
3584: VideoController.vcnMix2 (
3585: VideoController.vcnPal16G8[p],
3586: 0)] :
3587: VideoController.vcnPal32G8[p]);
3588: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
3589: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3590: VideoController.vcnPalTbl[
3591: VideoController.vcnMix2 (
3592: VideoController.vcnPal16G8[p],
3593: 0)] :
3594: VideoController.vcnPal32G8[p] :
3595: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) & -2] & 1) != 0 ?
3596: VideoController.vcnPalTbl[
3597: VideoController.vcnMix2 (
3598: VideoController.vcnPal16G8[p],
3599: 0)] :
3600: VideoController.vcnPal32G8[p]);
3601: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
3602: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3603: VideoController.vcnPalTbl[
3604: VideoController.vcnMix2 (
3605: VideoController.vcnPal16G8[p],
3606: 0)] :
3607: VideoController.vcnPal32G8[p] :
3608: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) & -2] & 1) != 0 ?
3609: VideoController.vcnPalTbl[
3610: VideoController.vcnMix2 (
3611: VideoController.vcnPal16G8[p],
3612: 0)] :
3613: VideoController.vcnPal32G8[p]);
3614: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
3615: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3616: VideoController.vcnPalTbl[
3617: VideoController.vcnMix2 (
3618: VideoController.vcnPal16G8[p],
3619: 0)] :
3620: VideoController.vcnPal32G8[p] :
3621: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) & -2] & 1) != 0 ?
3622: VideoController.vcnPalTbl[
3623: VideoController.vcnMix2 (
3624: VideoController.vcnPal16G8[p],
3625: 0)] :
3626: VideoController.vcnPal32G8[p]);
3627: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
3628: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3629: VideoController.vcnPalTbl[
3630: VideoController.vcnMix2 (
3631: VideoController.vcnPal16G8[p],
3632: 0)] :
3633: VideoController.vcnPal32G8[p] :
3634: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) & -2] & 1) != 0 ?
3635: VideoController.vcnPalTbl[
3636: VideoController.vcnMix2 (
3637: VideoController.vcnPal16G8[p],
3638: 0)] :
3639: VideoController.vcnPal32G8[p]);
3640: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
3641: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3642: VideoController.vcnPalTbl[
3643: VideoController.vcnMix2 (
3644: VideoController.vcnPal16G8[p],
3645: 0)] :
3646: VideoController.vcnPal32G8[p] :
3647: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) & -2] & 1) != 0 ?
3648: VideoController.vcnPalTbl[
3649: VideoController.vcnMix2 (
3650: VideoController.vcnPal16G8[p],
3651: 0)] :
3652: VideoController.vcnPal32G8[p]);
3653: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
3654: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3655: VideoController.vcnPalTbl[
3656: VideoController.vcnMix2 (
3657: VideoController.vcnPal16G8[p],
3658: 0)] :
3659: VideoController.vcnPal32G8[p] :
3660: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) & -2] & 1) != 0 ?
3661: VideoController.vcnPalTbl[
3662: VideoController.vcnMix2 (
3663: VideoController.vcnPal16G8[p],
3664: 0)] :
3665: VideoController.vcnPal32G8[p]);
3666: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
3667: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3668: VideoController.vcnPalTbl[
3669: VideoController.vcnMix2 (
3670: VideoController.vcnPal16G8[p],
3671: 0)] :
3672: VideoController.vcnPal32G8[p] :
3673: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) & -2] & 1) != 0 ?
3674: VideoController.vcnPalTbl[
3675: VideoController.vcnMix2 (
3676: VideoController.vcnPal16G8[p],
3677: 0)] :
3678: VideoController.vcnPal32G8[p]);
3679: gx1st += 16;
3680: gx2nd += 16;
3681: da += 8;
3682: }
3683: }
3684: },
3685:
3686:
3687:
3688:
3689:
3690:
3691:
3692:
3693:
3694:
3695:
3696:
3697:
3698:
3699:
3700:
3701:
3702:
3703:
3704:
3705:
3706:
3707:
3708:
3709:
3710:
3711:
3712:
3713:
3714:
3715:
3716:
3717: E2_XHCG {
3718: @Override public void drawRaster (int src, int dst) {
3719: int pn = VideoController.vcnReg2Curr & 3;
3720: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3721: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3722: pn = VideoController.vcnReg2Curr >> 2 & 3;
3723: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3724: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3725: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3726: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3727: int db = da + XEiJ.pnlScreenWidth;
3728: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
3729: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3730: gx1st += half << 1;
3731: gx2nd += half << 1;
3732: da += half;
3733: }
3734: while (da < db) {
3735: int p, q;
3736: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
3737: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3738: VideoController.vcnPalTbl[
3739: VideoController.vcnMix2 (
3740: q,
3741: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
3742: (p & 1) != 0 ?
3743: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
3744: VideoController.vcnPal32G8[p] :
3745: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) & -2]) & 1) != 0 ?
3746: VideoController.vcnPalTbl[
3747: VideoController.vcnMix2 (
3748: p,
3749: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
3750: VideoController.vcnPal32G8[q]);
3751: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
3752: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3753: VideoController.vcnPalTbl[
3754: VideoController.vcnMix2 (
3755: q,
3756: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
3757: (p & 1) != 0 ?
3758: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
3759: VideoController.vcnPal32G8[p] :
3760: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) & -2]) & 1) != 0 ?
3761: VideoController.vcnPalTbl[
3762: VideoController.vcnMix2 (
3763: p,
3764: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
3765: VideoController.vcnPal32G8[q]);
3766: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
3767: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3768: VideoController.vcnPalTbl[
3769: VideoController.vcnMix2 (
3770: q,
3771: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
3772: (p & 1) != 0 ?
3773: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
3774: VideoController.vcnPal32G8[p] :
3775: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) & -2]) & 1) != 0 ?
3776: VideoController.vcnPalTbl[
3777: VideoController.vcnMix2 (
3778: p,
3779: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
3780: VideoController.vcnPal32G8[q]);
3781: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
3782: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3783: VideoController.vcnPalTbl[
3784: VideoController.vcnMix2 (
3785: q,
3786: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
3787: (p & 1) != 0 ?
3788: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
3789: VideoController.vcnPal32G8[p] :
3790: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) & -2]) & 1) != 0 ?
3791: VideoController.vcnPalTbl[
3792: VideoController.vcnMix2 (
3793: p,
3794: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
3795: VideoController.vcnPal32G8[q]);
3796: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
3797: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3798: VideoController.vcnPalTbl[
3799: VideoController.vcnMix2 (
3800: q,
3801: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
3802: (p & 1) != 0 ?
3803: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
3804: VideoController.vcnPal32G8[p] :
3805: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) & -2]) & 1) != 0 ?
3806: VideoController.vcnPalTbl[
3807: VideoController.vcnMix2 (
3808: p,
3809: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
3810: VideoController.vcnPal32G8[q]);
3811: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
3812: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3813: VideoController.vcnPalTbl[
3814: VideoController.vcnMix2 (
3815: q,
3816: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
3817: (p & 1) != 0 ?
3818: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
3819: VideoController.vcnPal32G8[p] :
3820: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) & -2]) & 1) != 0 ?
3821: VideoController.vcnPalTbl[
3822: VideoController.vcnMix2 (
3823: p,
3824: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
3825: VideoController.vcnPal32G8[q]);
3826: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
3827: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3828: VideoController.vcnPalTbl[
3829: VideoController.vcnMix2 (
3830: q,
3831: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
3832: (p & 1) != 0 ?
3833: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
3834: VideoController.vcnPal32G8[p] :
3835: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) & -2]) & 1) != 0 ?
3836: VideoController.vcnPalTbl[
3837: VideoController.vcnMix2 (
3838: p,
3839: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
3840: VideoController.vcnPal32G8[q]);
3841: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
3842: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3843: VideoController.vcnPalTbl[
3844: VideoController.vcnMix2 (
3845: q,
3846: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
3847: (p & 1) != 0 ?
3848: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
3849: VideoController.vcnPal32G8[p] :
3850: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) & -2]) & 1) != 0 ?
3851: VideoController.vcnPalTbl[
3852: VideoController.vcnMix2 (
3853: p,
3854: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
3855: VideoController.vcnPal32G8[q]);
3856: gx1st += 16;
3857: gx2nd += 16;
3858: da += 8;
3859: }
3860: }
3861: },
3862:
3863:
3864:
3865:
3866:
3867:
3868:
3869:
3870:
3871:
3872:
3873:
3874:
3875:
3876:
3877:
3878:
3879:
3880:
3881:
3882:
3883:
3884:
3885:
3886:
3887:
3888:
3889:
3890:
3891:
3892:
3893:
3894: E2_XHCGT {
3895: @Override public void drawRaster (int src, int dst) {
3896: int pn = VideoController.vcnReg2Curr & 3;
3897: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3898: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3899: pn = VideoController.vcnReg2Curr >> 2 & 3;
3900: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3901: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3902: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3903: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3904: int db = da + XEiJ.pnlScreenWidth;
3905: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
3906: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3907: gx1st += half << 1;
3908: gx2nd += half << 1;
3909: da += half;
3910: }
3911: while (da < db) {
3912: int p, q;
3913: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
3914: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3915: VideoController.vcnPalTbl[
3916: VideoController.vcnMix2 (
3917: VideoController.vcnMix2 (
3918: q,
3919: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
3920: 0)] :
3921: (p & 1) != 0 ?
3922: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
3923: VideoController.vcnPal32G8[p] :
3924: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) & -2]) & 1) != 0 ?
3925: VideoController.vcnPalTbl[
3926: VideoController.vcnMix2 (
3927: VideoController.vcnMix2 (
3928: p,
3929: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
3930: 0)] :
3931: VideoController.vcnPal32G8[q]);
3932: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
3933: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3934: VideoController.vcnPalTbl[
3935: VideoController.vcnMix2 (
3936: VideoController.vcnMix2 (
3937: q,
3938: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
3939: 0)] :
3940: (p & 1) != 0 ?
3941: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
3942: VideoController.vcnPal32G8[p] :
3943: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) & -2]) & 1) != 0 ?
3944: VideoController.vcnPalTbl[
3945: VideoController.vcnMix2 (
3946: VideoController.vcnMix2 (
3947: p,
3948: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
3949: 0)] :
3950: VideoController.vcnPal32G8[q]);
3951: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
3952: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3953: VideoController.vcnPalTbl[
3954: VideoController.vcnMix2 (
3955: VideoController.vcnMix2 (
3956: q,
3957: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
3958: 0)] :
3959: (p & 1) != 0 ?
3960: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
3961: VideoController.vcnPal32G8[p] :
3962: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) & -2]) & 1) != 0 ?
3963: VideoController.vcnPalTbl[
3964: VideoController.vcnMix2 (
3965: VideoController.vcnMix2 (
3966: p,
3967: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
3968: 0)] :
3969: VideoController.vcnPal32G8[q]);
3970: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
3971: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3972: VideoController.vcnPalTbl[
3973: VideoController.vcnMix2 (
3974: VideoController.vcnMix2 (
3975: q,
3976: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
3977: 0)] :
3978: (p & 1) != 0 ?
3979: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
3980: VideoController.vcnPal32G8[p] :
3981: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) & -2]) & 1) != 0 ?
3982: VideoController.vcnPalTbl[
3983: VideoController.vcnMix2 (
3984: VideoController.vcnMix2 (
3985: p,
3986: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
3987: 0)] :
3988: VideoController.vcnPal32G8[q]);
3989: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
3990: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3991: VideoController.vcnPalTbl[
3992: VideoController.vcnMix2 (
3993: VideoController.vcnMix2 (
3994: q,
3995: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
3996: 0)] :
3997: (p & 1) != 0 ?
3998: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
3999: VideoController.vcnPal32G8[p] :
4000: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) & -2]) & 1) != 0 ?
4001: VideoController.vcnPalTbl[
4002: VideoController.vcnMix2 (
4003: VideoController.vcnMix2 (
4004: p,
4005: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
4006: 0)] :
4007: VideoController.vcnPal32G8[q]);
4008: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
4009: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
4010: VideoController.vcnPalTbl[
4011: VideoController.vcnMix2 (
4012: VideoController.vcnMix2 (
4013: q,
4014: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
4015: 0)] :
4016: (p & 1) != 0 ?
4017: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
4018: VideoController.vcnPal32G8[p] :
4019: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) & -2]) & 1) != 0 ?
4020: VideoController.vcnPalTbl[
4021: VideoController.vcnMix2 (
4022: VideoController.vcnMix2 (
4023: p,
4024: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
4025: 0)] :
4026: VideoController.vcnPal32G8[q]);
4027: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
4028: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
4029: VideoController.vcnPalTbl[
4030: VideoController.vcnMix2 (
4031: VideoController.vcnMix2 (
4032: q,
4033: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
4034: 0)] :
4035: (p & 1) != 0 ?
4036: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
4037: VideoController.vcnPal32G8[p] :
4038: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) & -2]) & 1) != 0 ?
4039: VideoController.vcnPalTbl[
4040: VideoController.vcnMix2 (
4041: VideoController.vcnMix2 (
4042: p,
4043: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
4044: 0)] :
4045: VideoController.vcnPal32G8[q]);
4046: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
4047: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
4048: VideoController.vcnPalTbl[
4049: VideoController.vcnMix2 (
4050: VideoController.vcnMix2 (
4051: q,
4052: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
4053: 0)] :
4054: (p & 1) != 0 ?
4055: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
4056: VideoController.vcnPal32G8[p] :
4057: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) & -2]) & 1) != 0 ?
4058: VideoController.vcnPalTbl[
4059: VideoController.vcnMix2 (
4060: VideoController.vcnMix2 (
4061: p,
4062: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
4063: 0)] :
4064: VideoController.vcnPal32G8[q]);
4065: gx1st += 16;
4066: gx2nd += 16;
4067: da += 8;
4068: }
4069: }
4070: },
4071:
4072:
4073:
4074:
4075:
4076:
4077:
4078:
4079:
4080:
4081:
4082:
4083:
4084:
4085:
4086:
4087:
4088:
4089:
4090:
4091:
4092:
4093:
4094:
4095:
4096:
4097:
4098: E2_XHPT {
4099: @Override public void drawRaster (int src, int dst) {
4100: int pn = VideoController.vcnReg2Curr & 3;
4101: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4102: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4103: pn = VideoController.vcnReg2Curr >> 2 & 3;
4104: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4105: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4106: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4107: int db = da + XEiJ.pnlScreenWidth;
4108: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
4109: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4110: gx1st += half << 1;
4111: gx2nd += half << 1;
4112: da += half;
4113: }
4114: while (da < db) {
4115: int p;
4116: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
4117: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2] :
4118: p == 1 ?
4119: VideoController.vcnPal32G8[0] :
4120: (p & 1) == 0 ?
4121: VideoController.vcnPal32G8[p] :
4122: VideoController.vcnPalTbl[
4123: VideoController.vcnMix2 (
4124: VideoController.vcnPal16G8[p & -2],
4125: 0)]);
4126: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
4127: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2] :
4128: p == 1 ?
4129: VideoController.vcnPal32G8[0] :
4130: (p & 1) == 0 ?
4131: VideoController.vcnPal32G8[p] :
4132: VideoController.vcnPalTbl[
4133: VideoController.vcnMix2 (
4134: VideoController.vcnPal16G8[p & -2],
4135: 0)]);
4136: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
4137: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2] :
4138: p == 1 ?
4139: VideoController.vcnPal32G8[0] :
4140: (p & 1) == 0 ?
4141: VideoController.vcnPal32G8[p] :
4142: VideoController.vcnPalTbl[
4143: VideoController.vcnMix2 (
4144: VideoController.vcnPal16G8[p & -2],
4145: 0)]);
4146: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
4147: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2] :
4148: p == 1 ?
4149: VideoController.vcnPal32G8[0] :
4150: (p & 1) == 0 ?
4151: VideoController.vcnPal32G8[p] :
4152: VideoController.vcnPalTbl[
4153: VideoController.vcnMix2 (
4154: VideoController.vcnPal16G8[p & -2],
4155: 0)]);
4156: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
4157: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2] :
4158: p == 1 ?
4159: VideoController.vcnPal32G8[0] :
4160: (p & 1) == 0 ?
4161: VideoController.vcnPal32G8[p] :
4162: VideoController.vcnPalTbl[
4163: VideoController.vcnMix2 (
4164: VideoController.vcnPal16G8[p & -2],
4165: 0)]);
4166: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
4167: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2] :
4168: p == 1 ?
4169: VideoController.vcnPal32G8[0] :
4170: (p & 1) == 0 ?
4171: VideoController.vcnPal32G8[p] :
4172: VideoController.vcnPalTbl[
4173: VideoController.vcnMix2 (
4174: VideoController.vcnPal16G8[p & -2],
4175: 0)]);
4176: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
4177: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2] :
4178: p == 1 ?
4179: VideoController.vcnPal32G8[0] :
4180: (p & 1) == 0 ?
4181: VideoController.vcnPal32G8[p] :
4182: VideoController.vcnPalTbl[
4183: VideoController.vcnMix2 (
4184: VideoController.vcnPal16G8[p & -2],
4185: 0)]);
4186: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
4187: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2] :
4188: p == 1 ?
4189: VideoController.vcnPal32G8[0] :
4190: (p & 1) == 0 ?
4191: VideoController.vcnPal32G8[p] :
4192: VideoController.vcnPalTbl[
4193: VideoController.vcnMix2 (
4194: VideoController.vcnPal16G8[p & -2],
4195: 0)]);
4196: gx1st += 16;
4197: gx2nd += 16;
4198: da += 8;
4199: }
4200: }
4201: },
4202:
4203:
4204:
4205:
4206:
4207:
4208:
4209:
4210:
4211:
4212:
4213:
4214:
4215:
4216:
4217:
4218:
4219:
4220:
4221:
4222:
4223:
4224:
4225:
4226:
4227:
4228:
4229: E2_XHPG {
4230: @Override public void drawRaster (int src, int dst) {
4231: int pn = VideoController.vcnReg2Curr & 3;
4232: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4233: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4234: pn = VideoController.vcnReg2Curr >> 2 & 3;
4235: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4236: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4237: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4238: int db = da + XEiJ.pnlScreenWidth;
4239: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
4240: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4241: gx1st += half << 1;
4242: gx2nd += half << 1;
4243: da += half;
4244: }
4245: while (da < db) {
4246: int p;
4247: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
4248: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2] :
4249: p == 1 ?
4250: VideoController.vcnPal32G8[0] :
4251: (p & 1) == 0 ?
4252: VideoController.vcnPal32G8[p] :
4253: VideoController.vcnPalTbl[
4254: VideoController.vcnMix2 (
4255: VideoController.vcnPal16G8[p & -2],
4256: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] | 1])]);
4257: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
4258: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2] :
4259: p == 1 ?
4260: VideoController.vcnPal32G8[0] :
4261: (p & 1) == 0 ?
4262: VideoController.vcnPal32G8[p] :
4263: VideoController.vcnPalTbl[
4264: VideoController.vcnMix2 (
4265: VideoController.vcnPal16G8[p & -2],
4266: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] | 1])]);
4267: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
4268: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2] :
4269: p == 1 ?
4270: VideoController.vcnPal32G8[0] :
4271: (p & 1) == 0 ?
4272: VideoController.vcnPal32G8[p] :
4273: VideoController.vcnPalTbl[
4274: VideoController.vcnMix2 (
4275: VideoController.vcnPal16G8[p & -2],
4276: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] | 1])]);
4277: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
4278: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2] :
4279: p == 1 ?
4280: VideoController.vcnPal32G8[0] :
4281: (p & 1) == 0 ?
4282: VideoController.vcnPal32G8[p] :
4283: VideoController.vcnPalTbl[
4284: VideoController.vcnMix2 (
4285: VideoController.vcnPal16G8[p & -2],
4286: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] | 1])]);
4287: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
4288: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2] :
4289: p == 1 ?
4290: VideoController.vcnPal32G8[0] :
4291: (p & 1) == 0 ?
4292: VideoController.vcnPal32G8[p] :
4293: VideoController.vcnPalTbl[
4294: VideoController.vcnMix2 (
4295: VideoController.vcnPal16G8[p & -2],
4296: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] | 1])]);
4297: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
4298: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2] :
4299: p == 1 ?
4300: VideoController.vcnPal32G8[0] :
4301: (p & 1) == 0 ?
4302: VideoController.vcnPal32G8[p] :
4303: VideoController.vcnPalTbl[
4304: VideoController.vcnMix2 (
4305: VideoController.vcnPal16G8[p & -2],
4306: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] | 1])]);
4307: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
4308: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2] :
4309: p == 1 ?
4310: VideoController.vcnPal32G8[0] :
4311: (p & 1) == 0 ?
4312: VideoController.vcnPal32G8[p] :
4313: VideoController.vcnPalTbl[
4314: VideoController.vcnMix2 (
4315: VideoController.vcnPal16G8[p & -2],
4316: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] | 1])]);
4317: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
4318: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2] :
4319: p == 1 ?
4320: VideoController.vcnPal32G8[0] :
4321: (p & 1) == 0 ?
4322: VideoController.vcnPal32G8[p] :
4323: VideoController.vcnPalTbl[
4324: VideoController.vcnMix2 (
4325: VideoController.vcnPal16G8[p & -2],
4326: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] | 1])]);
4327: gx1st += 16;
4328: gx2nd += 16;
4329: da += 8;
4330: }
4331: }
4332: },
4333:
4334:
4335:
4336:
4337:
4338:
4339:
4340:
4341:
4342:
4343:
4344:
4345:
4346:
4347:
4348:
4349:
4350:
4351:
4352:
4353:
4354:
4355:
4356:
4357:
4358:
4359:
4360: E2_XHPGT {
4361: @Override public void drawRaster (int src, int dst) {
4362: int pn = VideoController.vcnReg2Curr & 3;
4363: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4364: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4365: pn = VideoController.vcnReg2Curr >> 2 & 3;
4366: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4367: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4368: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4369: int db = da + XEiJ.pnlScreenWidth;
4370: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
4371: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4372: gx1st += half << 1;
4373: gx2nd += half << 1;
4374: da += half;
4375: }
4376: while (da < db) {
4377: int p;
4378: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
4379: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2] :
4380: p == 1 ?
4381: VideoController.vcnPal32G8[0] :
4382: (p & 1) == 0 ?
4383: VideoController.vcnPal32G8[p] :
4384: VideoController.vcnPalTbl[
4385: VideoController.vcnMix2 (
4386: VideoController.vcnMix2 (
4387: VideoController.vcnPal16G8[p & -2],
4388: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] | 1]),
4389: 0)]);
4390: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
4391: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2] :
4392: p == 1 ?
4393: VideoController.vcnPal32G8[0] :
4394: (p & 1) == 0 ?
4395: VideoController.vcnPal32G8[p] :
4396: VideoController.vcnPalTbl[
4397: VideoController.vcnMix2 (
4398: VideoController.vcnMix2 (
4399: VideoController.vcnPal16G8[p & -2],
4400: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] | 1]),
4401: 0)]);
4402: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
4403: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2] :
4404: p == 1 ?
4405: VideoController.vcnPal32G8[0] :
4406: (p & 1) == 0 ?
4407: VideoController.vcnPal32G8[p] :
4408: VideoController.vcnPalTbl[
4409: VideoController.vcnMix2 (
4410: VideoController.vcnMix2 (
4411: VideoController.vcnPal16G8[p & -2],
4412: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] | 1]),
4413: 0)]);
4414: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
4415: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2] :
4416: p == 1 ?
4417: VideoController.vcnPal32G8[0] :
4418: (p & 1) == 0 ?
4419: VideoController.vcnPal32G8[p] :
4420: VideoController.vcnPalTbl[
4421: VideoController.vcnMix2 (
4422: VideoController.vcnMix2 (
4423: VideoController.vcnPal16G8[p & -2],
4424: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] | 1]),
4425: 0)]);
4426: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
4427: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2] :
4428: p == 1 ?
4429: VideoController.vcnPal32G8[0] :
4430: (p & 1) == 0 ?
4431: VideoController.vcnPal32G8[p] :
4432: VideoController.vcnPalTbl[
4433: VideoController.vcnMix2 (
4434: VideoController.vcnMix2 (
4435: VideoController.vcnPal16G8[p & -2],
4436: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] | 1]),
4437: 0)]);
4438: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
4439: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2] :
4440: p == 1 ?
4441: VideoController.vcnPal32G8[0] :
4442: (p & 1) == 0 ?
4443: VideoController.vcnPal32G8[p] :
4444: VideoController.vcnPalTbl[
4445: VideoController.vcnMix2 (
4446: VideoController.vcnMix2 (
4447: VideoController.vcnPal16G8[p & -2],
4448: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] | 1]),
4449: 0)]);
4450: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
4451: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2] :
4452: p == 1 ?
4453: VideoController.vcnPal32G8[0] :
4454: (p & 1) == 0 ?
4455: VideoController.vcnPal32G8[p] :
4456: VideoController.vcnPalTbl[
4457: VideoController.vcnMix2 (
4458: VideoController.vcnMix2 (
4459: VideoController.vcnPal16G8[p & -2],
4460: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] | 1]),
4461: 0)]);
4462: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
4463: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2] :
4464: p == 1 ?
4465: VideoController.vcnPal32G8[0] :
4466: (p & 1) == 0 ?
4467: VideoController.vcnPal32G8[p] :
4468: VideoController.vcnPalTbl[
4469: VideoController.vcnMix2 (
4470: VideoController.vcnMix2 (
4471: VideoController.vcnPal16G8[p & -2],
4472: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] | 1]),
4473: 0)]);
4474: gx1st += 16;
4475: gx2nd += 16;
4476: da += 8;
4477: }
4478: }
4479: },
4480:
4481:
4482:
4483:
4484:
4485:
4486:
4487:
4488:
4489:
4490:
4491:
4492:
4493:
4494:
4495:
4496:
4497:
4498:
4499:
4500:
4501:
4502:
4503: E2_A {
4504: @Override public void drawRaster (int src, int dst) {
4505: int pn = VideoController.vcnReg2Curr & 3;
4506: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4507: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4508: pn = VideoController.vcnReg2Curr >> 2 & 3;
4509: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4510: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4511: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4512: int db = da + XEiJ.pnlScreenWidth;
4513: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
4514: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4515: gx1st += half << 1;
4516: gx2nd += half << 1;
4517: da += half;
4518: }
4519: while (da < db) {
4520: int p;
4521: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
4522: (p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
4523: VideoController.vcnMix2 (
4524: VideoController.vcnPal16G8[p],
4525: VideoController.vcnPal16TS[0]) :
4526: VideoController.vcnMix2 (
4527: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023]],
4528: VideoController.vcnPal16TS[0])]);
4529: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
4530: (p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
4531: VideoController.vcnMix2 (
4532: VideoController.vcnPal16G8[p],
4533: VideoController.vcnPal16TS[0]) :
4534: VideoController.vcnMix2 (
4535: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]],
4536: VideoController.vcnPal16TS[0])]);
4537: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
4538: (p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
4539: VideoController.vcnMix2 (
4540: VideoController.vcnPal16G8[p],
4541: VideoController.vcnPal16TS[0]) :
4542: VideoController.vcnMix2 (
4543: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]],
4544: VideoController.vcnPal16TS[0])]);
4545: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
4546: (p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
4547: VideoController.vcnMix2 (
4548: VideoController.vcnPal16G8[p],
4549: VideoController.vcnPal16TS[0]) :
4550: VideoController.vcnMix2 (
4551: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]],
4552: VideoController.vcnPal16TS[0])]);
4553: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
4554: (p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
4555: VideoController.vcnMix2 (
4556: VideoController.vcnPal16G8[p],
4557: VideoController.vcnPal16TS[0]) :
4558: VideoController.vcnMix2 (
4559: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]],
4560: VideoController.vcnPal16TS[0])]);
4561: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
4562: (p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
4563: VideoController.vcnMix2 (
4564: VideoController.vcnPal16G8[p],
4565: VideoController.vcnPal16TS[0]) :
4566: VideoController.vcnMix2 (
4567: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]],
4568: VideoController.vcnPal16TS[0])]);
4569: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
4570: (p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
4571: VideoController.vcnMix2 (
4572: VideoController.vcnPal16G8[p],
4573: VideoController.vcnPal16TS[0]) :
4574: VideoController.vcnMix2 (
4575: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]],
4576: VideoController.vcnPal16TS[0])]);
4577: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
4578: (p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
4579: VideoController.vcnMix2 (
4580: VideoController.vcnPal16G8[p],
4581: VideoController.vcnPal16TS[0]) :
4582: VideoController.vcnMix2 (
4583: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]],
4584: VideoController.vcnPal16TS[0])]);
4585: gx1st += 16;
4586: gx2nd += 16;
4587: da += 8;
4588: }
4589: }
4590: },
4591:
4592:
4593:
4594:
4595:
4596:
4597:
4598:
4599:
4600:
4601:
4602:
4603:
4604:
4605:
4606:
4607:
4608:
4609:
4610:
4611:
4612:
4613:
4614:
4615:
4616:
4617: E3 {
4618: @Override public void drawRaster (int src, int dst) {
4619: int pn = VideoController.vcnReg2Curr & 3;
4620: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4621: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4622: pn = VideoController.vcnReg2Curr >> 2 & 3;
4623: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4624: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4625: pn = VideoController.vcnReg2Curr >> 4 & 3;
4626: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
4627: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4628: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4629: int db = da + XEiJ.pnlScreenWidth;
4630: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
4631: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4632: gx1st += half << 1;
4633: gx2nd += half << 1;
4634: gx3rd += half << 1;
4635: da += half;
4636: }
4637: while (da < db) {
4638: int p;
4639: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
4640: VideoController.vcnPal32G8[p] :
4641: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
4642: VideoController.vcnPal32G8[p] :
4643: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023]]);
4644: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
4645: VideoController.vcnPal32G8[p] :
4646: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
4647: VideoController.vcnPal32G8[p] :
4648: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]]);
4649: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
4650: VideoController.vcnPal32G8[p] :
4651: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
4652: VideoController.vcnPal32G8[p] :
4653: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]]);
4654: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
4655: VideoController.vcnPal32G8[p] :
4656: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
4657: VideoController.vcnPal32G8[p] :
4658: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]]);
4659: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
4660: VideoController.vcnPal32G8[p] :
4661: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
4662: VideoController.vcnPal32G8[p] :
4663: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]]);
4664: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
4665: VideoController.vcnPal32G8[p] :
4666: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
4667: VideoController.vcnPal32G8[p] :
4668: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]]);
4669: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
4670: VideoController.vcnPal32G8[p] :
4671: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
4672: VideoController.vcnPal32G8[p] :
4673: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]]);
4674: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
4675: VideoController.vcnPal32G8[p] :
4676: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
4677: VideoController.vcnPal32G8[p] :
4678: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]]);
4679: gx1st += 16;
4680: gx2nd += 16;
4681: gx3rd += 16;
4682: da += 8;
4683: }
4684: }
4685: },
4686:
4687:
4688:
4689:
4690:
4691:
4692: XE3 {
4693: @Override public void drawRaster (int src, int dst) {
4694: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
4695:
4696: case 0b00010000:
4697: case 0b00010001:
4698: case 0b00010010:
4699: case 0b00010011:
4700: E3.drawRaster (src, dst);
4701: break;
4702:
4703: case 0b00010100:
4704: case 0b00010101:
4705: case 0b00010110:
4706: case 0b00010111:
4707: E3_XWP.drawRaster (src, dst);
4708: break;
4709:
4710: case 0b00011000:
4711: E3.drawRaster (src, dst);
4712: break;
4713:
4714: case 0b00011001:
4715: E3_XHCT.drawRaster (src, dst);
4716: break;
4717:
4718: case 0b00011010:
4719: E3_XHCG.drawRaster (src, dst);
4720: break;
4721:
4722: case 0b00011011:
4723: E3_XHCGT.drawRaster (src, dst);
4724: break;
4725:
4726: case 0b00011101:
4727: E3_XHPT.drawRaster (src, dst);
4728: break;
4729:
4730: case 0b00011110:
4731: E3_XHPG.drawRaster (src, dst);
4732: break;
4733:
4734: case 0b00011111:
4735: E3_XHPGT.drawRaster (src, dst);
4736: break;
4737:
4738: case 0b01000000:
4739: case 0b01000001:
4740: case 0b01000010:
4741: case 0b01000011:
4742: case 0b01000100:
4743: case 0b01000101:
4744: case 0b01000110:
4745: case 0b01000111:
4746: case 0b01001000:
4747: case 0b01001001:
4748: case 0b01001010:
4749: case 0b01001011:
4750: case 0b01001100:
4751: case 0b01001101:
4752: case 0b01001110:
4753: case 0b01001111:
4754: case 0b01010000:
4755: case 0b01010001:
4756: case 0b01010010:
4757: case 0b01010011:
4758: case 0b01010100:
4759: case 0b01010101:
4760: case 0b01010110:
4761: case 0b01010111:
4762: case 0b01011000:
4763: case 0b01011001:
4764: case 0b01011010:
4765: case 0b01011011:
4766: case 0b01011100:
4767: case 0b01011101:
4768: case 0b01011110:
4769: case 0b01011111:
4770: E3_A.drawRaster (src, dst);
4771: break;
4772: default:
4773: E3.drawRaster (src, dst);
4774: VideoController.vcnReportUnimplemented (XE3);
4775: }
4776: }
4777: },
4778:
4779:
4780:
4781:
4782:
4783:
4784:
4785:
4786:
4787:
4788:
4789:
4790:
4791:
4792:
4793:
4794:
4795:
4796:
4797:
4798:
4799:
4800:
4801:
4802:
4803:
4804:
4805:
4806:
4807:
4808: E3_XWP {
4809: @Override public void drawRaster (int src, int dst) {
4810: int pn = VideoController.vcnReg2Curr & 3;
4811: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4812: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4813: pn = VideoController.vcnReg2Curr >> 2 & 3;
4814: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4815: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4816: pn = VideoController.vcnReg2Curr >> 4 & 3;
4817: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
4818: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4819: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4820: int db = da + XEiJ.pnlScreenWidth;
4821: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
4822: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4823: gx1st += half << 1;
4824: gx2nd += half << 1;
4825: gx3rd += half << 1;
4826: da += half;
4827: }
4828: while (da < db) {
4829: int p;
4830: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
4831: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
4832: VideoController.vcnPal32G8[p] :
4833: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2] :
4834: p == 1 ?
4835: VideoController.vcnPal32G8[0] :
4836: (p & 1) == 0 ?
4837: VideoController.vcnPal32G8[p] :
4838: VideoController.vcnPal32G8[p & -2]);
4839: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
4840: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
4841: VideoController.vcnPal32G8[p] :
4842: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2] :
4843: p == 1 ?
4844: VideoController.vcnPal32G8[0] :
4845: (p & 1) == 0 ?
4846: VideoController.vcnPal32G8[p] :
4847: VideoController.vcnPal32G8[p & -2]);
4848: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
4849: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
4850: VideoController.vcnPal32G8[p] :
4851: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2] :
4852: p == 1 ?
4853: VideoController.vcnPal32G8[0] :
4854: (p & 1) == 0 ?
4855: VideoController.vcnPal32G8[p] :
4856: VideoController.vcnPal32G8[p & -2]);
4857: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
4858: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
4859: VideoController.vcnPal32G8[p] :
4860: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2] :
4861: p == 1 ?
4862: VideoController.vcnPal32G8[0] :
4863: (p & 1) == 0 ?
4864: VideoController.vcnPal32G8[p] :
4865: VideoController.vcnPal32G8[p & -2]);
4866: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
4867: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
4868: VideoController.vcnPal32G8[p] :
4869: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2] :
4870: p == 1 ?
4871: VideoController.vcnPal32G8[0] :
4872: (p & 1) == 0 ?
4873: VideoController.vcnPal32G8[p] :
4874: VideoController.vcnPal32G8[p & -2]);
4875: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
4876: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
4877: VideoController.vcnPal32G8[p] :
4878: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2] :
4879: p == 1 ?
4880: VideoController.vcnPal32G8[0] :
4881: (p & 1) == 0 ?
4882: VideoController.vcnPal32G8[p] :
4883: VideoController.vcnPal32G8[p & -2]);
4884: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
4885: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
4886: VideoController.vcnPal32G8[p] :
4887: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2] :
4888: p == 1 ?
4889: VideoController.vcnPal32G8[0] :
4890: (p & 1) == 0 ?
4891: VideoController.vcnPal32G8[p] :
4892: VideoController.vcnPal32G8[p & -2]);
4893: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
4894: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
4895: VideoController.vcnPal32G8[p] :
4896: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2] :
4897: p == 1 ?
4898: VideoController.vcnPal32G8[0] :
4899: (p & 1) == 0 ?
4900: VideoController.vcnPal32G8[p] :
4901: VideoController.vcnPal32G8[p & -2]);
4902: gx1st += 16;
4903: gx2nd += 16;
4904: gx3rd += 16;
4905: da += 8;
4906: }
4907: }
4908: },
4909:
4910:
4911:
4912:
4913:
4914:
4915:
4916:
4917:
4918:
4919:
4920:
4921:
4922:
4923:
4924:
4925:
4926:
4927:
4928:
4929:
4930:
4931:
4932:
4933:
4934:
4935:
4936:
4937:
4938:
4939:
4940:
4941:
4942:
4943:
4944: E3_XHCT {
4945: @Override public void drawRaster (int src, int dst) {
4946: int pn = VideoController.vcnReg2Curr & 3;
4947: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4948: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4949: pn = VideoController.vcnReg2Curr >> 2 & 3;
4950: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4951: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4952: pn = VideoController.vcnReg2Curr >> 4 & 3;
4953: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
4954: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4955: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4956: int db = da + XEiJ.pnlScreenWidth;
4957: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
4958: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4959: gx1st += half << 1;
4960: gx2nd += half << 1;
4961: gx3rd += half << 1;
4962: da += half;
4963: }
4964: while (da < db) {
4965: int p;
4966: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
4967: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
4968: VideoController.vcnPalTbl[
4969: VideoController.vcnMix2 (
4970: VideoController.vcnPal16G8[p],
4971: 0)] :
4972: VideoController.vcnPal32G8[p] :
4973: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
4974: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
4975: VideoController.vcnPalTbl[
4976: VideoController.vcnMix2 (
4977: VideoController.vcnPal16G8[p],
4978: 0)] :
4979: VideoController.vcnPal32G8[p] :
4980: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) & -2] & 1) != 0 ?
4981: VideoController.vcnPalTbl[
4982: VideoController.vcnMix2 (
4983: VideoController.vcnPal16G8[p],
4984: 0)] :
4985: VideoController.vcnPal32G8[p]);
4986: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
4987: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
4988: VideoController.vcnPalTbl[
4989: VideoController.vcnMix2 (
4990: VideoController.vcnPal16G8[p],
4991: 0)] :
4992: VideoController.vcnPal32G8[p] :
4993: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
4994: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
4995: VideoController.vcnPalTbl[
4996: VideoController.vcnMix2 (
4997: VideoController.vcnPal16G8[p],
4998: 0)] :
4999: VideoController.vcnPal32G8[p] :
5000: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) & -2] & 1) != 0 ?
5001: VideoController.vcnPalTbl[
5002: VideoController.vcnMix2 (
5003: VideoController.vcnPal16G8[p],
5004: 0)] :
5005: VideoController.vcnPal32G8[p]);
5006: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
5007: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5008: VideoController.vcnPalTbl[
5009: VideoController.vcnMix2 (
5010: VideoController.vcnPal16G8[p],
5011: 0)] :
5012: VideoController.vcnPal32G8[p] :
5013: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
5014: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5015: VideoController.vcnPalTbl[
5016: VideoController.vcnMix2 (
5017: VideoController.vcnPal16G8[p],
5018: 0)] :
5019: VideoController.vcnPal32G8[p] :
5020: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) & -2] & 1) != 0 ?
5021: VideoController.vcnPalTbl[
5022: VideoController.vcnMix2 (
5023: VideoController.vcnPal16G8[p],
5024: 0)] :
5025: VideoController.vcnPal32G8[p]);
5026: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
5027: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5028: VideoController.vcnPalTbl[
5029: VideoController.vcnMix2 (
5030: VideoController.vcnPal16G8[p],
5031: 0)] :
5032: VideoController.vcnPal32G8[p] :
5033: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
5034: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5035: VideoController.vcnPalTbl[
5036: VideoController.vcnMix2 (
5037: VideoController.vcnPal16G8[p],
5038: 0)] :
5039: VideoController.vcnPal32G8[p] :
5040: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) & -2] & 1) != 0 ?
5041: VideoController.vcnPalTbl[
5042: VideoController.vcnMix2 (
5043: VideoController.vcnPal16G8[p],
5044: 0)] :
5045: VideoController.vcnPal32G8[p]);
5046: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
5047: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5048: VideoController.vcnPalTbl[
5049: VideoController.vcnMix2 (
5050: VideoController.vcnPal16G8[p],
5051: 0)] :
5052: VideoController.vcnPal32G8[p] :
5053: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
5054: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5055: VideoController.vcnPalTbl[
5056: VideoController.vcnMix2 (
5057: VideoController.vcnPal16G8[p],
5058: 0)] :
5059: VideoController.vcnPal32G8[p] :
5060: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) & -2] & 1) != 0 ?
5061: VideoController.vcnPalTbl[
5062: VideoController.vcnMix2 (
5063: VideoController.vcnPal16G8[p],
5064: 0)] :
5065: VideoController.vcnPal32G8[p]);
5066: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
5067: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5068: VideoController.vcnPalTbl[
5069: VideoController.vcnMix2 (
5070: VideoController.vcnPal16G8[p],
5071: 0)] :
5072: VideoController.vcnPal32G8[p] :
5073: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
5074: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5075: VideoController.vcnPalTbl[
5076: VideoController.vcnMix2 (
5077: VideoController.vcnPal16G8[p],
5078: 0)] :
5079: VideoController.vcnPal32G8[p] :
5080: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) & -2] & 1) != 0 ?
5081: VideoController.vcnPalTbl[
5082: VideoController.vcnMix2 (
5083: VideoController.vcnPal16G8[p],
5084: 0)] :
5085: VideoController.vcnPal32G8[p]);
5086: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
5087: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5088: VideoController.vcnPalTbl[
5089: VideoController.vcnMix2 (
5090: VideoController.vcnPal16G8[p],
5091: 0)] :
5092: VideoController.vcnPal32G8[p] :
5093: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
5094: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5095: VideoController.vcnPalTbl[
5096: VideoController.vcnMix2 (
5097: VideoController.vcnPal16G8[p],
5098: 0)] :
5099: VideoController.vcnPal32G8[p] :
5100: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) & -2] & 1) != 0 ?
5101: VideoController.vcnPalTbl[
5102: VideoController.vcnMix2 (
5103: VideoController.vcnPal16G8[p],
5104: 0)] :
5105: VideoController.vcnPal32G8[p]);
5106: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
5107: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5108: VideoController.vcnPalTbl[
5109: VideoController.vcnMix2 (
5110: VideoController.vcnPal16G8[p],
5111: 0)] :
5112: VideoController.vcnPal32G8[p] :
5113: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
5114: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5115: VideoController.vcnPalTbl[
5116: VideoController.vcnMix2 (
5117: VideoController.vcnPal16G8[p],
5118: 0)] :
5119: VideoController.vcnPal32G8[p] :
5120: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) & -2] & 1) != 0 ?
5121: VideoController.vcnPalTbl[
5122: VideoController.vcnMix2 (
5123: VideoController.vcnPal16G8[p],
5124: 0)] :
5125: VideoController.vcnPal32G8[p]);
5126: gx1st += 16;
5127: gx2nd += 16;
5128: gx3rd += 16;
5129: da += 8;
5130: }
5131: }
5132: },
5133:
5134:
5135:
5136:
5137:
5138:
5139:
5140:
5141:
5142:
5143:
5144:
5145:
5146:
5147:
5148:
5149:
5150:
5151:
5152:
5153:
5154:
5155:
5156:
5157:
5158:
5159:
5160:
5161:
5162:
5163:
5164:
5165:
5166:
5167:
5168:
5169:
5170:
5171:
5172:
5173:
5174: E3_XHCG {
5175: @Override public void drawRaster (int src, int dst) {
5176: int pn = VideoController.vcnReg2Curr & 3;
5177: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
5178: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5179: pn = VideoController.vcnReg2Curr >> 2 & 3;
5180: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
5181: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5182: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5183: pn = VideoController.vcnReg2Curr >> 4 & 3;
5184: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
5185: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5186: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
5187: int db = da + XEiJ.pnlScreenWidth;
5188: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
5189: int half = XEiJ.pnlScreenWidth >> 4 << 3;
5190: gx1st += half << 1;
5191: gx2nd += half << 1;
5192: gx3rd += half << 1;
5193: da += half;
5194: }
5195: while (da < db) {
5196: int p, q;
5197: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
5198: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5199: VideoController.vcnPalTbl[
5200: VideoController.vcnMix2 (
5201: q,
5202: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
5203: (p & 1) != 0 ?
5204: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
5205: VideoController.vcnPal32G8[p] :
5206: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
5207: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5208: VideoController.vcnPalTbl[
5209: VideoController.vcnMix2 (
5210: q,
5211: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
5212: VideoController.vcnPal32G8[p] :
5213: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) & -2]) & 1) != 0 ?
5214: VideoController.vcnPalTbl[
5215: VideoController.vcnMix2 (
5216: p,
5217: VideoController.vcnPal16G8[1])] :
5218: (q & 1) != 0 ?
5219: VideoController.vcnPal32G8[1] :
5220: VideoController.vcnPal32G8[q]);
5221: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
5222: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5223: VideoController.vcnPalTbl[
5224: VideoController.vcnMix2 (
5225: q,
5226: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
5227: (p & 1) != 0 ?
5228: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
5229: VideoController.vcnPal32G8[p] :
5230: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
5231: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5232: VideoController.vcnPalTbl[
5233: VideoController.vcnMix2 (
5234: q,
5235: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
5236: VideoController.vcnPal32G8[p] :
5237: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) & -2]) & 1) != 0 ?
5238: VideoController.vcnPalTbl[
5239: VideoController.vcnMix2 (
5240: p,
5241: VideoController.vcnPal16G8[1])] :
5242: (q & 1) != 0 ?
5243: VideoController.vcnPal32G8[1] :
5244: VideoController.vcnPal32G8[q]);
5245: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
5246: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5247: VideoController.vcnPalTbl[
5248: VideoController.vcnMix2 (
5249: q,
5250: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
5251: (p & 1) != 0 ?
5252: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
5253: VideoController.vcnPal32G8[p] :
5254: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
5255: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5256: VideoController.vcnPalTbl[
5257: VideoController.vcnMix2 (
5258: q,
5259: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
5260: VideoController.vcnPal32G8[p] :
5261: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) & -2]) & 1) != 0 ?
5262: VideoController.vcnPalTbl[
5263: VideoController.vcnMix2 (
5264: p,
5265: VideoController.vcnPal16G8[1])] :
5266: (q & 1) != 0 ?
5267: VideoController.vcnPal32G8[1] :
5268: VideoController.vcnPal32G8[q]);
5269: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
5270: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5271: VideoController.vcnPalTbl[
5272: VideoController.vcnMix2 (
5273: q,
5274: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
5275: (p & 1) != 0 ?
5276: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
5277: VideoController.vcnPal32G8[p] :
5278: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
5279: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5280: VideoController.vcnPalTbl[
5281: VideoController.vcnMix2 (
5282: q,
5283: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
5284: VideoController.vcnPal32G8[p] :
5285: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) & -2]) & 1) != 0 ?
5286: VideoController.vcnPalTbl[
5287: VideoController.vcnMix2 (
5288: p,
5289: VideoController.vcnPal16G8[1])] :
5290: (q & 1) != 0 ?
5291: VideoController.vcnPal32G8[1] :
5292: VideoController.vcnPal32G8[q]);
5293: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
5294: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5295: VideoController.vcnPalTbl[
5296: VideoController.vcnMix2 (
5297: q,
5298: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
5299: (p & 1) != 0 ?
5300: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
5301: VideoController.vcnPal32G8[p] :
5302: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
5303: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5304: VideoController.vcnPalTbl[
5305: VideoController.vcnMix2 (
5306: q,
5307: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
5308: VideoController.vcnPal32G8[p] :
5309: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) & -2]) & 1) != 0 ?
5310: VideoController.vcnPalTbl[
5311: VideoController.vcnMix2 (
5312: p,
5313: VideoController.vcnPal16G8[1])] :
5314: (q & 1) != 0 ?
5315: VideoController.vcnPal32G8[1] :
5316: VideoController.vcnPal32G8[q]);
5317: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
5318: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5319: VideoController.vcnPalTbl[
5320: VideoController.vcnMix2 (
5321: q,
5322: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
5323: (p & 1) != 0 ?
5324: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
5325: VideoController.vcnPal32G8[p] :
5326: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
5327: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5328: VideoController.vcnPalTbl[
5329: VideoController.vcnMix2 (
5330: q,
5331: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
5332: VideoController.vcnPal32G8[p] :
5333: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) & -2]) & 1) != 0 ?
5334: VideoController.vcnPalTbl[
5335: VideoController.vcnMix2 (
5336: p,
5337: VideoController.vcnPal16G8[1])] :
5338: (q & 1) != 0 ?
5339: VideoController.vcnPal32G8[1] :
5340: VideoController.vcnPal32G8[q]);
5341: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
5342: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5343: VideoController.vcnPalTbl[
5344: VideoController.vcnMix2 (
5345: q,
5346: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
5347: (p & 1) != 0 ?
5348: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
5349: VideoController.vcnPal32G8[p] :
5350: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
5351: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5352: VideoController.vcnPalTbl[
5353: VideoController.vcnMix2 (
5354: q,
5355: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
5356: VideoController.vcnPal32G8[p] :
5357: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) & -2]) & 1) != 0 ?
5358: VideoController.vcnPalTbl[
5359: VideoController.vcnMix2 (
5360: p,
5361: VideoController.vcnPal16G8[1])] :
5362: (q & 1) != 0 ?
5363: VideoController.vcnPal32G8[1] :
5364: VideoController.vcnPal32G8[q]);
5365: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
5366: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5367: VideoController.vcnPalTbl[
5368: VideoController.vcnMix2 (
5369: q,
5370: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
5371: (p & 1) != 0 ?
5372: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
5373: VideoController.vcnPal32G8[p] :
5374: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
5375: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5376: VideoController.vcnPalTbl[
5377: VideoController.vcnMix2 (
5378: q,
5379: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
5380: VideoController.vcnPal32G8[p] :
5381: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) & -2]) & 1) != 0 ?
5382: VideoController.vcnPalTbl[
5383: VideoController.vcnMix2 (
5384: p,
5385: VideoController.vcnPal16G8[1])] :
5386: (q & 1) != 0 ?
5387: VideoController.vcnPal32G8[1] :
5388: VideoController.vcnPal32G8[q]);
5389: gx1st += 16;
5390: gx2nd += 16;
5391: gx3rd += 16;
5392: da += 8;
5393: }
5394: }
5395: },
5396:
5397:
5398:
5399:
5400:
5401:
5402:
5403:
5404:
5405:
5406:
5407:
5408:
5409:
5410:
5411:
5412:
5413:
5414:
5415:
5416:
5417:
5418:
5419:
5420:
5421:
5422:
5423:
5424:
5425:
5426:
5427:
5428:
5429:
5430:
5431:
5432:
5433:
5434:
5435:
5436:
5437: E3_XHCGT {
5438: @Override public void drawRaster (int src, int dst) {
5439: int pn = VideoController.vcnReg2Curr & 3;
5440: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
5441: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5442: pn = VideoController.vcnReg2Curr >> 2 & 3;
5443: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
5444: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5445: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5446: pn = VideoController.vcnReg2Curr >> 4 & 3;
5447: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
5448: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5449: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
5450: int db = da + XEiJ.pnlScreenWidth;
5451: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
5452: int half = XEiJ.pnlScreenWidth >> 4 << 3;
5453: gx1st += half << 1;
5454: gx2nd += half << 1;
5455: gx3rd += half << 1;
5456: da += half;
5457: }
5458: while (da < db) {
5459: int p, q;
5460: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
5461: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5462: VideoController.vcnPalTbl[
5463: VideoController.vcnMix2 (
5464: VideoController.vcnMix2 (
5465: q,
5466: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
5467: 0)] :
5468: (p & 1) != 0 ?
5469: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
5470: VideoController.vcnPal32G8[p] :
5471: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
5472: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5473: VideoController.vcnPalTbl[
5474: VideoController.vcnMix2 (
5475: VideoController.vcnMix2 (
5476: q,
5477: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
5478: 0)] :
5479: VideoController.vcnPal32G8[p] :
5480: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) & -2]) & 1) != 0 ?
5481: VideoController.vcnPalTbl[
5482: VideoController.vcnMix2 (
5483: VideoController.vcnMix2 (
5484: p,
5485: VideoController.vcnPal16G8[1]),
5486: 0)] :
5487: (q & 1) != 0 ?
5488: VideoController.vcnPal32G8[1] :
5489: VideoController.vcnPal32G8[q]);
5490: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
5491: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5492: VideoController.vcnPalTbl[
5493: VideoController.vcnMix2 (
5494: VideoController.vcnMix2 (
5495: q,
5496: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
5497: 0)] :
5498: (p & 1) != 0 ?
5499: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
5500: VideoController.vcnPal32G8[p] :
5501: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
5502: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5503: VideoController.vcnPalTbl[
5504: VideoController.vcnMix2 (
5505: VideoController.vcnMix2 (
5506: q,
5507: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
5508: 0)] :
5509: VideoController.vcnPal32G8[p] :
5510: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) & -2]) & 1) != 0 ?
5511: VideoController.vcnPalTbl[
5512: VideoController.vcnMix2 (
5513: VideoController.vcnMix2 (
5514: p,
5515: VideoController.vcnPal16G8[1]),
5516: 0)] :
5517: (q & 1) != 0 ?
5518: VideoController.vcnPal32G8[1] :
5519: VideoController.vcnPal32G8[q]);
5520: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
5521: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5522: VideoController.vcnPalTbl[
5523: VideoController.vcnMix2 (
5524: VideoController.vcnMix2 (
5525: q,
5526: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
5527: 0)] :
5528: (p & 1) != 0 ?
5529: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
5530: VideoController.vcnPal32G8[p] :
5531: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
5532: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5533: VideoController.vcnPalTbl[
5534: VideoController.vcnMix2 (
5535: VideoController.vcnMix2 (
5536: q,
5537: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
5538: 0)] :
5539: VideoController.vcnPal32G8[p] :
5540: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) & -2]) & 1) != 0 ?
5541: VideoController.vcnPalTbl[
5542: VideoController.vcnMix2 (
5543: VideoController.vcnMix2 (
5544: p,
5545: VideoController.vcnPal16G8[1]),
5546: 0)] :
5547: (q & 1) != 0 ?
5548: VideoController.vcnPal32G8[1] :
5549: VideoController.vcnPal32G8[q]);
5550: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
5551: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5552: VideoController.vcnPalTbl[
5553: VideoController.vcnMix2 (
5554: VideoController.vcnMix2 (
5555: q,
5556: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
5557: 0)] :
5558: (p & 1) != 0 ?
5559: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
5560: VideoController.vcnPal32G8[p] :
5561: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
5562: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5563: VideoController.vcnPalTbl[
5564: VideoController.vcnMix2 (
5565: VideoController.vcnMix2 (
5566: q,
5567: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
5568: 0)] :
5569: VideoController.vcnPal32G8[p] :
5570: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) & -2]) & 1) != 0 ?
5571: VideoController.vcnPalTbl[
5572: VideoController.vcnMix2 (
5573: VideoController.vcnMix2 (
5574: p,
5575: VideoController.vcnPal16G8[1]),
5576: 0)] :
5577: (q & 1) != 0 ?
5578: VideoController.vcnPal32G8[1] :
5579: VideoController.vcnPal32G8[q]);
5580: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
5581: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5582: VideoController.vcnPalTbl[
5583: VideoController.vcnMix2 (
5584: VideoController.vcnMix2 (
5585: q,
5586: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
5587: 0)] :
5588: (p & 1) != 0 ?
5589: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
5590: VideoController.vcnPal32G8[p] :
5591: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
5592: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5593: VideoController.vcnPalTbl[
5594: VideoController.vcnMix2 (
5595: VideoController.vcnMix2 (
5596: q,
5597: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
5598: 0)] :
5599: VideoController.vcnPal32G8[p] :
5600: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) & -2]) & 1) != 0 ?
5601: VideoController.vcnPalTbl[
5602: VideoController.vcnMix2 (
5603: VideoController.vcnMix2 (
5604: p,
5605: VideoController.vcnPal16G8[1]),
5606: 0)] :
5607: (q & 1) != 0 ?
5608: VideoController.vcnPal32G8[1] :
5609: VideoController.vcnPal32G8[q]);
5610: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
5611: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5612: VideoController.vcnPalTbl[
5613: VideoController.vcnMix2 (
5614: VideoController.vcnMix2 (
5615: q,
5616: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
5617: 0)] :
5618: (p & 1) != 0 ?
5619: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
5620: VideoController.vcnPal32G8[p] :
5621: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
5622: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5623: VideoController.vcnPalTbl[
5624: VideoController.vcnMix2 (
5625: VideoController.vcnMix2 (
5626: q,
5627: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
5628: 0)] :
5629: VideoController.vcnPal32G8[p] :
5630: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) & -2]) & 1) != 0 ?
5631: VideoController.vcnPalTbl[
5632: VideoController.vcnMix2 (
5633: VideoController.vcnMix2 (
5634: p,
5635: VideoController.vcnPal16G8[1]),
5636: 0)] :
5637: (q & 1) != 0 ?
5638: VideoController.vcnPal32G8[1] :
5639: VideoController.vcnPal32G8[q]);
5640: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
5641: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5642: VideoController.vcnPalTbl[
5643: VideoController.vcnMix2 (
5644: VideoController.vcnMix2 (
5645: q,
5646: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
5647: 0)] :
5648: (p & 1) != 0 ?
5649: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
5650: VideoController.vcnPal32G8[p] :
5651: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
5652: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5653: VideoController.vcnPalTbl[
5654: VideoController.vcnMix2 (
5655: VideoController.vcnMix2 (
5656: q,
5657: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
5658: 0)] :
5659: VideoController.vcnPal32G8[p] :
5660: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) & -2]) & 1) != 0 ?
5661: VideoController.vcnPalTbl[
5662: VideoController.vcnMix2 (
5663: VideoController.vcnMix2 (
5664: p,
5665: VideoController.vcnPal16G8[1]),
5666: 0)] :
5667: (q & 1) != 0 ?
5668: VideoController.vcnPal32G8[1] :
5669: VideoController.vcnPal32G8[q]);
5670: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
5671: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5672: VideoController.vcnPalTbl[
5673: VideoController.vcnMix2 (
5674: VideoController.vcnMix2 (
5675: q,
5676: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
5677: 0)] :
5678: (p & 1) != 0 ?
5679: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
5680: VideoController.vcnPal32G8[p] :
5681: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
5682: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5683: VideoController.vcnPalTbl[
5684: VideoController.vcnMix2 (
5685: VideoController.vcnMix2 (
5686: q,
5687: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
5688: 0)] :
5689: VideoController.vcnPal32G8[p] :
5690: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) & -2]) & 1) != 0 ?
5691: VideoController.vcnPalTbl[
5692: VideoController.vcnMix2 (
5693: VideoController.vcnMix2 (
5694: p,
5695: VideoController.vcnPal16G8[1]),
5696: 0)] :
5697: (q & 1) != 0 ?
5698: VideoController.vcnPal32G8[1] :
5699: VideoController.vcnPal32G8[q]);
5700: gx1st += 16;
5701: gx2nd += 16;
5702: gx3rd += 16;
5703: da += 8;
5704: }
5705: }
5706: },
5707:
5708:
5709:
5710:
5711:
5712:
5713:
5714:
5715:
5716:
5717:
5718:
5719:
5720:
5721:
5722:
5723:
5724:
5725:
5726:
5727:
5728:
5729:
5730:
5731:
5732:
5733:
5734:
5735:
5736:
5737: E3_XHPT {
5738: @Override public void drawRaster (int src, int dst) {
5739: int pn = VideoController.vcnReg2Curr & 3;
5740: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
5741: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5742: pn = VideoController.vcnReg2Curr >> 2 & 3;
5743: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
5744: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5745: pn = VideoController.vcnReg2Curr >> 4 & 3;
5746: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
5747: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5748: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
5749: int db = da + XEiJ.pnlScreenWidth;
5750: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
5751: int half = XEiJ.pnlScreenWidth >> 4 << 3;
5752: gx1st += half << 1;
5753: gx2nd += half << 1;
5754: gx3rd += half << 1;
5755: da += half;
5756: }
5757: while (da < db) {
5758: int p;
5759: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
5760: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
5761: VideoController.vcnPal32G8[p] :
5762: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2] :
5763: p == 1 ?
5764: VideoController.vcnPal32G8[0] :
5765: (p & 1) == 0 ?
5766: VideoController.vcnPal32G8[p] :
5767: VideoController.vcnPalTbl[
5768: VideoController.vcnMix2 (
5769: VideoController.vcnPal16G8[p & -2],
5770: 0)]);
5771: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
5772: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
5773: VideoController.vcnPal32G8[p] :
5774: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2] :
5775: p == 1 ?
5776: VideoController.vcnPal32G8[0] :
5777: (p & 1) == 0 ?
5778: VideoController.vcnPal32G8[p] :
5779: VideoController.vcnPalTbl[
5780: VideoController.vcnMix2 (
5781: VideoController.vcnPal16G8[p & -2],
5782: 0)]);
5783: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
5784: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
5785: VideoController.vcnPal32G8[p] :
5786: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2] :
5787: p == 1 ?
5788: VideoController.vcnPal32G8[0] :
5789: (p & 1) == 0 ?
5790: VideoController.vcnPal32G8[p] :
5791: VideoController.vcnPalTbl[
5792: VideoController.vcnMix2 (
5793: VideoController.vcnPal16G8[p & -2],
5794: 0)]);
5795: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
5796: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
5797: VideoController.vcnPal32G8[p] :
5798: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2] :
5799: p == 1 ?
5800: VideoController.vcnPal32G8[0] :
5801: (p & 1) == 0 ?
5802: VideoController.vcnPal32G8[p] :
5803: VideoController.vcnPalTbl[
5804: VideoController.vcnMix2 (
5805: VideoController.vcnPal16G8[p & -2],
5806: 0)]);
5807: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
5808: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
5809: VideoController.vcnPal32G8[p] :
5810: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2] :
5811: p == 1 ?
5812: VideoController.vcnPal32G8[0] :
5813: (p & 1) == 0 ?
5814: VideoController.vcnPal32G8[p] :
5815: VideoController.vcnPalTbl[
5816: VideoController.vcnMix2 (
5817: VideoController.vcnPal16G8[p & -2],
5818: 0)]);
5819: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
5820: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
5821: VideoController.vcnPal32G8[p] :
5822: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2] :
5823: p == 1 ?
5824: VideoController.vcnPal32G8[0] :
5825: (p & 1) == 0 ?
5826: VideoController.vcnPal32G8[p] :
5827: VideoController.vcnPalTbl[
5828: VideoController.vcnMix2 (
5829: VideoController.vcnPal16G8[p & -2],
5830: 0)]);
5831: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
5832: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
5833: VideoController.vcnPal32G8[p] :
5834: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2] :
5835: p == 1 ?
5836: VideoController.vcnPal32G8[0] :
5837: (p & 1) == 0 ?
5838: VideoController.vcnPal32G8[p] :
5839: VideoController.vcnPalTbl[
5840: VideoController.vcnMix2 (
5841: VideoController.vcnPal16G8[p & -2],
5842: 0)]);
5843: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
5844: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
5845: VideoController.vcnPal32G8[p] :
5846: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2] :
5847: p == 1 ?
5848: VideoController.vcnPal32G8[0] :
5849: (p & 1) == 0 ?
5850: VideoController.vcnPal32G8[p] :
5851: VideoController.vcnPalTbl[
5852: VideoController.vcnMix2 (
5853: VideoController.vcnPal16G8[p & -2],
5854: 0)]);
5855: gx1st += 16;
5856: gx2nd += 16;
5857: gx3rd += 16;
5858: da += 8;
5859: }
5860: }
5861: },
5862:
5863:
5864:
5865:
5866:
5867:
5868:
5869:
5870:
5871:
5872:
5873:
5874:
5875:
5876:
5877:
5878:
5879:
5880:
5881:
5882:
5883:
5884:
5885:
5886:
5887:
5888:
5889:
5890:
5891:
5892: E3_XHPG {
5893: @Override public void drawRaster (int src, int dst) {
5894: int pn = VideoController.vcnReg2Curr & 3;
5895: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
5896: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5897: pn = VideoController.vcnReg2Curr >> 2 & 3;
5898: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
5899: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5900: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5901: pn = VideoController.vcnReg2Curr >> 4 & 3;
5902: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
5903: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5904: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
5905: int db = da + XEiJ.pnlScreenWidth;
5906: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
5907: int half = XEiJ.pnlScreenWidth >> 4 << 3;
5908: gx1st += half << 1;
5909: gx2nd += half << 1;
5910: gx3rd += half << 1;
5911: da += half;
5912: }
5913: while (da < db) {
5914: int p;
5915: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
5916: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
5917: VideoController.vcnPal32G8[p] :
5918: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2] :
5919: p == 1 ?
5920: VideoController.vcnPal32G8[0] :
5921: (p & 1) == 0 ?
5922: VideoController.vcnPal32G8[p] :
5923: VideoController.vcnPalTbl[
5924: VideoController.vcnMix2 (
5925: VideoController.vcnPal16G8[p & -2],
5926: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])]);
5927: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
5928: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
5929: VideoController.vcnPal32G8[p] :
5930: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2] :
5931: p == 1 ?
5932: VideoController.vcnPal32G8[0] :
5933: (p & 1) == 0 ?
5934: VideoController.vcnPal32G8[p] :
5935: VideoController.vcnPalTbl[
5936: VideoController.vcnMix2 (
5937: VideoController.vcnPal16G8[p & -2],
5938: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])]);
5939: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
5940: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
5941: VideoController.vcnPal32G8[p] :
5942: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2] :
5943: p == 1 ?
5944: VideoController.vcnPal32G8[0] :
5945: (p & 1) == 0 ?
5946: VideoController.vcnPal32G8[p] :
5947: VideoController.vcnPalTbl[
5948: VideoController.vcnMix2 (
5949: VideoController.vcnPal16G8[p & -2],
5950: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])]);
5951: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
5952: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
5953: VideoController.vcnPal32G8[p] :
5954: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2] :
5955: p == 1 ?
5956: VideoController.vcnPal32G8[0] :
5957: (p & 1) == 0 ?
5958: VideoController.vcnPal32G8[p] :
5959: VideoController.vcnPalTbl[
5960: VideoController.vcnMix2 (
5961: VideoController.vcnPal16G8[p & -2],
5962: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])]);
5963: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
5964: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
5965: VideoController.vcnPal32G8[p] :
5966: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2] :
5967: p == 1 ?
5968: VideoController.vcnPal32G8[0] :
5969: (p & 1) == 0 ?
5970: VideoController.vcnPal32G8[p] :
5971: VideoController.vcnPalTbl[
5972: VideoController.vcnMix2 (
5973: VideoController.vcnPal16G8[p & -2],
5974: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])]);
5975: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
5976: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
5977: VideoController.vcnPal32G8[p] :
5978: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2] :
5979: p == 1 ?
5980: VideoController.vcnPal32G8[0] :
5981: (p & 1) == 0 ?
5982: VideoController.vcnPal32G8[p] :
5983: VideoController.vcnPalTbl[
5984: VideoController.vcnMix2 (
5985: VideoController.vcnPal16G8[p & -2],
5986: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])]);
5987: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
5988: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
5989: VideoController.vcnPal32G8[p] :
5990: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2] :
5991: p == 1 ?
5992: VideoController.vcnPal32G8[0] :
5993: (p & 1) == 0 ?
5994: VideoController.vcnPal32G8[p] :
5995: VideoController.vcnPalTbl[
5996: VideoController.vcnMix2 (
5997: VideoController.vcnPal16G8[p & -2],
5998: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])]);
5999: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
6000: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
6001: VideoController.vcnPal32G8[p] :
6002: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2] :
6003: p == 1 ?
6004: VideoController.vcnPal32G8[0] :
6005: (p & 1) == 0 ?
6006: VideoController.vcnPal32G8[p] :
6007: VideoController.vcnPalTbl[
6008: VideoController.vcnMix2 (
6009: VideoController.vcnPal16G8[p & -2],
6010: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])]);
6011: gx1st += 16;
6012: gx2nd += 16;
6013: gx3rd += 16;
6014: da += 8;
6015: }
6016: }
6017: },
6018:
6019:
6020:
6021:
6022:
6023:
6024:
6025:
6026:
6027:
6028:
6029:
6030:
6031:
6032:
6033:
6034:
6035:
6036:
6037:
6038:
6039:
6040:
6041:
6042:
6043:
6044:
6045:
6046:
6047:
6048: E3_XHPGT {
6049: @Override public void drawRaster (int src, int dst) {
6050: int pn = VideoController.vcnReg2Curr & 3;
6051: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6052: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6053: pn = VideoController.vcnReg2Curr >> 2 & 3;
6054: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6055: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6056: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6057: pn = VideoController.vcnReg2Curr >> 4 & 3;
6058: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6059: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6060: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6061: int db = da + XEiJ.pnlScreenWidth;
6062: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
6063: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6064: gx1st += half << 1;
6065: gx2nd += half << 1;
6066: gx3rd += half << 1;
6067: da += half;
6068: }
6069: while (da < db) {
6070: int p;
6071: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
6072: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
6073: VideoController.vcnPal32G8[p] :
6074: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2] :
6075: p == 1 ?
6076: VideoController.vcnPal32G8[0] :
6077: (p & 1) == 0 ?
6078: VideoController.vcnPal32G8[p] :
6079: VideoController.vcnPalTbl[
6080: VideoController.vcnMix2 (
6081: VideoController.vcnMix2 (
6082: VideoController.vcnPal16G8[p & -2],
6083: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
6084: 0)]);
6085: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
6086: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
6087: VideoController.vcnPal32G8[p] :
6088: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2] :
6089: p == 1 ?
6090: VideoController.vcnPal32G8[0] :
6091: (p & 1) == 0 ?
6092: VideoController.vcnPal32G8[p] :
6093: VideoController.vcnPalTbl[
6094: VideoController.vcnMix2 (
6095: VideoController.vcnMix2 (
6096: VideoController.vcnPal16G8[p & -2],
6097: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
6098: 0)]);
6099: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
6100: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
6101: VideoController.vcnPal32G8[p] :
6102: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2] :
6103: p == 1 ?
6104: VideoController.vcnPal32G8[0] :
6105: (p & 1) == 0 ?
6106: VideoController.vcnPal32G8[p] :
6107: VideoController.vcnPalTbl[
6108: VideoController.vcnMix2 (
6109: VideoController.vcnMix2 (
6110: VideoController.vcnPal16G8[p & -2],
6111: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
6112: 0)]);
6113: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
6114: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
6115: VideoController.vcnPal32G8[p] :
6116: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2] :
6117: p == 1 ?
6118: VideoController.vcnPal32G8[0] :
6119: (p & 1) == 0 ?
6120: VideoController.vcnPal32G8[p] :
6121: VideoController.vcnPalTbl[
6122: VideoController.vcnMix2 (
6123: VideoController.vcnMix2 (
6124: VideoController.vcnPal16G8[p & -2],
6125: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
6126: 0)]);
6127: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
6128: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
6129: VideoController.vcnPal32G8[p] :
6130: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2] :
6131: p == 1 ?
6132: VideoController.vcnPal32G8[0] :
6133: (p & 1) == 0 ?
6134: VideoController.vcnPal32G8[p] :
6135: VideoController.vcnPalTbl[
6136: VideoController.vcnMix2 (
6137: VideoController.vcnMix2 (
6138: VideoController.vcnPal16G8[p & -2],
6139: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
6140: 0)]);
6141: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
6142: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
6143: VideoController.vcnPal32G8[p] :
6144: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2] :
6145: p == 1 ?
6146: VideoController.vcnPal32G8[0] :
6147: (p & 1) == 0 ?
6148: VideoController.vcnPal32G8[p] :
6149: VideoController.vcnPalTbl[
6150: VideoController.vcnMix2 (
6151: VideoController.vcnMix2 (
6152: VideoController.vcnPal16G8[p & -2],
6153: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
6154: 0)]);
6155: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
6156: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
6157: VideoController.vcnPal32G8[p] :
6158: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2] :
6159: p == 1 ?
6160: VideoController.vcnPal32G8[0] :
6161: (p & 1) == 0 ?
6162: VideoController.vcnPal32G8[p] :
6163: VideoController.vcnPalTbl[
6164: VideoController.vcnMix2 (
6165: VideoController.vcnMix2 (
6166: VideoController.vcnPal16G8[p & -2],
6167: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
6168: 0)]);
6169: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
6170: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
6171: VideoController.vcnPal32G8[p] :
6172: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2] :
6173: p == 1 ?
6174: VideoController.vcnPal32G8[0] :
6175: (p & 1) == 0 ?
6176: VideoController.vcnPal32G8[p] :
6177: VideoController.vcnPalTbl[
6178: VideoController.vcnMix2 (
6179: VideoController.vcnMix2 (
6180: VideoController.vcnPal16G8[p & -2],
6181: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
6182: 0)]);
6183: gx1st += 16;
6184: gx2nd += 16;
6185: gx3rd += 16;
6186: da += 8;
6187: }
6188: }
6189: },
6190:
6191:
6192:
6193:
6194:
6195:
6196:
6197:
6198:
6199:
6200:
6201:
6202:
6203:
6204:
6205:
6206:
6207:
6208:
6209:
6210:
6211:
6212:
6213:
6214:
6215:
6216: E3_A {
6217: @Override public void drawRaster (int src, int dst) {
6218: int pn = VideoController.vcnReg2Curr & 3;
6219: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6220: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6221: pn = VideoController.vcnReg2Curr >> 2 & 3;
6222: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6223: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6224: pn = VideoController.vcnReg2Curr >> 4 & 3;
6225: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6226: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6227: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6228: int db = da + XEiJ.pnlScreenWidth;
6229: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
6230: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6231: gx1st += half << 1;
6232: gx2nd += half << 1;
6233: gx3rd += half << 1;
6234: da += half;
6235: }
6236: while (da < db) {
6237: int p;
6238: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
6239: (p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
6240: VideoController.vcnMix2 (
6241: VideoController.vcnPal16G8[p],
6242: VideoController.vcnPal16TS[0]) :
6243: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
6244: VideoController.vcnMix2 (
6245: VideoController.vcnPal16G8[p],
6246: VideoController.vcnPal16TS[0]) :
6247: VideoController.vcnMix2 (
6248: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023]],
6249: VideoController.vcnPal16TS[0])]);
6250: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
6251: (p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
6252: VideoController.vcnMix2 (
6253: VideoController.vcnPal16G8[p],
6254: VideoController.vcnPal16TS[0]) :
6255: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
6256: VideoController.vcnMix2 (
6257: VideoController.vcnPal16G8[p],
6258: VideoController.vcnPal16TS[0]) :
6259: VideoController.vcnMix2 (
6260: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]],
6261: VideoController.vcnPal16TS[0])]);
6262: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
6263: (p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
6264: VideoController.vcnMix2 (
6265: VideoController.vcnPal16G8[p],
6266: VideoController.vcnPal16TS[0]) :
6267: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
6268: VideoController.vcnMix2 (
6269: VideoController.vcnPal16G8[p],
6270: VideoController.vcnPal16TS[0]) :
6271: VideoController.vcnMix2 (
6272: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]],
6273: VideoController.vcnPal16TS[0])]);
6274: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
6275: (p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
6276: VideoController.vcnMix2 (
6277: VideoController.vcnPal16G8[p],
6278: VideoController.vcnPal16TS[0]) :
6279: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
6280: VideoController.vcnMix2 (
6281: VideoController.vcnPal16G8[p],
6282: VideoController.vcnPal16TS[0]) :
6283: VideoController.vcnMix2 (
6284: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]],
6285: VideoController.vcnPal16TS[0])]);
6286: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
6287: (p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
6288: VideoController.vcnMix2 (
6289: VideoController.vcnPal16G8[p],
6290: VideoController.vcnPal16TS[0]) :
6291: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
6292: VideoController.vcnMix2 (
6293: VideoController.vcnPal16G8[p],
6294: VideoController.vcnPal16TS[0]) :
6295: VideoController.vcnMix2 (
6296: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]],
6297: VideoController.vcnPal16TS[0])]);
6298: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
6299: (p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
6300: VideoController.vcnMix2 (
6301: VideoController.vcnPal16G8[p],
6302: VideoController.vcnPal16TS[0]) :
6303: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
6304: VideoController.vcnMix2 (
6305: VideoController.vcnPal16G8[p],
6306: VideoController.vcnPal16TS[0]) :
6307: VideoController.vcnMix2 (
6308: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]],
6309: VideoController.vcnPal16TS[0])]);
6310: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
6311: (p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
6312: VideoController.vcnMix2 (
6313: VideoController.vcnPal16G8[p],
6314: VideoController.vcnPal16TS[0]) :
6315: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
6316: VideoController.vcnMix2 (
6317: VideoController.vcnPal16G8[p],
6318: VideoController.vcnPal16TS[0]) :
6319: VideoController.vcnMix2 (
6320: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]],
6321: VideoController.vcnPal16TS[0])]);
6322: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
6323: (p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
6324: VideoController.vcnMix2 (
6325: VideoController.vcnPal16G8[p],
6326: VideoController.vcnPal16TS[0]) :
6327: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
6328: VideoController.vcnMix2 (
6329: VideoController.vcnPal16G8[p],
6330: VideoController.vcnPal16TS[0]) :
6331: VideoController.vcnMix2 (
6332: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]],
6333: VideoController.vcnPal16TS[0])]);
6334: gx1st += 16;
6335: gx2nd += 16;
6336: gx3rd += 16;
6337: da += 8;
6338: }
6339: }
6340: },
6341:
6342:
6343:
6344:
6345:
6346:
6347:
6348:
6349:
6350:
6351:
6352:
6353:
6354:
6355:
6356:
6357:
6358:
6359:
6360:
6361:
6362:
6363:
6364:
6365:
6366:
6367:
6368:
6369:
6370: E4 {
6371: @Override public void drawRaster (int src, int dst) {
6372: int pn = VideoController.vcnReg2Curr & 3;
6373: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6374: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6375: pn = VideoController.vcnReg2Curr >> 2 & 3;
6376: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6377: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6378: pn = VideoController.vcnReg2Curr >> 4 & 3;
6379: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6380: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6381: pn = VideoController.vcnReg2Curr >> 6 & 3;
6382: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
6383: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6384: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6385: int db = da + XEiJ.pnlScreenWidth;
6386: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
6387: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6388: gx1st += half << 1;
6389: gx2nd += half << 1;
6390: gx3rd += half << 1;
6391: gx4th += half << 1;
6392: da += half;
6393: }
6394: while (da < db) {
6395: int p;
6396: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
6397: VideoController.vcnPal32G8[p] :
6398: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
6399: VideoController.vcnPal32G8[p] :
6400: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
6401: VideoController.vcnPal32G8[p] :
6402: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023]]);
6403: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
6404: VideoController.vcnPal32G8[p] :
6405: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
6406: VideoController.vcnPal32G8[p] :
6407: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
6408: VideoController.vcnPal32G8[p] :
6409: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]]);
6410: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
6411: VideoController.vcnPal32G8[p] :
6412: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
6413: VideoController.vcnPal32G8[p] :
6414: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
6415: VideoController.vcnPal32G8[p] :
6416: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]]);
6417: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
6418: VideoController.vcnPal32G8[p] :
6419: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
6420: VideoController.vcnPal32G8[p] :
6421: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
6422: VideoController.vcnPal32G8[p] :
6423: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]]);
6424: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
6425: VideoController.vcnPal32G8[p] :
6426: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
6427: VideoController.vcnPal32G8[p] :
6428: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
6429: VideoController.vcnPal32G8[p] :
6430: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]]);
6431: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
6432: VideoController.vcnPal32G8[p] :
6433: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
6434: VideoController.vcnPal32G8[p] :
6435: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
6436: VideoController.vcnPal32G8[p] :
6437: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]]);
6438: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
6439: VideoController.vcnPal32G8[p] :
6440: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
6441: VideoController.vcnPal32G8[p] :
6442: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
6443: VideoController.vcnPal32G8[p] :
6444: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]]);
6445: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
6446: VideoController.vcnPal32G8[p] :
6447: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
6448: VideoController.vcnPal32G8[p] :
6449: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
6450: VideoController.vcnPal32G8[p] :
6451: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]]);
6452: gx1st += 16;
6453: gx2nd += 16;
6454: gx3rd += 16;
6455: gx4th += 16;
6456: da += 8;
6457: }
6458: }
6459: },
6460:
6461:
6462:
6463:
6464:
6465:
6466: XE4 {
6467: @Override public void drawRaster (int src, int dst) {
6468: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
6469:
6470: case 0b00010000:
6471: case 0b00010001:
6472: case 0b00010010:
6473: case 0b00010011:
6474: E4.drawRaster (src, dst);
6475: break;
6476:
6477: case 0b00010100:
6478: case 0b00010101:
6479: case 0b00010110:
6480: case 0b00010111:
6481: E4_XWP.drawRaster (src, dst);
6482: break;
6483:
6484: case 0b00011000:
6485: E4.drawRaster (src, dst);
6486: break;
6487:
6488: case 0b00011001:
6489: E4_XHCT.drawRaster (src, dst);
6490: break;
6491:
6492: case 0b00011010:
6493: E4_XHCG.drawRaster (src, dst);
6494: break;
6495:
6496: case 0b00011011:
6497: E4_XHCGT.drawRaster (src, dst);
6498: break;
6499:
6500: case 0b00011101:
6501: E4_XHPT.drawRaster (src, dst);
6502: break;
6503:
6504: case 0b00011110:
6505: E4_XHPG.drawRaster (src, dst);
6506: break;
6507:
6508: case 0b00011111:
6509: E4_XHPGT.drawRaster (src, dst);
6510: break;
6511:
6512: case 0b01000000:
6513: case 0b01000001:
6514: case 0b01000010:
6515: case 0b01000011:
6516: case 0b01000100:
6517: case 0b01000101:
6518: case 0b01000110:
6519: case 0b01000111:
6520: case 0b01001000:
6521: case 0b01001001:
6522: case 0b01001010:
6523: case 0b01001011:
6524: case 0b01001100:
6525: case 0b01001101:
6526: case 0b01001110:
6527: case 0b01001111:
6528: case 0b01010000:
6529: case 0b01010001:
6530: case 0b01010010:
6531: case 0b01010011:
6532: case 0b01010100:
6533: case 0b01010101:
6534: case 0b01010110:
6535: case 0b01010111:
6536: case 0b01011000:
6537: case 0b01011001:
6538: case 0b01011010:
6539: case 0b01011011:
6540: case 0b01011100:
6541: case 0b01011101:
6542: case 0b01011110:
6543: case 0b01011111:
6544: E4_A.drawRaster (src, dst);
6545: break;
6546: default:
6547: E4.drawRaster (src, dst);
6548: VideoController.vcnReportUnimplemented (XE4);
6549: }
6550: }
6551: },
6552:
6553:
6554:
6555:
6556:
6557:
6558:
6559:
6560:
6561:
6562:
6563:
6564:
6565:
6566:
6567:
6568:
6569:
6570:
6571:
6572:
6573:
6574:
6575:
6576:
6577:
6578:
6579:
6580:
6581:
6582:
6583:
6584:
6585: E4_XWP {
6586: @Override public void drawRaster (int src, int dst) {
6587: int pn = VideoController.vcnReg2Curr & 3;
6588: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6589: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6590: pn = VideoController.vcnReg2Curr >> 2 & 3;
6591: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6592: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6593: pn = VideoController.vcnReg2Curr >> 4 & 3;
6594: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6595: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6596: pn = VideoController.vcnReg2Curr >> 6 & 3;
6597: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
6598: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6599: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6600: int db = da + XEiJ.pnlScreenWidth;
6601: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
6602: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6603: gx1st += half << 1;
6604: gx2nd += half << 1;
6605: gx3rd += half << 1;
6606: gx4th += half << 1;
6607: da += half;
6608: }
6609: while (da < db) {
6610: int p;
6611: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
6612: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
6613: VideoController.vcnPal32G8[p] :
6614: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2) != 0 ?
6615: VideoController.vcnPal32G8[p] :
6616: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023] & -2] :
6617: p == 1 ?
6618: VideoController.vcnPal32G8[0] :
6619: (p & 1) == 0 ?
6620: VideoController.vcnPal32G8[p] :
6621: VideoController.vcnPal32G8[p & -2]);
6622: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
6623: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
6624: VideoController.vcnPal32G8[p] :
6625: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2) != 0 ?
6626: VideoController.vcnPal32G8[p] :
6627: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] & -2] :
6628: p == 1 ?
6629: VideoController.vcnPal32G8[0] :
6630: (p & 1) == 0 ?
6631: VideoController.vcnPal32G8[p] :
6632: VideoController.vcnPal32G8[p & -2]);
6633: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
6634: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
6635: VideoController.vcnPal32G8[p] :
6636: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2) != 0 ?
6637: VideoController.vcnPal32G8[p] :
6638: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] & -2] :
6639: p == 1 ?
6640: VideoController.vcnPal32G8[0] :
6641: (p & 1) == 0 ?
6642: VideoController.vcnPal32G8[p] :
6643: VideoController.vcnPal32G8[p & -2]);
6644: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
6645: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
6646: VideoController.vcnPal32G8[p] :
6647: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2) != 0 ?
6648: VideoController.vcnPal32G8[p] :
6649: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] & -2] :
6650: p == 1 ?
6651: VideoController.vcnPal32G8[0] :
6652: (p & 1) == 0 ?
6653: VideoController.vcnPal32G8[p] :
6654: VideoController.vcnPal32G8[p & -2]);
6655: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
6656: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
6657: VideoController.vcnPal32G8[p] :
6658: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2) != 0 ?
6659: VideoController.vcnPal32G8[p] :
6660: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] & -2] :
6661: p == 1 ?
6662: VideoController.vcnPal32G8[0] :
6663: (p & 1) == 0 ?
6664: VideoController.vcnPal32G8[p] :
6665: VideoController.vcnPal32G8[p & -2]);
6666: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
6667: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
6668: VideoController.vcnPal32G8[p] :
6669: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2) != 0 ?
6670: VideoController.vcnPal32G8[p] :
6671: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] & -2] :
6672: p == 1 ?
6673: VideoController.vcnPal32G8[0] :
6674: (p & 1) == 0 ?
6675: VideoController.vcnPal32G8[p] :
6676: VideoController.vcnPal32G8[p & -2]);
6677: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
6678: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
6679: VideoController.vcnPal32G8[p] :
6680: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2) != 0 ?
6681: VideoController.vcnPal32G8[p] :
6682: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] & -2] :
6683: p == 1 ?
6684: VideoController.vcnPal32G8[0] :
6685: (p & 1) == 0 ?
6686: VideoController.vcnPal32G8[p] :
6687: VideoController.vcnPal32G8[p & -2]);
6688: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
6689: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
6690: VideoController.vcnPal32G8[p] :
6691: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2) != 0 ?
6692: VideoController.vcnPal32G8[p] :
6693: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] & -2] :
6694: p == 1 ?
6695: VideoController.vcnPal32G8[0] :
6696: (p & 1) == 0 ?
6697: VideoController.vcnPal32G8[p] :
6698: VideoController.vcnPal32G8[p & -2]);
6699: gx1st += 16;
6700: gx2nd += 16;
6701: gx3rd += 16;
6702: gx4th += 16;
6703: da += 8;
6704: }
6705: }
6706: },
6707:
6708:
6709:
6710:
6711:
6712:
6713:
6714:
6715:
6716:
6717:
6718:
6719:
6720:
6721:
6722:
6723:
6724:
6725:
6726:
6727:
6728:
6729:
6730:
6731:
6732:
6733:
6734:
6735:
6736:
6737:
6738:
6739:
6740:
6741:
6742:
6743:
6744:
6745:
6746:
6747:
6748: E4_XHCT {
6749: @Override public void drawRaster (int src, int dst) {
6750: int pn = VideoController.vcnReg2Curr & 3;
6751: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6752: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6753: pn = VideoController.vcnReg2Curr >> 2 & 3;
6754: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6755: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6756: pn = VideoController.vcnReg2Curr >> 4 & 3;
6757: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6758: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6759: pn = VideoController.vcnReg2Curr >> 6 & 3;
6760: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
6761: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6762: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6763: int db = da + XEiJ.pnlScreenWidth;
6764: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
6765: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6766: gx1st += half << 1;
6767: gx2nd += half << 1;
6768: gx3rd += half << 1;
6769: gx4th += half << 1;
6770: da += half;
6771: }
6772: while (da < db) {
6773: int p;
6774: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
6775: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6776: VideoController.vcnPalTbl[
6777: VideoController.vcnMix2 (
6778: VideoController.vcnPal16G8[p],
6779: 0)] :
6780: VideoController.vcnPal32G8[p] :
6781: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
6782: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6783: VideoController.vcnPalTbl[
6784: VideoController.vcnMix2 (
6785: VideoController.vcnPal16G8[p],
6786: 0)] :
6787: VideoController.vcnPal32G8[p] :
6788: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
6789: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6790: VideoController.vcnPalTbl[
6791: VideoController.vcnMix2 (
6792: VideoController.vcnPal16G8[p],
6793: 0)] :
6794: VideoController.vcnPal32G8[p] :
6795: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th & 1023]) & -2] & 1) != 0 ?
6796: VideoController.vcnPalTbl[
6797: VideoController.vcnMix2 (
6798: VideoController.vcnPal16G8[p],
6799: 0)] :
6800: VideoController.vcnPal32G8[p]);
6801: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
6802: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6803: VideoController.vcnPalTbl[
6804: VideoController.vcnMix2 (
6805: VideoController.vcnPal16G8[p],
6806: 0)] :
6807: VideoController.vcnPal32G8[p] :
6808: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
6809: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6810: VideoController.vcnPalTbl[
6811: VideoController.vcnMix2 (
6812: VideoController.vcnPal16G8[p],
6813: 0)] :
6814: VideoController.vcnPal32G8[p] :
6815: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
6816: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6817: VideoController.vcnPalTbl[
6818: VideoController.vcnMix2 (
6819: VideoController.vcnPal16G8[p],
6820: 0)] :
6821: VideoController.vcnPal32G8[p] :
6822: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]) & -2] & 1) != 0 ?
6823: VideoController.vcnPalTbl[
6824: VideoController.vcnMix2 (
6825: VideoController.vcnPal16G8[p],
6826: 0)] :
6827: VideoController.vcnPal32G8[p]);
6828: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
6829: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6830: VideoController.vcnPalTbl[
6831: VideoController.vcnMix2 (
6832: VideoController.vcnPal16G8[p],
6833: 0)] :
6834: VideoController.vcnPal32G8[p] :
6835: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
6836: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6837: VideoController.vcnPalTbl[
6838: VideoController.vcnMix2 (
6839: VideoController.vcnPal16G8[p],
6840: 0)] :
6841: VideoController.vcnPal32G8[p] :
6842: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
6843: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6844: VideoController.vcnPalTbl[
6845: VideoController.vcnMix2 (
6846: VideoController.vcnPal16G8[p],
6847: 0)] :
6848: VideoController.vcnPal32G8[p] :
6849: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]) & -2] & 1) != 0 ?
6850: VideoController.vcnPalTbl[
6851: VideoController.vcnMix2 (
6852: VideoController.vcnPal16G8[p],
6853: 0)] :
6854: VideoController.vcnPal32G8[p]);
6855: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
6856: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6857: VideoController.vcnPalTbl[
6858: VideoController.vcnMix2 (
6859: VideoController.vcnPal16G8[p],
6860: 0)] :
6861: VideoController.vcnPal32G8[p] :
6862: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
6863: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6864: VideoController.vcnPalTbl[
6865: VideoController.vcnMix2 (
6866: VideoController.vcnPal16G8[p],
6867: 0)] :
6868: VideoController.vcnPal32G8[p] :
6869: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
6870: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6871: VideoController.vcnPalTbl[
6872: VideoController.vcnMix2 (
6873: VideoController.vcnPal16G8[p],
6874: 0)] :
6875: VideoController.vcnPal32G8[p] :
6876: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]) & -2] & 1) != 0 ?
6877: VideoController.vcnPalTbl[
6878: VideoController.vcnMix2 (
6879: VideoController.vcnPal16G8[p],
6880: 0)] :
6881: VideoController.vcnPal32G8[p]);
6882: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
6883: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6884: VideoController.vcnPalTbl[
6885: VideoController.vcnMix2 (
6886: VideoController.vcnPal16G8[p],
6887: 0)] :
6888: VideoController.vcnPal32G8[p] :
6889: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
6890: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6891: VideoController.vcnPalTbl[
6892: VideoController.vcnMix2 (
6893: VideoController.vcnPal16G8[p],
6894: 0)] :
6895: VideoController.vcnPal32G8[p] :
6896: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
6897: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6898: VideoController.vcnPalTbl[
6899: VideoController.vcnMix2 (
6900: VideoController.vcnPal16G8[p],
6901: 0)] :
6902: VideoController.vcnPal32G8[p] :
6903: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]) & -2] & 1) != 0 ?
6904: VideoController.vcnPalTbl[
6905: VideoController.vcnMix2 (
6906: VideoController.vcnPal16G8[p],
6907: 0)] :
6908: VideoController.vcnPal32G8[p]);
6909: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
6910: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6911: VideoController.vcnPalTbl[
6912: VideoController.vcnMix2 (
6913: VideoController.vcnPal16G8[p],
6914: 0)] :
6915: VideoController.vcnPal32G8[p] :
6916: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
6917: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6918: VideoController.vcnPalTbl[
6919: VideoController.vcnMix2 (
6920: VideoController.vcnPal16G8[p],
6921: 0)] :
6922: VideoController.vcnPal32G8[p] :
6923: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
6924: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6925: VideoController.vcnPalTbl[
6926: VideoController.vcnMix2 (
6927: VideoController.vcnPal16G8[p],
6928: 0)] :
6929: VideoController.vcnPal32G8[p] :
6930: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]) & -2] & 1) != 0 ?
6931: VideoController.vcnPalTbl[
6932: VideoController.vcnMix2 (
6933: VideoController.vcnPal16G8[p],
6934: 0)] :
6935: VideoController.vcnPal32G8[p]);
6936: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
6937: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6938: VideoController.vcnPalTbl[
6939: VideoController.vcnMix2 (
6940: VideoController.vcnPal16G8[p],
6941: 0)] :
6942: VideoController.vcnPal32G8[p] :
6943: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
6944: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6945: VideoController.vcnPalTbl[
6946: VideoController.vcnMix2 (
6947: VideoController.vcnPal16G8[p],
6948: 0)] :
6949: VideoController.vcnPal32G8[p] :
6950: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
6951: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6952: VideoController.vcnPalTbl[
6953: VideoController.vcnMix2 (
6954: VideoController.vcnPal16G8[p],
6955: 0)] :
6956: VideoController.vcnPal32G8[p] :
6957: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]) & -2] & 1) != 0 ?
6958: VideoController.vcnPalTbl[
6959: VideoController.vcnMix2 (
6960: VideoController.vcnPal16G8[p],
6961: 0)] :
6962: VideoController.vcnPal32G8[p]);
6963: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
6964: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6965: VideoController.vcnPalTbl[
6966: VideoController.vcnMix2 (
6967: VideoController.vcnPal16G8[p],
6968: 0)] :
6969: VideoController.vcnPal32G8[p] :
6970: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
6971: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6972: VideoController.vcnPalTbl[
6973: VideoController.vcnMix2 (
6974: VideoController.vcnPal16G8[p],
6975: 0)] :
6976: VideoController.vcnPal32G8[p] :
6977: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
6978: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6979: VideoController.vcnPalTbl[
6980: VideoController.vcnMix2 (
6981: VideoController.vcnPal16G8[p],
6982: 0)] :
6983: VideoController.vcnPal32G8[p] :
6984: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]) & -2] & 1) != 0 ?
6985: VideoController.vcnPalTbl[
6986: VideoController.vcnMix2 (
6987: VideoController.vcnPal16G8[p],
6988: 0)] :
6989: VideoController.vcnPal32G8[p]);
6990: gx1st += 16;
6991: gx2nd += 16;
6992: gx3rd += 16;
6993: gx4th += 16;
6994: da += 8;
6995: }
6996: }
6997: },
6998:
6999:
7000:
7001:
7002:
7003:
7004:
7005:
7006:
7007:
7008:
7009:
7010:
7011:
7012:
7013:
7014:
7015:
7016:
7017:
7018:
7019:
7020:
7021:
7022:
7023:
7024:
7025:
7026:
7027:
7028:
7029:
7030:
7031:
7032:
7033:
7034:
7035:
7036:
7037:
7038:
7039:
7040:
7041:
7042:
7043:
7044:
7045:
7046:
7047:
7048: E4_XHCG {
7049: @Override public void drawRaster (int src, int dst) {
7050: int pn = VideoController.vcnReg2Curr & 3;
7051: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
7052: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7053: pn = VideoController.vcnReg2Curr >> 2 & 3;
7054: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
7055: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7056: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7057: pn = VideoController.vcnReg2Curr >> 4 & 3;
7058: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
7059: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7060: pn = VideoController.vcnReg2Curr >> 6 & 3;
7061: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
7062: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7063: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
7064: int db = da + XEiJ.pnlScreenWidth;
7065: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
7066: int half = XEiJ.pnlScreenWidth >> 4 << 3;
7067: gx1st += half << 1;
7068: gx2nd += half << 1;
7069: gx3rd += half << 1;
7070: gx4th += half << 1;
7071: da += half;
7072: }
7073: while (da < db) {
7074: int p, q;
7075: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
7076: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7077: VideoController.vcnPalTbl[
7078: VideoController.vcnMix2 (
7079: q,
7080: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
7081: (p & 1) != 0 ?
7082: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
7083: VideoController.vcnPal32G8[p] :
7084: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
7085: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7086: VideoController.vcnPalTbl[
7087: VideoController.vcnMix2 (
7088: q,
7089: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
7090: VideoController.vcnPal32G8[p] :
7091: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
7092: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7093: VideoController.vcnPalTbl[
7094: VideoController.vcnMix2 (
7095: q,
7096: VideoController.vcnPal16G8[1])] :
7097: (p & 1) != 0 ?
7098: VideoController.vcnPal32G8[1] :
7099: VideoController.vcnPal32G8[p] :
7100: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th & 1023]) & -2]) & 1) != 0 ?
7101: VideoController.vcnPalTbl[
7102: VideoController.vcnMix2 (
7103: p,
7104: VideoController.vcnPal16G8[1])] :
7105: (q & 1) != 0 ?
7106: VideoController.vcnPal32G8[1] :
7107: VideoController.vcnPal32G8[q]);
7108: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
7109: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7110: VideoController.vcnPalTbl[
7111: VideoController.vcnMix2 (
7112: q,
7113: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
7114: (p & 1) != 0 ?
7115: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
7116: VideoController.vcnPal32G8[p] :
7117: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
7118: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7119: VideoController.vcnPalTbl[
7120: VideoController.vcnMix2 (
7121: q,
7122: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
7123: VideoController.vcnPal32G8[p] :
7124: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
7125: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7126: VideoController.vcnPalTbl[
7127: VideoController.vcnMix2 (
7128: q,
7129: VideoController.vcnPal16G8[1])] :
7130: (p & 1) != 0 ?
7131: VideoController.vcnPal32G8[1] :
7132: VideoController.vcnPal32G8[p] :
7133: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]) & -2]) & 1) != 0 ?
7134: VideoController.vcnPalTbl[
7135: VideoController.vcnMix2 (
7136: p,
7137: VideoController.vcnPal16G8[1])] :
7138: (q & 1) != 0 ?
7139: VideoController.vcnPal32G8[1] :
7140: VideoController.vcnPal32G8[q]);
7141: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
7142: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7143: VideoController.vcnPalTbl[
7144: VideoController.vcnMix2 (
7145: q,
7146: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
7147: (p & 1) != 0 ?
7148: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
7149: VideoController.vcnPal32G8[p] :
7150: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
7151: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7152: VideoController.vcnPalTbl[
7153: VideoController.vcnMix2 (
7154: q,
7155: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
7156: VideoController.vcnPal32G8[p] :
7157: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
7158: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7159: VideoController.vcnPalTbl[
7160: VideoController.vcnMix2 (
7161: q,
7162: VideoController.vcnPal16G8[1])] :
7163: (p & 1) != 0 ?
7164: VideoController.vcnPal32G8[1] :
7165: VideoController.vcnPal32G8[p] :
7166: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]) & -2]) & 1) != 0 ?
7167: VideoController.vcnPalTbl[
7168: VideoController.vcnMix2 (
7169: p,
7170: VideoController.vcnPal16G8[1])] :
7171: (q & 1) != 0 ?
7172: VideoController.vcnPal32G8[1] :
7173: VideoController.vcnPal32G8[q]);
7174: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
7175: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7176: VideoController.vcnPalTbl[
7177: VideoController.vcnMix2 (
7178: q,
7179: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
7180: (p & 1) != 0 ?
7181: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
7182: VideoController.vcnPal32G8[p] :
7183: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
7184: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7185: VideoController.vcnPalTbl[
7186: VideoController.vcnMix2 (
7187: q,
7188: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
7189: VideoController.vcnPal32G8[p] :
7190: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
7191: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7192: VideoController.vcnPalTbl[
7193: VideoController.vcnMix2 (
7194: q,
7195: VideoController.vcnPal16G8[1])] :
7196: (p & 1) != 0 ?
7197: VideoController.vcnPal32G8[1] :
7198: VideoController.vcnPal32G8[p] :
7199: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]) & -2]) & 1) != 0 ?
7200: VideoController.vcnPalTbl[
7201: VideoController.vcnMix2 (
7202: p,
7203: VideoController.vcnPal16G8[1])] :
7204: (q & 1) != 0 ?
7205: VideoController.vcnPal32G8[1] :
7206: VideoController.vcnPal32G8[q]);
7207: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
7208: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7209: VideoController.vcnPalTbl[
7210: VideoController.vcnMix2 (
7211: q,
7212: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
7213: (p & 1) != 0 ?
7214: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
7215: VideoController.vcnPal32G8[p] :
7216: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
7217: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7218: VideoController.vcnPalTbl[
7219: VideoController.vcnMix2 (
7220: q,
7221: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
7222: VideoController.vcnPal32G8[p] :
7223: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
7224: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7225: VideoController.vcnPalTbl[
7226: VideoController.vcnMix2 (
7227: q,
7228: VideoController.vcnPal16G8[1])] :
7229: (p & 1) != 0 ?
7230: VideoController.vcnPal32G8[1] :
7231: VideoController.vcnPal32G8[p] :
7232: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]) & -2]) & 1) != 0 ?
7233: VideoController.vcnPalTbl[
7234: VideoController.vcnMix2 (
7235: p,
7236: VideoController.vcnPal16G8[1])] :
7237: (q & 1) != 0 ?
7238: VideoController.vcnPal32G8[1] :
7239: VideoController.vcnPal32G8[q]);
7240: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
7241: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7242: VideoController.vcnPalTbl[
7243: VideoController.vcnMix2 (
7244: q,
7245: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
7246: (p & 1) != 0 ?
7247: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
7248: VideoController.vcnPal32G8[p] :
7249: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
7250: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7251: VideoController.vcnPalTbl[
7252: VideoController.vcnMix2 (
7253: q,
7254: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
7255: VideoController.vcnPal32G8[p] :
7256: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
7257: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7258: VideoController.vcnPalTbl[
7259: VideoController.vcnMix2 (
7260: q,
7261: VideoController.vcnPal16G8[1])] :
7262: (p & 1) != 0 ?
7263: VideoController.vcnPal32G8[1] :
7264: VideoController.vcnPal32G8[p] :
7265: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]) & -2]) & 1) != 0 ?
7266: VideoController.vcnPalTbl[
7267: VideoController.vcnMix2 (
7268: p,
7269: VideoController.vcnPal16G8[1])] :
7270: (q & 1) != 0 ?
7271: VideoController.vcnPal32G8[1] :
7272: VideoController.vcnPal32G8[q]);
7273: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
7274: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7275: VideoController.vcnPalTbl[
7276: VideoController.vcnMix2 (
7277: q,
7278: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
7279: (p & 1) != 0 ?
7280: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
7281: VideoController.vcnPal32G8[p] :
7282: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
7283: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7284: VideoController.vcnPalTbl[
7285: VideoController.vcnMix2 (
7286: q,
7287: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
7288: VideoController.vcnPal32G8[p] :
7289: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
7290: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7291: VideoController.vcnPalTbl[
7292: VideoController.vcnMix2 (
7293: q,
7294: VideoController.vcnPal16G8[1])] :
7295: (p & 1) != 0 ?
7296: VideoController.vcnPal32G8[1] :
7297: VideoController.vcnPal32G8[p] :
7298: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]) & -2]) & 1) != 0 ?
7299: VideoController.vcnPalTbl[
7300: VideoController.vcnMix2 (
7301: p,
7302: VideoController.vcnPal16G8[1])] :
7303: (q & 1) != 0 ?
7304: VideoController.vcnPal32G8[1] :
7305: VideoController.vcnPal32G8[q]);
7306: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
7307: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7308: VideoController.vcnPalTbl[
7309: VideoController.vcnMix2 (
7310: q,
7311: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
7312: (p & 1) != 0 ?
7313: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
7314: VideoController.vcnPal32G8[p] :
7315: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
7316: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7317: VideoController.vcnPalTbl[
7318: VideoController.vcnMix2 (
7319: q,
7320: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
7321: VideoController.vcnPal32G8[p] :
7322: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
7323: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7324: VideoController.vcnPalTbl[
7325: VideoController.vcnMix2 (
7326: q,
7327: VideoController.vcnPal16G8[1])] :
7328: (p & 1) != 0 ?
7329: VideoController.vcnPal32G8[1] :
7330: VideoController.vcnPal32G8[p] :
7331: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]) & -2]) & 1) != 0 ?
7332: VideoController.vcnPalTbl[
7333: VideoController.vcnMix2 (
7334: p,
7335: VideoController.vcnPal16G8[1])] :
7336: (q & 1) != 0 ?
7337: VideoController.vcnPal32G8[1] :
7338: VideoController.vcnPal32G8[q]);
7339: gx1st += 16;
7340: gx2nd += 16;
7341: gx3rd += 16;
7342: gx4th += 16;
7343: da += 8;
7344: }
7345: }
7346: },
7347:
7348:
7349:
7350:
7351:
7352:
7353:
7354:
7355:
7356:
7357:
7358:
7359:
7360:
7361:
7362:
7363:
7364:
7365:
7366:
7367:
7368:
7369:
7370:
7371:
7372:
7373:
7374:
7375:
7376:
7377:
7378:
7379:
7380:
7381:
7382:
7383:
7384:
7385:
7386:
7387:
7388:
7389:
7390:
7391:
7392:
7393:
7394:
7395:
7396:
7397: E4_XHCGT {
7398: @Override public void drawRaster (int src, int dst) {
7399: int pn = VideoController.vcnReg2Curr & 3;
7400: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
7401: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7402: pn = VideoController.vcnReg2Curr >> 2 & 3;
7403: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
7404: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7405: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7406: pn = VideoController.vcnReg2Curr >> 4 & 3;
7407: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
7408: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7409: pn = VideoController.vcnReg2Curr >> 6 & 3;
7410: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
7411: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7412: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
7413: int db = da + XEiJ.pnlScreenWidth;
7414: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
7415: int half = XEiJ.pnlScreenWidth >> 4 << 3;
7416: gx1st += half << 1;
7417: gx2nd += half << 1;
7418: gx3rd += half << 1;
7419: gx4th += half << 1;
7420: da += half;
7421: }
7422: while (da < db) {
7423: int p, q;
7424: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
7425: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7426: VideoController.vcnPalTbl[
7427: VideoController.vcnMix2 (
7428: VideoController.vcnMix2 (
7429: q,
7430: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
7431: 0)] :
7432: (p & 1) != 0 ?
7433: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
7434: VideoController.vcnPal32G8[p] :
7435: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
7436: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7437: VideoController.vcnPalTbl[
7438: VideoController.vcnMix2 (
7439: VideoController.vcnMix2 (
7440: q,
7441: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
7442: 0)] :
7443: VideoController.vcnPal32G8[p] :
7444: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
7445: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7446: VideoController.vcnPalTbl[
7447: VideoController.vcnMix2 (
7448: VideoController.vcnMix2 (
7449: q,
7450: VideoController.vcnPal16G8[1]),
7451: 0)] :
7452: (p & 1) != 0 ?
7453: VideoController.vcnPal32G8[1] :
7454: VideoController.vcnPal32G8[p] :
7455: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th & 1023]) & -2]) & 1) != 0 ?
7456: VideoController.vcnPalTbl[
7457: VideoController.vcnMix2 (
7458: VideoController.vcnMix2 (
7459: p,
7460: VideoController.vcnPal16G8[1]),
7461: 0)] :
7462: (q & 1) != 0 ?
7463: VideoController.vcnPal32G8[1] :
7464: VideoController.vcnPal32G8[q]);
7465: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
7466: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7467: VideoController.vcnPalTbl[
7468: VideoController.vcnMix2 (
7469: VideoController.vcnMix2 (
7470: q,
7471: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
7472: 0)] :
7473: (p & 1) != 0 ?
7474: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
7475: VideoController.vcnPal32G8[p] :
7476: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
7477: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7478: VideoController.vcnPalTbl[
7479: VideoController.vcnMix2 (
7480: VideoController.vcnMix2 (
7481: q,
7482: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
7483: 0)] :
7484: VideoController.vcnPal32G8[p] :
7485: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
7486: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7487: VideoController.vcnPalTbl[
7488: VideoController.vcnMix2 (
7489: VideoController.vcnMix2 (
7490: q,
7491: VideoController.vcnPal16G8[1]),
7492: 0)] :
7493: (p & 1) != 0 ?
7494: VideoController.vcnPal32G8[1] :
7495: VideoController.vcnPal32G8[p] :
7496: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]) & -2]) & 1) != 0 ?
7497: VideoController.vcnPalTbl[
7498: VideoController.vcnMix2 (
7499: VideoController.vcnMix2 (
7500: p,
7501: VideoController.vcnPal16G8[1]),
7502: 0)] :
7503: (q & 1) != 0 ?
7504: VideoController.vcnPal32G8[1] :
7505: VideoController.vcnPal32G8[q]);
7506: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
7507: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7508: VideoController.vcnPalTbl[
7509: VideoController.vcnMix2 (
7510: VideoController.vcnMix2 (
7511: q,
7512: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
7513: 0)] :
7514: (p & 1) != 0 ?
7515: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
7516: VideoController.vcnPal32G8[p] :
7517: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
7518: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7519: VideoController.vcnPalTbl[
7520: VideoController.vcnMix2 (
7521: VideoController.vcnMix2 (
7522: q,
7523: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
7524: 0)] :
7525: VideoController.vcnPal32G8[p] :
7526: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
7527: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7528: VideoController.vcnPalTbl[
7529: VideoController.vcnMix2 (
7530: VideoController.vcnMix2 (
7531: q,
7532: VideoController.vcnPal16G8[1]),
7533: 0)] :
7534: (p & 1) != 0 ?
7535: VideoController.vcnPal32G8[1] :
7536: VideoController.vcnPal32G8[p] :
7537: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]) & -2]) & 1) != 0 ?
7538: VideoController.vcnPalTbl[
7539: VideoController.vcnMix2 (
7540: VideoController.vcnMix2 (
7541: p,
7542: VideoController.vcnPal16G8[1]),
7543: 0)] :
7544: (q & 1) != 0 ?
7545: VideoController.vcnPal32G8[1] :
7546: VideoController.vcnPal32G8[q]);
7547: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
7548: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7549: VideoController.vcnPalTbl[
7550: VideoController.vcnMix2 (
7551: VideoController.vcnMix2 (
7552: q,
7553: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
7554: 0)] :
7555: (p & 1) != 0 ?
7556: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
7557: VideoController.vcnPal32G8[p] :
7558: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
7559: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7560: VideoController.vcnPalTbl[
7561: VideoController.vcnMix2 (
7562: VideoController.vcnMix2 (
7563: q,
7564: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
7565: 0)] :
7566: VideoController.vcnPal32G8[p] :
7567: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
7568: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7569: VideoController.vcnPalTbl[
7570: VideoController.vcnMix2 (
7571: VideoController.vcnMix2 (
7572: q,
7573: VideoController.vcnPal16G8[1]),
7574: 0)] :
7575: (p & 1) != 0 ?
7576: VideoController.vcnPal32G8[1] :
7577: VideoController.vcnPal32G8[p] :
7578: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]) & -2]) & 1) != 0 ?
7579: VideoController.vcnPalTbl[
7580: VideoController.vcnMix2 (
7581: VideoController.vcnMix2 (
7582: p,
7583: VideoController.vcnPal16G8[1]),
7584: 0)] :
7585: (q & 1) != 0 ?
7586: VideoController.vcnPal32G8[1] :
7587: VideoController.vcnPal32G8[q]);
7588: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
7589: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7590: VideoController.vcnPalTbl[
7591: VideoController.vcnMix2 (
7592: VideoController.vcnMix2 (
7593: q,
7594: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
7595: 0)] :
7596: (p & 1) != 0 ?
7597: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
7598: VideoController.vcnPal32G8[p] :
7599: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
7600: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7601: VideoController.vcnPalTbl[
7602: VideoController.vcnMix2 (
7603: VideoController.vcnMix2 (
7604: q,
7605: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
7606: 0)] :
7607: VideoController.vcnPal32G8[p] :
7608: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
7609: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7610: VideoController.vcnPalTbl[
7611: VideoController.vcnMix2 (
7612: VideoController.vcnMix2 (
7613: q,
7614: VideoController.vcnPal16G8[1]),
7615: 0)] :
7616: (p & 1) != 0 ?
7617: VideoController.vcnPal32G8[1] :
7618: VideoController.vcnPal32G8[p] :
7619: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]) & -2]) & 1) != 0 ?
7620: VideoController.vcnPalTbl[
7621: VideoController.vcnMix2 (
7622: VideoController.vcnMix2 (
7623: p,
7624: VideoController.vcnPal16G8[1]),
7625: 0)] :
7626: (q & 1) != 0 ?
7627: VideoController.vcnPal32G8[1] :
7628: VideoController.vcnPal32G8[q]);
7629: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
7630: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7631: VideoController.vcnPalTbl[
7632: VideoController.vcnMix2 (
7633: VideoController.vcnMix2 (
7634: q,
7635: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
7636: 0)] :
7637: (p & 1) != 0 ?
7638: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
7639: VideoController.vcnPal32G8[p] :
7640: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
7641: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7642: VideoController.vcnPalTbl[
7643: VideoController.vcnMix2 (
7644: VideoController.vcnMix2 (
7645: q,
7646: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
7647: 0)] :
7648: VideoController.vcnPal32G8[p] :
7649: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
7650: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7651: VideoController.vcnPalTbl[
7652: VideoController.vcnMix2 (
7653: VideoController.vcnMix2 (
7654: q,
7655: VideoController.vcnPal16G8[1]),
7656: 0)] :
7657: (p & 1) != 0 ?
7658: VideoController.vcnPal32G8[1] :
7659: VideoController.vcnPal32G8[p] :
7660: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]) & -2]) & 1) != 0 ?
7661: VideoController.vcnPalTbl[
7662: VideoController.vcnMix2 (
7663: VideoController.vcnMix2 (
7664: p,
7665: VideoController.vcnPal16G8[1]),
7666: 0)] :
7667: (q & 1) != 0 ?
7668: VideoController.vcnPal32G8[1] :
7669: VideoController.vcnPal32G8[q]);
7670: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
7671: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7672: VideoController.vcnPalTbl[
7673: VideoController.vcnMix2 (
7674: VideoController.vcnMix2 (
7675: q,
7676: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
7677: 0)] :
7678: (p & 1) != 0 ?
7679: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
7680: VideoController.vcnPal32G8[p] :
7681: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
7682: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7683: VideoController.vcnPalTbl[
7684: VideoController.vcnMix2 (
7685: VideoController.vcnMix2 (
7686: q,
7687: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
7688: 0)] :
7689: VideoController.vcnPal32G8[p] :
7690: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
7691: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7692: VideoController.vcnPalTbl[
7693: VideoController.vcnMix2 (
7694: VideoController.vcnMix2 (
7695: q,
7696: VideoController.vcnPal16G8[1]),
7697: 0)] :
7698: (p & 1) != 0 ?
7699: VideoController.vcnPal32G8[1] :
7700: VideoController.vcnPal32G8[p] :
7701: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]) & -2]) & 1) != 0 ?
7702: VideoController.vcnPalTbl[
7703: VideoController.vcnMix2 (
7704: VideoController.vcnMix2 (
7705: p,
7706: VideoController.vcnPal16G8[1]),
7707: 0)] :
7708: (q & 1) != 0 ?
7709: VideoController.vcnPal32G8[1] :
7710: VideoController.vcnPal32G8[q]);
7711: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
7712: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7713: VideoController.vcnPalTbl[
7714: VideoController.vcnMix2 (
7715: VideoController.vcnMix2 (
7716: q,
7717: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
7718: 0)] :
7719: (p & 1) != 0 ?
7720: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
7721: VideoController.vcnPal32G8[p] :
7722: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
7723: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7724: VideoController.vcnPalTbl[
7725: VideoController.vcnMix2 (
7726: VideoController.vcnMix2 (
7727: q,
7728: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
7729: 0)] :
7730: VideoController.vcnPal32G8[p] :
7731: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
7732: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7733: VideoController.vcnPalTbl[
7734: VideoController.vcnMix2 (
7735: VideoController.vcnMix2 (
7736: q,
7737: VideoController.vcnPal16G8[1]),
7738: 0)] :
7739: (p & 1) != 0 ?
7740: VideoController.vcnPal32G8[1] :
7741: VideoController.vcnPal32G8[p] :
7742: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]) & -2]) & 1) != 0 ?
7743: VideoController.vcnPalTbl[
7744: VideoController.vcnMix2 (
7745: VideoController.vcnMix2 (
7746: p,
7747: VideoController.vcnPal16G8[1]),
7748: 0)] :
7749: (q & 1) != 0 ?
7750: VideoController.vcnPal32G8[1] :
7751: VideoController.vcnPal32G8[q]);
7752: gx1st += 16;
7753: gx2nd += 16;
7754: gx3rd += 16;
7755: gx4th += 16;
7756: da += 8;
7757: }
7758: }
7759: },
7760:
7761:
7762:
7763:
7764:
7765:
7766:
7767:
7768:
7769:
7770:
7771:
7772:
7773:
7774:
7775:
7776:
7777:
7778:
7779:
7780:
7781:
7782:
7783:
7784:
7785:
7786:
7787:
7788:
7789:
7790:
7791:
7792:
7793: E4_XHPT {
7794: @Override public void drawRaster (int src, int dst) {
7795: int pn = VideoController.vcnReg2Curr & 3;
7796: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
7797: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7798: pn = VideoController.vcnReg2Curr >> 2 & 3;
7799: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
7800: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7801: pn = VideoController.vcnReg2Curr >> 4 & 3;
7802: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
7803: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7804: pn = VideoController.vcnReg2Curr >> 6 & 3;
7805: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
7806: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7807: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
7808: int db = da + XEiJ.pnlScreenWidth;
7809: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
7810: int half = XEiJ.pnlScreenWidth >> 4 << 3;
7811: gx1st += half << 1;
7812: gx2nd += half << 1;
7813: gx3rd += half << 1;
7814: gx4th += half << 1;
7815: da += half;
7816: }
7817: while (da < db) {
7818: int p;
7819: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
7820: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
7821: VideoController.vcnPal32G8[p] :
7822: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2) != 0 ?
7823: VideoController.vcnPal32G8[p] :
7824: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023] & -2] :
7825: p == 1 ?
7826: VideoController.vcnPal32G8[0] :
7827: (p & 1) == 0 ?
7828: VideoController.vcnPal32G8[p] :
7829: VideoController.vcnPalTbl[
7830: VideoController.vcnMix2 (
7831: VideoController.vcnPal16G8[p & -2],
7832: 0)]);
7833: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
7834: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
7835: VideoController.vcnPal32G8[p] :
7836: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2) != 0 ?
7837: VideoController.vcnPal32G8[p] :
7838: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] & -2] :
7839: p == 1 ?
7840: VideoController.vcnPal32G8[0] :
7841: (p & 1) == 0 ?
7842: VideoController.vcnPal32G8[p] :
7843: VideoController.vcnPalTbl[
7844: VideoController.vcnMix2 (
7845: VideoController.vcnPal16G8[p & -2],
7846: 0)]);
7847: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
7848: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
7849: VideoController.vcnPal32G8[p] :
7850: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2) != 0 ?
7851: VideoController.vcnPal32G8[p] :
7852: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] & -2] :
7853: p == 1 ?
7854: VideoController.vcnPal32G8[0] :
7855: (p & 1) == 0 ?
7856: VideoController.vcnPal32G8[p] :
7857: VideoController.vcnPalTbl[
7858: VideoController.vcnMix2 (
7859: VideoController.vcnPal16G8[p & -2],
7860: 0)]);
7861: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
7862: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
7863: VideoController.vcnPal32G8[p] :
7864: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2) != 0 ?
7865: VideoController.vcnPal32G8[p] :
7866: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] & -2] :
7867: p == 1 ?
7868: VideoController.vcnPal32G8[0] :
7869: (p & 1) == 0 ?
7870: VideoController.vcnPal32G8[p] :
7871: VideoController.vcnPalTbl[
7872: VideoController.vcnMix2 (
7873: VideoController.vcnPal16G8[p & -2],
7874: 0)]);
7875: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
7876: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
7877: VideoController.vcnPal32G8[p] :
7878: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2) != 0 ?
7879: VideoController.vcnPal32G8[p] :
7880: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] & -2] :
7881: p == 1 ?
7882: VideoController.vcnPal32G8[0] :
7883: (p & 1) == 0 ?
7884: VideoController.vcnPal32G8[p] :
7885: VideoController.vcnPalTbl[
7886: VideoController.vcnMix2 (
7887: VideoController.vcnPal16G8[p & -2],
7888: 0)]);
7889: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
7890: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
7891: VideoController.vcnPal32G8[p] :
7892: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2) != 0 ?
7893: VideoController.vcnPal32G8[p] :
7894: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] & -2] :
7895: p == 1 ?
7896: VideoController.vcnPal32G8[0] :
7897: (p & 1) == 0 ?
7898: VideoController.vcnPal32G8[p] :
7899: VideoController.vcnPalTbl[
7900: VideoController.vcnMix2 (
7901: VideoController.vcnPal16G8[p & -2],
7902: 0)]);
7903: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
7904: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
7905: VideoController.vcnPal32G8[p] :
7906: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2) != 0 ?
7907: VideoController.vcnPal32G8[p] :
7908: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] & -2] :
7909: p == 1 ?
7910: VideoController.vcnPal32G8[0] :
7911: (p & 1) == 0 ?
7912: VideoController.vcnPal32G8[p] :
7913: VideoController.vcnPalTbl[
7914: VideoController.vcnMix2 (
7915: VideoController.vcnPal16G8[p & -2],
7916: 0)]);
7917: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
7918: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
7919: VideoController.vcnPal32G8[p] :
7920: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2) != 0 ?
7921: VideoController.vcnPal32G8[p] :
7922: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] & -2] :
7923: p == 1 ?
7924: VideoController.vcnPal32G8[0] :
7925: (p & 1) == 0 ?
7926: VideoController.vcnPal32G8[p] :
7927: VideoController.vcnPalTbl[
7928: VideoController.vcnMix2 (
7929: VideoController.vcnPal16G8[p & -2],
7930: 0)]);
7931: gx1st += 16;
7932: gx2nd += 16;
7933: gx3rd += 16;
7934: gx4th += 16;
7935: da += 8;
7936: }
7937: }
7938: },
7939:
7940:
7941:
7942:
7943:
7944:
7945:
7946:
7947:
7948:
7949:
7950:
7951:
7952:
7953:
7954:
7955:
7956:
7957:
7958:
7959:
7960:
7961:
7962:
7963:
7964:
7965:
7966:
7967:
7968:
7969:
7970:
7971:
7972: E4_XHPG {
7973: @Override public void drawRaster (int src, int dst) {
7974: int pn = VideoController.vcnReg2Curr & 3;
7975: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
7976: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7977: pn = VideoController.vcnReg2Curr >> 2 & 3;
7978: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
7979: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7980: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7981: pn = VideoController.vcnReg2Curr >> 4 & 3;
7982: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
7983: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7984: pn = VideoController.vcnReg2Curr >> 6 & 3;
7985: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
7986: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7987: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
7988: int db = da + XEiJ.pnlScreenWidth;
7989: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
7990: int half = XEiJ.pnlScreenWidth >> 4 << 3;
7991: gx1st += half << 1;
7992: gx2nd += half << 1;
7993: gx3rd += half << 1;
7994: gx4th += half << 1;
7995: da += half;
7996: }
7997: while (da < db) {
7998: int p;
7999: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
8000: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
8001: VideoController.vcnPal32G8[p] :
8002: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2) != 0 ?
8003: VideoController.vcnPal32G8[p] :
8004: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023] & -2] :
8005: p == 1 ?
8006: VideoController.vcnPal32G8[0] :
8007: (p & 1) == 0 ?
8008: VideoController.vcnPal32G8[p] :
8009: VideoController.vcnPalTbl[
8010: VideoController.vcnMix2 (
8011: VideoController.vcnPal16G8[p & -2],
8012: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])]);
8013: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
8014: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
8015: VideoController.vcnPal32G8[p] :
8016: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2) != 0 ?
8017: VideoController.vcnPal32G8[p] :
8018: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] & -2] :
8019: p == 1 ?
8020: VideoController.vcnPal32G8[0] :
8021: (p & 1) == 0 ?
8022: VideoController.vcnPal32G8[p] :
8023: VideoController.vcnPalTbl[
8024: VideoController.vcnMix2 (
8025: VideoController.vcnPal16G8[p & -2],
8026: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])]);
8027: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
8028: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
8029: VideoController.vcnPal32G8[p] :
8030: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2) != 0 ?
8031: VideoController.vcnPal32G8[p] :
8032: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] & -2] :
8033: p == 1 ?
8034: VideoController.vcnPal32G8[0] :
8035: (p & 1) == 0 ?
8036: VideoController.vcnPal32G8[p] :
8037: VideoController.vcnPalTbl[
8038: VideoController.vcnMix2 (
8039: VideoController.vcnPal16G8[p & -2],
8040: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])]);
8041: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
8042: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
8043: VideoController.vcnPal32G8[p] :
8044: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2) != 0 ?
8045: VideoController.vcnPal32G8[p] :
8046: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] & -2] :
8047: p == 1 ?
8048: VideoController.vcnPal32G8[0] :
8049: (p & 1) == 0 ?
8050: VideoController.vcnPal32G8[p] :
8051: VideoController.vcnPalTbl[
8052: VideoController.vcnMix2 (
8053: VideoController.vcnPal16G8[p & -2],
8054: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])]);
8055: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
8056: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
8057: VideoController.vcnPal32G8[p] :
8058: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2) != 0 ?
8059: VideoController.vcnPal32G8[p] :
8060: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] & -2] :
8061: p == 1 ?
8062: VideoController.vcnPal32G8[0] :
8063: (p & 1) == 0 ?
8064: VideoController.vcnPal32G8[p] :
8065: VideoController.vcnPalTbl[
8066: VideoController.vcnMix2 (
8067: VideoController.vcnPal16G8[p & -2],
8068: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])]);
8069: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
8070: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
8071: VideoController.vcnPal32G8[p] :
8072: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2) != 0 ?
8073: VideoController.vcnPal32G8[p] :
8074: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] & -2] :
8075: p == 1 ?
8076: VideoController.vcnPal32G8[0] :
8077: (p & 1) == 0 ?
8078: VideoController.vcnPal32G8[p] :
8079: VideoController.vcnPalTbl[
8080: VideoController.vcnMix2 (
8081: VideoController.vcnPal16G8[p & -2],
8082: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])]);
8083: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
8084: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
8085: VideoController.vcnPal32G8[p] :
8086: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2) != 0 ?
8087: VideoController.vcnPal32G8[p] :
8088: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] & -2] :
8089: p == 1 ?
8090: VideoController.vcnPal32G8[0] :
8091: (p & 1) == 0 ?
8092: VideoController.vcnPal32G8[p] :
8093: VideoController.vcnPalTbl[
8094: VideoController.vcnMix2 (
8095: VideoController.vcnPal16G8[p & -2],
8096: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])]);
8097: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
8098: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
8099: VideoController.vcnPal32G8[p] :
8100: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2) != 0 ?
8101: VideoController.vcnPal32G8[p] :
8102: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] & -2] :
8103: p == 1 ?
8104: VideoController.vcnPal32G8[0] :
8105: (p & 1) == 0 ?
8106: VideoController.vcnPal32G8[p] :
8107: VideoController.vcnPalTbl[
8108: VideoController.vcnMix2 (
8109: VideoController.vcnPal16G8[p & -2],
8110: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])]);
8111: gx1st += 16;
8112: gx2nd += 16;
8113: gx3rd += 16;
8114: gx4th += 16;
8115: da += 8;
8116: }
8117: }
8118: },
8119:
8120:
8121:
8122:
8123:
8124:
8125:
8126:
8127:
8128:
8129:
8130:
8131:
8132:
8133:
8134:
8135:
8136:
8137:
8138:
8139:
8140:
8141:
8142:
8143:
8144:
8145:
8146:
8147:
8148:
8149:
8150:
8151:
8152: E4_XHPGT {
8153: @Override public void drawRaster (int src, int dst) {
8154: int pn = VideoController.vcnReg2Curr & 3;
8155: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8156: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8157: pn = VideoController.vcnReg2Curr >> 2 & 3;
8158: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8159: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8160: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8161: pn = VideoController.vcnReg2Curr >> 4 & 3;
8162: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
8163: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8164: pn = VideoController.vcnReg2Curr >> 6 & 3;
8165: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
8166: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8167: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8168: int db = da + XEiJ.pnlScreenWidth;
8169: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
8170: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8171: gx1st += half << 1;
8172: gx2nd += half << 1;
8173: gx3rd += half << 1;
8174: gx4th += half << 1;
8175: da += half;
8176: }
8177: while (da < db) {
8178: int p;
8179: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
8180: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
8181: VideoController.vcnPal32G8[p] :
8182: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2) != 0 ?
8183: VideoController.vcnPal32G8[p] :
8184: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023] & -2] :
8185: p == 1 ?
8186: VideoController.vcnPal32G8[0] :
8187: (p & 1) == 0 ?
8188: VideoController.vcnPal32G8[p] :
8189: VideoController.vcnPalTbl[
8190: VideoController.vcnMix2 (
8191: VideoController.vcnMix2 (
8192: VideoController.vcnPal16G8[p & -2],
8193: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
8194: 0)]);
8195: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
8196: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
8197: VideoController.vcnPal32G8[p] :
8198: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2) != 0 ?
8199: VideoController.vcnPal32G8[p] :
8200: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] & -2] :
8201: p == 1 ?
8202: VideoController.vcnPal32G8[0] :
8203: (p & 1) == 0 ?
8204: VideoController.vcnPal32G8[p] :
8205: VideoController.vcnPalTbl[
8206: VideoController.vcnMix2 (
8207: VideoController.vcnMix2 (
8208: VideoController.vcnPal16G8[p & -2],
8209: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
8210: 0)]);
8211: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
8212: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
8213: VideoController.vcnPal32G8[p] :
8214: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2) != 0 ?
8215: VideoController.vcnPal32G8[p] :
8216: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] & -2] :
8217: p == 1 ?
8218: VideoController.vcnPal32G8[0] :
8219: (p & 1) == 0 ?
8220: VideoController.vcnPal32G8[p] :
8221: VideoController.vcnPalTbl[
8222: VideoController.vcnMix2 (
8223: VideoController.vcnMix2 (
8224: VideoController.vcnPal16G8[p & -2],
8225: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
8226: 0)]);
8227: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
8228: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
8229: VideoController.vcnPal32G8[p] :
8230: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2) != 0 ?
8231: VideoController.vcnPal32G8[p] :
8232: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] & -2] :
8233: p == 1 ?
8234: VideoController.vcnPal32G8[0] :
8235: (p & 1) == 0 ?
8236: VideoController.vcnPal32G8[p] :
8237: VideoController.vcnPalTbl[
8238: VideoController.vcnMix2 (
8239: VideoController.vcnMix2 (
8240: VideoController.vcnPal16G8[p & -2],
8241: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
8242: 0)]);
8243: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
8244: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
8245: VideoController.vcnPal32G8[p] :
8246: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2) != 0 ?
8247: VideoController.vcnPal32G8[p] :
8248: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] & -2] :
8249: p == 1 ?
8250: VideoController.vcnPal32G8[0] :
8251: (p & 1) == 0 ?
8252: VideoController.vcnPal32G8[p] :
8253: VideoController.vcnPalTbl[
8254: VideoController.vcnMix2 (
8255: VideoController.vcnMix2 (
8256: VideoController.vcnPal16G8[p & -2],
8257: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
8258: 0)]);
8259: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
8260: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
8261: VideoController.vcnPal32G8[p] :
8262: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2) != 0 ?
8263: VideoController.vcnPal32G8[p] :
8264: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] & -2] :
8265: p == 1 ?
8266: VideoController.vcnPal32G8[0] :
8267: (p & 1) == 0 ?
8268: VideoController.vcnPal32G8[p] :
8269: VideoController.vcnPalTbl[
8270: VideoController.vcnMix2 (
8271: VideoController.vcnMix2 (
8272: VideoController.vcnPal16G8[p & -2],
8273: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
8274: 0)]);
8275: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
8276: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
8277: VideoController.vcnPal32G8[p] :
8278: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2) != 0 ?
8279: VideoController.vcnPal32G8[p] :
8280: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] & -2] :
8281: p == 1 ?
8282: VideoController.vcnPal32G8[0] :
8283: (p & 1) == 0 ?
8284: VideoController.vcnPal32G8[p] :
8285: VideoController.vcnPalTbl[
8286: VideoController.vcnMix2 (
8287: VideoController.vcnMix2 (
8288: VideoController.vcnPal16G8[p & -2],
8289: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
8290: 0)]);
8291: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
8292: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
8293: VideoController.vcnPal32G8[p] :
8294: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2) != 0 ?
8295: VideoController.vcnPal32G8[p] :
8296: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] & -2] :
8297: p == 1 ?
8298: VideoController.vcnPal32G8[0] :
8299: (p & 1) == 0 ?
8300: VideoController.vcnPal32G8[p] :
8301: VideoController.vcnPalTbl[
8302: VideoController.vcnMix2 (
8303: VideoController.vcnMix2 (
8304: VideoController.vcnPal16G8[p & -2],
8305: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
8306: 0)]);
8307: gx1st += 16;
8308: gx2nd += 16;
8309: gx3rd += 16;
8310: gx4th += 16;
8311: da += 8;
8312: }
8313: }
8314: },
8315:
8316:
8317:
8318:
8319:
8320:
8321:
8322:
8323:
8324:
8325:
8326:
8327:
8328:
8329:
8330:
8331:
8332:
8333:
8334:
8335:
8336:
8337:
8338:
8339:
8340:
8341:
8342:
8343:
8344: E4_A {
8345: @Override public void drawRaster (int src, int dst) {
8346: int pn = VideoController.vcnReg2Curr & 3;
8347: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8348: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8349: pn = VideoController.vcnReg2Curr >> 2 & 3;
8350: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8351: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8352: pn = VideoController.vcnReg2Curr >> 4 & 3;
8353: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
8354: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8355: pn = VideoController.vcnReg2Curr >> 6 & 3;
8356: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
8357: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8358: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8359: int db = da + XEiJ.pnlScreenWidth;
8360: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
8361: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8362: gx1st += half << 1;
8363: gx2nd += half << 1;
8364: gx3rd += half << 1;
8365: gx4th += half << 1;
8366: da += half;
8367: }
8368: while (da < db) {
8369: int p;
8370: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
8371: (p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
8372: VideoController.vcnMix2 (
8373: VideoController.vcnPal16G8[p],
8374: VideoController.vcnPal16TS[0]) :
8375: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
8376: VideoController.vcnMix2 (
8377: VideoController.vcnPal16G8[p],
8378: VideoController.vcnPal16TS[0]) :
8379: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
8380: VideoController.vcnMix2 (
8381: VideoController.vcnPal16G8[p],
8382: VideoController.vcnPal16TS[0]) :
8383: VideoController.vcnMix2 (
8384: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th & 1023]],
8385: VideoController.vcnPal16TS[0])]);
8386: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
8387: (p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
8388: VideoController.vcnMix2 (
8389: VideoController.vcnPal16G8[p],
8390: VideoController.vcnPal16TS[0]) :
8391: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
8392: VideoController.vcnMix2 (
8393: VideoController.vcnPal16G8[p],
8394: VideoController.vcnPal16TS[0]) :
8395: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
8396: VideoController.vcnMix2 (
8397: VideoController.vcnPal16G8[p],
8398: VideoController.vcnPal16TS[0]) :
8399: VideoController.vcnMix2 (
8400: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]],
8401: VideoController.vcnPal16TS[0])]);
8402: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
8403: (p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
8404: VideoController.vcnMix2 (
8405: VideoController.vcnPal16G8[p],
8406: VideoController.vcnPal16TS[0]) :
8407: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
8408: VideoController.vcnMix2 (
8409: VideoController.vcnPal16G8[p],
8410: VideoController.vcnPal16TS[0]) :
8411: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
8412: VideoController.vcnMix2 (
8413: VideoController.vcnPal16G8[p],
8414: VideoController.vcnPal16TS[0]) :
8415: VideoController.vcnMix2 (
8416: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]],
8417: VideoController.vcnPal16TS[0])]);
8418: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
8419: (p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
8420: VideoController.vcnMix2 (
8421: VideoController.vcnPal16G8[p],
8422: VideoController.vcnPal16TS[0]) :
8423: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
8424: VideoController.vcnMix2 (
8425: VideoController.vcnPal16G8[p],
8426: VideoController.vcnPal16TS[0]) :
8427: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
8428: VideoController.vcnMix2 (
8429: VideoController.vcnPal16G8[p],
8430: VideoController.vcnPal16TS[0]) :
8431: VideoController.vcnMix2 (
8432: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]],
8433: VideoController.vcnPal16TS[0])]);
8434: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
8435: (p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
8436: VideoController.vcnMix2 (
8437: VideoController.vcnPal16G8[p],
8438: VideoController.vcnPal16TS[0]) :
8439: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
8440: VideoController.vcnMix2 (
8441: VideoController.vcnPal16G8[p],
8442: VideoController.vcnPal16TS[0]) :
8443: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
8444: VideoController.vcnMix2 (
8445: VideoController.vcnPal16G8[p],
8446: VideoController.vcnPal16TS[0]) :
8447: VideoController.vcnMix2 (
8448: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]],
8449: VideoController.vcnPal16TS[0])]);
8450: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
8451: (p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
8452: VideoController.vcnMix2 (
8453: VideoController.vcnPal16G8[p],
8454: VideoController.vcnPal16TS[0]) :
8455: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
8456: VideoController.vcnMix2 (
8457: VideoController.vcnPal16G8[p],
8458: VideoController.vcnPal16TS[0]) :
8459: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
8460: VideoController.vcnMix2 (
8461: VideoController.vcnPal16G8[p],
8462: VideoController.vcnPal16TS[0]) :
8463: VideoController.vcnMix2 (
8464: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]],
8465: VideoController.vcnPal16TS[0])]);
8466: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
8467: (p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
8468: VideoController.vcnMix2 (
8469: VideoController.vcnPal16G8[p],
8470: VideoController.vcnPal16TS[0]) :
8471: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
8472: VideoController.vcnMix2 (
8473: VideoController.vcnPal16G8[p],
8474: VideoController.vcnPal16TS[0]) :
8475: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
8476: VideoController.vcnMix2 (
8477: VideoController.vcnPal16G8[p],
8478: VideoController.vcnPal16TS[0]) :
8479: VideoController.vcnMix2 (
8480: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]],
8481: VideoController.vcnPal16TS[0])]);
8482: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
8483: (p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
8484: VideoController.vcnMix2 (
8485: VideoController.vcnPal16G8[p],
8486: VideoController.vcnPal16TS[0]) :
8487: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
8488: VideoController.vcnMix2 (
8489: VideoController.vcnPal16G8[p],
8490: VideoController.vcnPal16TS[0]) :
8491: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
8492: VideoController.vcnMix2 (
8493: VideoController.vcnPal16G8[p],
8494: VideoController.vcnPal16TS[0]) :
8495: VideoController.vcnMix2 (
8496: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]],
8497: VideoController.vcnPal16TS[0])]);
8498: gx1st += 16;
8499: gx2nd += 16;
8500: gx3rd += 16;
8501: gx4th += 16;
8502: da += 8;
8503: }
8504: }
8505: },
8506:
8507:
8508:
8509:
8510:
8511:
8512:
8513:
8514:
8515:
8516:
8517:
8518:
8519:
8520:
8521:
8522:
8523:
8524:
8525:
8526: F1 {
8527: @Override public void drawRaster (int src, int dst) {
8528: int pn = VideoController.vcnReg2Curr & 3;
8529: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8530: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8531: pn = VideoController.vcnReg2Curr >> 2 & 3;
8532: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8533: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8534: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8535: int db = da + XEiJ.pnlScreenWidth;
8536: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
8537: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8538: gx1st += half << 1;
8539: gx2nd += half << 1;
8540: da += half;
8541: }
8542: while (da < db) {
8543: XEiJ.pnlBM[da] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
8544: MainMemory.mmrM8[gy1st | gx1st & 1023])]);
8545: XEiJ.pnlBM[da + 1] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
8546: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])]);
8547: XEiJ.pnlBM[da + 2] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
8548: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])]);
8549: XEiJ.pnlBM[da + 3] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
8550: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])]);
8551: XEiJ.pnlBM[da + 4] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
8552: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])]);
8553: XEiJ.pnlBM[da + 5] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
8554: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])]);
8555: XEiJ.pnlBM[da + 6] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
8556: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])]);
8557: XEiJ.pnlBM[da + 7] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
8558: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])]);
8559: gx1st += 16;
8560: gx2nd += 16;
8561: da += 8;
8562: }
8563: }
8564: },
8565:
8566:
8567:
8568:
8569:
8570:
8571: XF1 {
8572: @Override public void drawRaster (int src, int dst) {
8573: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
8574:
8575: case 0b00010000:
8576: case 0b00010001:
8577: case 0b00010010:
8578: case 0b00010011:
8579: F1.drawRaster (src, dst);
8580: break;
8581:
8582: case 0b00010100:
8583: case 0b00010101:
8584: case 0b00010110:
8585: case 0b00010111:
8586: F1_XWP.drawRaster (src, dst);
8587: break;
8588:
8589: case 0b00011000:
8590: F1.drawRaster (src, dst);
8591: break;
8592:
8593: case 0b00011001:
8594: F1_XHCT.drawRaster (src, dst);
8595: break;
8596:
8597: case 0b00011010:
8598: F1_XHCG.drawRaster (src, dst);
8599: break;
8600:
8601: case 0b00011011:
8602: F1_XHCGT.drawRaster (src, dst);
8603: break;
8604:
8605: case 0b00011101:
8606: F1_XHPT.drawRaster (src, dst);
8607: break;
8608:
8609: case 0b00011110:
8610: F1_XHPG.drawRaster (src, dst);
8611: break;
8612:
8613: case 0b00011111:
8614: F1_XHPGT.drawRaster (src, dst);
8615: break;
8616:
8617: case 0b01000000:
8618: case 0b01000001:
8619: case 0b01000010:
8620: case 0b01000011:
8621: case 0b01000100:
8622: case 0b01000101:
8623: case 0b01000110:
8624: case 0b01000111:
8625: case 0b01001000:
8626: case 0b01001001:
8627: case 0b01001010:
8628: case 0b01001011:
8629: case 0b01001100:
8630: case 0b01001101:
8631: case 0b01001110:
8632: case 0b01001111:
8633: case 0b01010000:
8634: case 0b01010001:
8635: case 0b01010010:
8636: case 0b01010011:
8637: case 0b01010100:
8638: case 0b01010101:
8639: case 0b01010110:
8640: case 0b01010111:
8641: case 0b01011000:
8642: case 0b01011001:
8643: case 0b01011010:
8644: case 0b01011011:
8645: case 0b01011100:
8646: case 0b01011101:
8647: case 0b01011110:
8648: case 0b01011111:
8649: F1_A.drawRaster (src, dst);
8650: break;
8651: default:
8652: F1.drawRaster (src, dst);
8653: VideoController.vcnReportUnimplemented (XF1);
8654: }
8655: }
8656: },
8657:
8658:
8659:
8660:
8661:
8662:
8663:
8664:
8665:
8666:
8667:
8668:
8669:
8670:
8671:
8672:
8673:
8674:
8675:
8676:
8677:
8678:
8679:
8680:
8681:
8682: F1_XWP {
8683: @Override public void drawRaster (int src, int dst) {
8684: int pn = VideoController.vcnReg2Curr & 3;
8685: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8686: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8687: pn = VideoController.vcnReg2Curr >> 2 & 3;
8688: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8689: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8690: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8691: int db = da + XEiJ.pnlScreenWidth;
8692: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
8693: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8694: gx1st += half << 1;
8695: gx2nd += half << 1;
8696: da += half;
8697: }
8698: while (da < db) {
8699: int p;
8700: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
8701: MainMemory.mmrM8[gy1st | gx1st & 1023])) <= 1 ?
8702: VideoController.vcnPal32G8[0] :
8703: (p & 1) == 0 ?
8704: VideoController.vcnPal32G8[p] :
8705: VideoController.vcnPal32G8[p & -2]);
8706: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
8707: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) <= 1 ?
8708: VideoController.vcnPal32G8[0] :
8709: (p & 1) == 0 ?
8710: VideoController.vcnPal32G8[p] :
8711: VideoController.vcnPal32G8[p & -2]);
8712: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
8713: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) <= 1 ?
8714: VideoController.vcnPal32G8[0] :
8715: (p & 1) == 0 ?
8716: VideoController.vcnPal32G8[p] :
8717: VideoController.vcnPal32G8[p & -2]);
8718: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
8719: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) <= 1 ?
8720: VideoController.vcnPal32G8[0] :
8721: (p & 1) == 0 ?
8722: VideoController.vcnPal32G8[p] :
8723: VideoController.vcnPal32G8[p & -2]);
8724: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
8725: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) <= 1 ?
8726: VideoController.vcnPal32G8[0] :
8727: (p & 1) == 0 ?
8728: VideoController.vcnPal32G8[p] :
8729: VideoController.vcnPal32G8[p & -2]);
8730: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
8731: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) <= 1 ?
8732: VideoController.vcnPal32G8[0] :
8733: (p & 1) == 0 ?
8734: VideoController.vcnPal32G8[p] :
8735: VideoController.vcnPal32G8[p & -2]);
8736: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
8737: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) <= 1 ?
8738: VideoController.vcnPal32G8[0] :
8739: (p & 1) == 0 ?
8740: VideoController.vcnPal32G8[p] :
8741: VideoController.vcnPal32G8[p & -2]);
8742: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
8743: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) <= 1 ?
8744: VideoController.vcnPal32G8[0] :
8745: (p & 1) == 0 ?
8746: VideoController.vcnPal32G8[p] :
8747: VideoController.vcnPal32G8[p & -2]);
8748: gx1st += 16;
8749: gx2nd += 16;
8750: da += 8;
8751: }
8752: }
8753: },
8754:
8755:
8756:
8757:
8758:
8759:
8760:
8761:
8762:
8763:
8764:
8765:
8766:
8767:
8768:
8769:
8770:
8771:
8772:
8773:
8774:
8775:
8776:
8777: F1_XHCT {
8778: @Override public void drawRaster (int src, int dst) {
8779: int pn = VideoController.vcnReg2Curr & 3;
8780: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8781: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8782: pn = VideoController.vcnReg2Curr >> 2 & 3;
8783: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8784: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8785: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8786: int db = da + XEiJ.pnlScreenWidth;
8787: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
8788: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8789: gx1st += half << 1;
8790: gx2nd += half << 1;
8791: da += half;
8792: }
8793: while (da < db) {
8794: int p;
8795: XEiJ.pnlBM[da] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
8796: MainMemory.mmrM8[gy1st | gx1st & 1023])) & -2] & 1) != 0 ?
8797: VideoController.vcnPalTbl[
8798: VideoController.vcnMix2 (
8799: VideoController.vcnPal16G8[p],
8800: 0)] :
8801: VideoController.vcnPal32G8[p]);
8802: XEiJ.pnlBM[da + 1] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
8803: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) & -2] & 1) != 0 ?
8804: VideoController.vcnPalTbl[
8805: VideoController.vcnMix2 (
8806: VideoController.vcnPal16G8[p],
8807: 0)] :
8808: VideoController.vcnPal32G8[p]);
8809: XEiJ.pnlBM[da + 2] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
8810: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) & -2] & 1) != 0 ?
8811: VideoController.vcnPalTbl[
8812: VideoController.vcnMix2 (
8813: VideoController.vcnPal16G8[p],
8814: 0)] :
8815: VideoController.vcnPal32G8[p]);
8816: XEiJ.pnlBM[da + 3] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
8817: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) & -2] & 1) != 0 ?
8818: VideoController.vcnPalTbl[
8819: VideoController.vcnMix2 (
8820: VideoController.vcnPal16G8[p],
8821: 0)] :
8822: VideoController.vcnPal32G8[p]);
8823: XEiJ.pnlBM[da + 4] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
8824: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) & -2] & 1) != 0 ?
8825: VideoController.vcnPalTbl[
8826: VideoController.vcnMix2 (
8827: VideoController.vcnPal16G8[p],
8828: 0)] :
8829: VideoController.vcnPal32G8[p]);
8830: XEiJ.pnlBM[da + 5] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
8831: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) & -2] & 1) != 0 ?
8832: VideoController.vcnPalTbl[
8833: VideoController.vcnMix2 (
8834: VideoController.vcnPal16G8[p],
8835: 0)] :
8836: VideoController.vcnPal32G8[p]);
8837: XEiJ.pnlBM[da + 6] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
8838: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) & -2] & 1) != 0 ?
8839: VideoController.vcnPalTbl[
8840: VideoController.vcnMix2 (
8841: VideoController.vcnPal16G8[p],
8842: 0)] :
8843: VideoController.vcnPal32G8[p]);
8844: XEiJ.pnlBM[da + 7] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
8845: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) & -2] & 1) != 0 ?
8846: VideoController.vcnPalTbl[
8847: VideoController.vcnMix2 (
8848: VideoController.vcnPal16G8[p],
8849: 0)] :
8850: VideoController.vcnPal32G8[p]);
8851: gx1st += 16;
8852: gx2nd += 16;
8853: da += 8;
8854: }
8855: }
8856: },
8857:
8858:
8859:
8860:
8861:
8862:
8863:
8864:
8865:
8866:
8867:
8868:
8869:
8870:
8871:
8872:
8873:
8874:
8875:
8876:
8877:
8878:
8879:
8880:
8881:
8882:
8883: F1_XHCG {
8884: @Override public void drawRaster (int src, int dst) {
8885: int pn = VideoController.vcnReg2Curr & 3;
8886: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8887: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8888: pn = VideoController.vcnReg2Curr >> 2 & 3;
8889: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8890: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8891: pn = VideoController.vcnReg2Curr >> 4 & 3;
8892: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
8893: int gz3rd = VideoController.vcnHidden3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8894: pn = VideoController.vcnReg2Curr >> 6 & 3;
8895: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
8896: int gz4th = VideoController.vcnHidden4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8897: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8898: int db = da + XEiJ.pnlScreenWidth;
8899: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
8900: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8901: gx1st += half << 1;
8902: gx2nd += half << 1;
8903: gx3rd += half << 1;
8904: gx4th += half << 1;
8905: da += half;
8906: }
8907: while (da < db) {
8908: int p, q;
8909: XEiJ.pnlBM[da] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
8910: MainMemory.mmrM8[gy1st | gx1st & 1023])) & -2]) & 1) != 0 ?
8911: VideoController.vcnPalTbl[
8912: VideoController.vcnMix2 (
8913: p,
8914: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
8915: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1])] :
8916: (q & 1) != 0 ?
8917: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
8918: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1] :
8919: VideoController.vcnPal32G8[q]);
8920: XEiJ.pnlBM[da + 1] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
8921: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) & -2]) & 1) != 0 ?
8922: VideoController.vcnPalTbl[
8923: VideoController.vcnMix2 (
8924: p,
8925: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
8926: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1])] :
8927: (q & 1) != 0 ?
8928: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
8929: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1] :
8930: VideoController.vcnPal32G8[q]);
8931: XEiJ.pnlBM[da + 2] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
8932: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) & -2]) & 1) != 0 ?
8933: VideoController.vcnPalTbl[
8934: VideoController.vcnMix2 (
8935: p,
8936: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
8937: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1])] :
8938: (q & 1) != 0 ?
8939: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
8940: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1] :
8941: VideoController.vcnPal32G8[q]);
8942: XEiJ.pnlBM[da + 3] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
8943: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) & -2]) & 1) != 0 ?
8944: VideoController.vcnPalTbl[
8945: VideoController.vcnMix2 (
8946: p,
8947: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
8948: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1])] :
8949: (q & 1) != 0 ?
8950: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
8951: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1] :
8952: VideoController.vcnPal32G8[q]);
8953: XEiJ.pnlBM[da + 4] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
8954: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) & -2]) & 1) != 0 ?
8955: VideoController.vcnPalTbl[
8956: VideoController.vcnMix2 (
8957: p,
8958: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
8959: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1])] :
8960: (q & 1) != 0 ?
8961: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
8962: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1] :
8963: VideoController.vcnPal32G8[q]);
8964: XEiJ.pnlBM[da + 5] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
8965: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) & -2]) & 1) != 0 ?
8966: VideoController.vcnPalTbl[
8967: VideoController.vcnMix2 (
8968: p,
8969: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
8970: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1])] :
8971: (q & 1) != 0 ?
8972: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
8973: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1] :
8974: VideoController.vcnPal32G8[q]);
8975: XEiJ.pnlBM[da + 6] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
8976: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) & -2]) & 1) != 0 ?
8977: VideoController.vcnPalTbl[
8978: VideoController.vcnMix2 (
8979: p,
8980: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
8981: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1])] :
8982: (q & 1) != 0 ?
8983: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
8984: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1] :
8985: VideoController.vcnPal32G8[q]);
8986: XEiJ.pnlBM[da + 7] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
8987: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) & -2]) & 1) != 0 ?
8988: VideoController.vcnPalTbl[
8989: VideoController.vcnMix2 (
8990: p,
8991: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
8992: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1])] :
8993: (q & 1) != 0 ?
8994: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
8995: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1] :
8996: VideoController.vcnPal32G8[q]);
8997: gx1st += 16;
8998: gx2nd += 16;
8999: gx3rd += 16;
9000: gx4th += 16;
9001: da += 8;
9002: }
9003: }
9004: },
9005:
9006:
9007:
9008:
9009:
9010:
9011:
9012:
9013:
9014:
9015:
9016:
9017:
9018:
9019:
9020:
9021:
9022:
9023:
9024:
9025:
9026:
9027:
9028:
9029:
9030:
9031: F1_XHCGT {
9032: @Override public void drawRaster (int src, int dst) {
9033: int pn = VideoController.vcnReg2Curr & 3;
9034: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9035: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9036: pn = VideoController.vcnReg2Curr >> 2 & 3;
9037: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9038: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9039: pn = VideoController.vcnReg2Curr >> 4 & 3;
9040: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
9041: int gz3rd = VideoController.vcnHidden3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9042: pn = VideoController.vcnReg2Curr >> 6 & 3;
9043: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
9044: int gz4th = VideoController.vcnHidden4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9045: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9046: int db = da + XEiJ.pnlScreenWidth;
9047: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
9048: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9049: gx1st += half << 1;
9050: gx2nd += half << 1;
9051: gx3rd += half << 1;
9052: gx4th += half << 1;
9053: da += half;
9054: }
9055: while (da < db) {
9056: int p, q;
9057: XEiJ.pnlBM[da] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9058: MainMemory.mmrM8[gy1st | gx1st & 1023])) & -2]) & 1) != 0 ?
9059: VideoController.vcnPalTbl[
9060: VideoController.vcnMix2 (
9061: VideoController.vcnMix2 (
9062: p,
9063: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
9064: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1]),
9065: 0)] :
9066: (q & 1) != 0 ?
9067: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
9068: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1] :
9069: VideoController.vcnPal32G8[q]);
9070: XEiJ.pnlBM[da + 1] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9071: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) & -2]) & 1) != 0 ?
9072: VideoController.vcnPalTbl[
9073: VideoController.vcnMix2 (
9074: VideoController.vcnMix2 (
9075: p,
9076: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
9077: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1]),
9078: 0)] :
9079: (q & 1) != 0 ?
9080: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
9081: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1] :
9082: VideoController.vcnPal32G8[q]);
9083: XEiJ.pnlBM[da + 2] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9084: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) & -2]) & 1) != 0 ?
9085: VideoController.vcnPalTbl[
9086: VideoController.vcnMix2 (
9087: VideoController.vcnMix2 (
9088: p,
9089: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
9090: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1]),
9091: 0)] :
9092: (q & 1) != 0 ?
9093: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
9094: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1] :
9095: VideoController.vcnPal32G8[q]);
9096: XEiJ.pnlBM[da + 3] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9097: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) & -2]) & 1) != 0 ?
9098: VideoController.vcnPalTbl[
9099: VideoController.vcnMix2 (
9100: VideoController.vcnMix2 (
9101: p,
9102: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
9103: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1]),
9104: 0)] :
9105: (q & 1) != 0 ?
9106: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
9107: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1] :
9108: VideoController.vcnPal32G8[q]);
9109: XEiJ.pnlBM[da + 4] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9110: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) & -2]) & 1) != 0 ?
9111: VideoController.vcnPalTbl[
9112: VideoController.vcnMix2 (
9113: VideoController.vcnMix2 (
9114: p,
9115: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
9116: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1]),
9117: 0)] :
9118: (q & 1) != 0 ?
9119: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
9120: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1] :
9121: VideoController.vcnPal32G8[q]);
9122: XEiJ.pnlBM[da + 5] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9123: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) & -2]) & 1) != 0 ?
9124: VideoController.vcnPalTbl[
9125: VideoController.vcnMix2 (
9126: VideoController.vcnMix2 (
9127: p,
9128: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
9129: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1]),
9130: 0)] :
9131: (q & 1) != 0 ?
9132: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
9133: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1] :
9134: VideoController.vcnPal32G8[q]);
9135: XEiJ.pnlBM[da + 6] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9136: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) & -2]) & 1) != 0 ?
9137: VideoController.vcnPalTbl[
9138: VideoController.vcnMix2 (
9139: VideoController.vcnMix2 (
9140: p,
9141: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
9142: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1]),
9143: 0)] :
9144: (q & 1) != 0 ?
9145: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
9146: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1] :
9147: VideoController.vcnPal32G8[q]);
9148: XEiJ.pnlBM[da + 7] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9149: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) & -2]) & 1) != 0 ?
9150: VideoController.vcnPalTbl[
9151: VideoController.vcnMix2 (
9152: VideoController.vcnMix2 (
9153: p,
9154: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
9155: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1]),
9156: 0)] :
9157: (q & 1) != 0 ?
9158: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
9159: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1] :
9160: VideoController.vcnPal32G8[q]);
9161: gx1st += 16;
9162: gx2nd += 16;
9163: gx3rd += 16;
9164: gx4th += 16;
9165: da += 8;
9166: }
9167: }
9168: },
9169:
9170:
9171:
9172:
9173:
9174:
9175:
9176:
9177:
9178:
9179:
9180:
9181:
9182:
9183:
9184:
9185:
9186:
9187:
9188:
9189:
9190:
9191:
9192:
9193:
9194: F1_XHPT {
9195: @Override public void drawRaster (int src, int dst) {
9196: int pn = VideoController.vcnReg2Curr & 3;
9197: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9198: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9199: pn = VideoController.vcnReg2Curr >> 2 & 3;
9200: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9201: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9202: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9203: int db = da + XEiJ.pnlScreenWidth;
9204: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
9205: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9206: gx1st += half << 1;
9207: gx2nd += half << 1;
9208: da += half;
9209: }
9210: while (da < db) {
9211: int p;
9212: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9213: MainMemory.mmrM8[gy1st | gx1st & 1023])) <= 1 ?
9214: VideoController.vcnPal32G8[0] :
9215: (p & 1) == 0 ?
9216: VideoController.vcnPal32G8[p] :
9217: VideoController.vcnPalTbl[
9218: VideoController.vcnMix2 (
9219: VideoController.vcnPal16G8[p & -2],
9220: 0)]);
9221: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9222: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) <= 1 ?
9223: VideoController.vcnPal32G8[0] :
9224: (p & 1) == 0 ?
9225: VideoController.vcnPal32G8[p] :
9226: VideoController.vcnPalTbl[
9227: VideoController.vcnMix2 (
9228: VideoController.vcnPal16G8[p & -2],
9229: 0)]);
9230: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9231: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) <= 1 ?
9232: VideoController.vcnPal32G8[0] :
9233: (p & 1) == 0 ?
9234: VideoController.vcnPal32G8[p] :
9235: VideoController.vcnPalTbl[
9236: VideoController.vcnMix2 (
9237: VideoController.vcnPal16G8[p & -2],
9238: 0)]);
9239: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9240: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) <= 1 ?
9241: VideoController.vcnPal32G8[0] :
9242: (p & 1) == 0 ?
9243: VideoController.vcnPal32G8[p] :
9244: VideoController.vcnPalTbl[
9245: VideoController.vcnMix2 (
9246: VideoController.vcnPal16G8[p & -2],
9247: 0)]);
9248: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9249: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) <= 1 ?
9250: VideoController.vcnPal32G8[0] :
9251: (p & 1) == 0 ?
9252: VideoController.vcnPal32G8[p] :
9253: VideoController.vcnPalTbl[
9254: VideoController.vcnMix2 (
9255: VideoController.vcnPal16G8[p & -2],
9256: 0)]);
9257: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9258: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) <= 1 ?
9259: VideoController.vcnPal32G8[0] :
9260: (p & 1) == 0 ?
9261: VideoController.vcnPal32G8[p] :
9262: VideoController.vcnPalTbl[
9263: VideoController.vcnMix2 (
9264: VideoController.vcnPal16G8[p & -2],
9265: 0)]);
9266: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9267: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) <= 1 ?
9268: VideoController.vcnPal32G8[0] :
9269: (p & 1) == 0 ?
9270: VideoController.vcnPal32G8[p] :
9271: VideoController.vcnPalTbl[
9272: VideoController.vcnMix2 (
9273: VideoController.vcnPal16G8[p & -2],
9274: 0)]);
9275: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9276: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) <= 1 ?
9277: VideoController.vcnPal32G8[0] :
9278: (p & 1) == 0 ?
9279: VideoController.vcnPal32G8[p] :
9280: VideoController.vcnPalTbl[
9281: VideoController.vcnMix2 (
9282: VideoController.vcnPal16G8[p & -2],
9283: 0)]);
9284: gx1st += 16;
9285: gx2nd += 16;
9286: da += 8;
9287: }
9288: }
9289: },
9290:
9291:
9292:
9293:
9294:
9295:
9296:
9297:
9298:
9299:
9300:
9301:
9302:
9303:
9304:
9305:
9306:
9307:
9308:
9309:
9310:
9311:
9312:
9313:
9314:
9315: F1_XHPG {
9316: @Override public void drawRaster (int src, int dst) {
9317: int pn = VideoController.vcnReg2Curr & 3;
9318: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9319: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9320: pn = VideoController.vcnReg2Curr >> 2 & 3;
9321: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9322: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9323: pn = VideoController.vcnReg2Curr >> 4 & 3;
9324: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
9325: int gz3rd = VideoController.vcnHidden3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9326: pn = VideoController.vcnReg2Curr >> 6 & 3;
9327: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
9328: int gz4th = VideoController.vcnHidden4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9329: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9330: int db = da + XEiJ.pnlScreenWidth;
9331: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
9332: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9333: gx1st += half << 1;
9334: gx2nd += half << 1;
9335: gx3rd += half << 1;
9336: gx4th += half << 1;
9337: da += half;
9338: }
9339: while (da < db) {
9340: int p;
9341: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9342: MainMemory.mmrM8[gy1st | gx1st & 1023])) <= 1 ?
9343: VideoController.vcnPal32G8[0] :
9344: (p & 1) == 0 ?
9345: VideoController.vcnPal32G8[p] :
9346: VideoController.vcnPalTbl[
9347: VideoController.vcnMix2 (
9348: VideoController.vcnPal16G8[p & -2],
9349: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
9350: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1])]);
9351: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9352: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) <= 1 ?
9353: VideoController.vcnPal32G8[0] :
9354: (p & 1) == 0 ?
9355: VideoController.vcnPal32G8[p] :
9356: VideoController.vcnPalTbl[
9357: VideoController.vcnMix2 (
9358: VideoController.vcnPal16G8[p & -2],
9359: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
9360: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1])]);
9361: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9362: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) <= 1 ?
9363: VideoController.vcnPal32G8[0] :
9364: (p & 1) == 0 ?
9365: VideoController.vcnPal32G8[p] :
9366: VideoController.vcnPalTbl[
9367: VideoController.vcnMix2 (
9368: VideoController.vcnPal16G8[p & -2],
9369: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
9370: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1])]);
9371: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9372: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) <= 1 ?
9373: VideoController.vcnPal32G8[0] :
9374: (p & 1) == 0 ?
9375: VideoController.vcnPal32G8[p] :
9376: VideoController.vcnPalTbl[
9377: VideoController.vcnMix2 (
9378: VideoController.vcnPal16G8[p & -2],
9379: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
9380: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1])]);
9381: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9382: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) <= 1 ?
9383: VideoController.vcnPal32G8[0] :
9384: (p & 1) == 0 ?
9385: VideoController.vcnPal32G8[p] :
9386: VideoController.vcnPalTbl[
9387: VideoController.vcnMix2 (
9388: VideoController.vcnPal16G8[p & -2],
9389: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
9390: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1])]);
9391: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9392: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) <= 1 ?
9393: VideoController.vcnPal32G8[0] :
9394: (p & 1) == 0 ?
9395: VideoController.vcnPal32G8[p] :
9396: VideoController.vcnPalTbl[
9397: VideoController.vcnMix2 (
9398: VideoController.vcnPal16G8[p & -2],
9399: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
9400: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1])]);
9401: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9402: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) <= 1 ?
9403: VideoController.vcnPal32G8[0] :
9404: (p & 1) == 0 ?
9405: VideoController.vcnPal32G8[p] :
9406: VideoController.vcnPalTbl[
9407: VideoController.vcnMix2 (
9408: VideoController.vcnPal16G8[p & -2],
9409: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
9410: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1])]);
9411: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9412: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) <= 1 ?
9413: VideoController.vcnPal32G8[0] :
9414: (p & 1) == 0 ?
9415: VideoController.vcnPal32G8[p] :
9416: VideoController.vcnPalTbl[
9417: VideoController.vcnMix2 (
9418: VideoController.vcnPal16G8[p & -2],
9419: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
9420: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1])]);
9421: gx1st += 16;
9422: gx2nd += 16;
9423: gx3rd += 16;
9424: gx4th += 16;
9425: da += 8;
9426: }
9427: }
9428: },
9429:
9430:
9431:
9432:
9433:
9434:
9435:
9436:
9437:
9438:
9439:
9440:
9441:
9442:
9443:
9444:
9445:
9446:
9447:
9448:
9449:
9450:
9451:
9452:
9453:
9454: F1_XHPGT {
9455: @Override public void drawRaster (int src, int dst) {
9456: int pn = VideoController.vcnReg2Curr & 3;
9457: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9458: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9459: pn = VideoController.vcnReg2Curr >> 2 & 3;
9460: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9461: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9462: pn = VideoController.vcnReg2Curr >> 4 & 3;
9463: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
9464: int gz3rd = VideoController.vcnHidden3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9465: pn = VideoController.vcnReg2Curr >> 6 & 3;
9466: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
9467: int gz4th = VideoController.vcnHidden4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9468: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9469: int db = da + XEiJ.pnlScreenWidth;
9470: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
9471: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9472: gx1st += half << 1;
9473: gx2nd += half << 1;
9474: gx3rd += half << 1;
9475: gx4th += half << 1;
9476: da += half;
9477: }
9478: while (da < db) {
9479: int p;
9480: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9481: MainMemory.mmrM8[gy1st | gx1st & 1023])) <= 1 ?
9482: VideoController.vcnPal32G8[0] :
9483: (p & 1) == 0 ?
9484: VideoController.vcnPal32G8[p] :
9485: VideoController.vcnPalTbl[
9486: VideoController.vcnMix2 (
9487: VideoController.vcnMix2 (
9488: VideoController.vcnPal16G8[p & -2],
9489: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
9490: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1]),
9491: 0)]);
9492: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9493: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) <= 1 ?
9494: VideoController.vcnPal32G8[0] :
9495: (p & 1) == 0 ?
9496: VideoController.vcnPal32G8[p] :
9497: VideoController.vcnPalTbl[
9498: VideoController.vcnMix2 (
9499: VideoController.vcnMix2 (
9500: VideoController.vcnPal16G8[p & -2],
9501: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
9502: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1]),
9503: 0)]);
9504: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9505: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) <= 1 ?
9506: VideoController.vcnPal32G8[0] :
9507: (p & 1) == 0 ?
9508: VideoController.vcnPal32G8[p] :
9509: VideoController.vcnPalTbl[
9510: VideoController.vcnMix2 (
9511: VideoController.vcnMix2 (
9512: VideoController.vcnPal16G8[p & -2],
9513: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
9514: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1]),
9515: 0)]);
9516: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9517: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) <= 1 ?
9518: VideoController.vcnPal32G8[0] :
9519: (p & 1) == 0 ?
9520: VideoController.vcnPal32G8[p] :
9521: VideoController.vcnPalTbl[
9522: VideoController.vcnMix2 (
9523: VideoController.vcnMix2 (
9524: VideoController.vcnPal16G8[p & -2],
9525: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
9526: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1]),
9527: 0)]);
9528: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9529: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) <= 1 ?
9530: VideoController.vcnPal32G8[0] :
9531: (p & 1) == 0 ?
9532: VideoController.vcnPal32G8[p] :
9533: VideoController.vcnPalTbl[
9534: VideoController.vcnMix2 (
9535: VideoController.vcnMix2 (
9536: VideoController.vcnPal16G8[p & -2],
9537: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
9538: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1]),
9539: 0)]);
9540: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9541: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) <= 1 ?
9542: VideoController.vcnPal32G8[0] :
9543: (p & 1) == 0 ?
9544: VideoController.vcnPal32G8[p] :
9545: VideoController.vcnPalTbl[
9546: VideoController.vcnMix2 (
9547: VideoController.vcnMix2 (
9548: VideoController.vcnPal16G8[p & -2],
9549: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
9550: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1]),
9551: 0)]);
9552: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9553: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) <= 1 ?
9554: VideoController.vcnPal32G8[0] :
9555: (p & 1) == 0 ?
9556: VideoController.vcnPal32G8[p] :
9557: VideoController.vcnPalTbl[
9558: VideoController.vcnMix2 (
9559: VideoController.vcnMix2 (
9560: VideoController.vcnPal16G8[p & -2],
9561: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
9562: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1]),
9563: 0)]);
9564: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9565: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) <= 1 ?
9566: VideoController.vcnPal32G8[0] :
9567: (p & 1) == 0 ?
9568: VideoController.vcnPal32G8[p] :
9569: VideoController.vcnPalTbl[
9570: VideoController.vcnMix2 (
9571: VideoController.vcnMix2 (
9572: VideoController.vcnPal16G8[p & -2],
9573: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
9574: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1]),
9575: 0)]);
9576: gx1st += 16;
9577: gx2nd += 16;
9578: gx3rd += 16;
9579: gx4th += 16;
9580: da += 8;
9581: }
9582: }
9583: },
9584:
9585:
9586:
9587:
9588:
9589:
9590:
9591:
9592:
9593:
9594:
9595:
9596:
9597:
9598:
9599:
9600:
9601:
9602:
9603:
9604: F1_A {
9605: @Override public void drawRaster (int src, int dst) {
9606: int pn = VideoController.vcnReg2Curr & 3;
9607: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9608: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9609: pn = VideoController.vcnReg2Curr >> 2 & 3;
9610: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9611: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9612: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9613: int db = da + XEiJ.pnlScreenWidth;
9614: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
9615: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9616: gx1st += half << 1;
9617: gx2nd += half << 1;
9618: da += half;
9619: }
9620: while (da < db) {
9621: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
9622: VideoController.vcnMix2 (
9623: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9624: MainMemory.mmrM8[gy1st | gx1st & 1023])],
9625: VideoController.vcnPal16TS[0])]);
9626: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
9627: VideoController.vcnMix2 (
9628: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9629: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])],
9630: VideoController.vcnPal16TS[0])]);
9631: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
9632: VideoController.vcnMix2 (
9633: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9634: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])],
9635: VideoController.vcnPal16TS[0])]);
9636: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
9637: VideoController.vcnMix2 (
9638: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9639: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])],
9640: VideoController.vcnPal16TS[0])]);
9641: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
9642: VideoController.vcnMix2 (
9643: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9644: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])],
9645: VideoController.vcnPal16TS[0])]);
9646: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
9647: VideoController.vcnMix2 (
9648: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9649: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])],
9650: VideoController.vcnPal16TS[0])]);
9651: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
9652: VideoController.vcnMix2 (
9653: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9654: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])],
9655: VideoController.vcnPal16TS[0])]);
9656: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
9657: VideoController.vcnMix2 (
9658: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9659: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])],
9660: VideoController.vcnPal16TS[0])]);
9661: gx1st += 16;
9662: gx2nd += 16;
9663: da += 8;
9664: }
9665: }
9666: },
9667:
9668:
9669:
9670:
9671:
9672:
9673:
9674:
9675:
9676:
9677:
9678:
9679:
9680:
9681:
9682:
9683:
9684:
9685:
9686:
9687:
9688:
9689:
9690: F2 {
9691: @Override public void drawRaster (int src, int dst) {
9692: int pn = VideoController.vcnReg2Curr & 3;
9693: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9694: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9695: pn = VideoController.vcnReg2Curr >> 2 & 3;
9696: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9697: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9698: pn = VideoController.vcnReg2Curr >> 4 & 3;
9699: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
9700: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9701: pn = VideoController.vcnReg2Curr >> 6 & 3;
9702: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
9703: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9704: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9705: int db = da + XEiJ.pnlScreenWidth;
9706: if (CRTC.crtBeginningAllStamp != CRTC.crtAllStamp) {
9707: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9708: gx1st += half << 1;
9709: gx2nd += half << 1;
9710: gx3rd += half << 1;
9711: gx4th += half << 1;
9712: da += half;
9713: }
9714: while (da < db) {
9715: int p;
9716: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9717: MainMemory.mmrM8[gy1st | gx1st & 1023])) != 0 ?
9718: VideoController.vcnPal32G8[p] :
9719: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th & 1023] << 4 |
9720: MainMemory.mmrM8[gy3rd | gx3rd & 1023])]);
9721: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9722: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) != 0 ?
9723: VideoController.vcnPal32G8[p] :
9724: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] << 4 |
9725: MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023])]);
9726: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9727: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) != 0 ?
9728: VideoController.vcnPal32G8[p] :
9729: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] << 4 |
9730: MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023])]);
9731: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9732: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) != 0 ?
9733: VideoController.vcnPal32G8[p] :
9734: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] << 4 |
9735: MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023])]);
9736: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9737: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) != 0 ?
9738: VideoController.vcnPal32G8[p] :
9739: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] << 4 |
9740: MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023])]);
9741: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9742: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) != 0 ?
9743: VideoController.vcnPal32G8[p] :
9744: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] << 4 |
9745: MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023])]);
9746: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9747: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) != 0 ?
9748: VideoController.vcnPal32G8[p] :
9749: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] << 4 |
9750: MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023])]);
9751: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9752: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) != 0 ?
9753: VideoController.vcnPal32G8[p] :
9754: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] << 4 |
9755: MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023])]);
9756: gx1st += 16;
9757: gx2nd += 16;
9758: gx3rd += 16;
9759: gx4th += 16;
9760: da += 8;
9761: }
9762: }
9763: },
9764:
9765:
9766:
9767:
9768:
9769:
9770: XF2 {
9771: @Override public void drawRaster (int src, int dst) {
9772: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
9773:
9774: case 0b00010000:
9775: case 0b00010001:
9776: case 0b00010010:
9777: case 0b00010011:
9778: F2.drawRaster (src, dst);
9779: break;
9780:
9781: case 0b00010100:
9782: case 0b00010101:
9783: case 0b00010110:
9784: case 0b00010111:
9785: F2_XWP.drawRaster (src, dst);
9786: