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, boolean rh) {
1413: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
1414: int db = da + XEiJ.pnlScreenWidth;
1415: if (rh) {
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, boolean rh) {
1440: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
1441:
1442: case 0b00010000:
1443: case 0b00010001:
1444: case 0b00010010:
1445: case 0b00010011:
1446: N.drawRaster (src, dst, rh);
1447: break;
1448:
1449: case 0b00010100:
1450: case 0b00010101:
1451: case 0b00010110:
1452: case 0b00010111:
1453: N.drawRaster (src, dst, rh);
1454: break;
1455:
1456: case 0b00011000:
1457: N.drawRaster (src, dst, rh);
1458: break;
1459:
1460: case 0b00011001:
1461: N.drawRaster (src, dst, rh);
1462: break;
1463:
1464: case 0b00011010:
1465: N.drawRaster (src, dst, rh);
1466: break;
1467:
1468: case 0b00011011:
1469: N.drawRaster (src, dst, rh);
1470: break;
1471:
1472: case 0b00011101:
1473: N.drawRaster (src, dst, rh);
1474: break;
1475:
1476: case 0b00011110:
1477: N.drawRaster (src, dst, rh);
1478: break;
1479:
1480: case 0b00011111:
1481: N.drawRaster (src, dst, rh);
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, rh);
1517: break;
1518: default:
1519: N.drawRaster (src, dst, rh);
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, boolean rh) {
1546: SpriteScreen.sprStep3 ();
1547: int sx = 16;
1548: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
1549: int db = da + XEiJ.pnlScreenWidth;
1550: if (rh) {
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, boolean rh) {
1577: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
1578:
1579: case 0b00010000:
1580: case 0b00010001:
1581: case 0b00010010:
1582: case 0b00010011:
1583: S.drawRaster (src, dst, rh);
1584: break;
1585:
1586: case 0b00010100:
1587: case 0b00010101:
1588: case 0b00010110:
1589: case 0b00010111:
1590: S.drawRaster (src, dst, rh);
1591: break;
1592:
1593: case 0b00011000:
1594: S.drawRaster (src, dst, rh);
1595: break;
1596:
1597: case 0b00011001:
1598: S.drawRaster (src, dst, rh);
1599: break;
1600:
1601: case 0b00011010:
1602: S.drawRaster (src, dst, rh);
1603: break;
1604:
1605: case 0b00011011:
1606: S.drawRaster (src, dst, rh);
1607: break;
1608:
1609: case 0b00011101:
1610: S.drawRaster (src, dst, rh);
1611: break;
1612:
1613: case 0b00011110:
1614: S.drawRaster (src, dst, rh);
1615: break;
1616:
1617: case 0b00011111:
1618: S.drawRaster (src, dst, rh);
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, rh);
1654: break;
1655: default:
1656: S.drawRaster (src, dst, rh);
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, boolean rh) {
1683: int ty = CRTC.crtR11TxYZero + src & 1023;
1684: int tc = (ty & CRTC.crtMask3) << 7 | CRTC.crtR10TxXCurr >> 3;
1685: int ta0 = 0x00e00000 + ((ty & CRTC.crtMaskMinus4) << 7);
1686: int ta1 = 0x00020000 + ta0;
1687: int ta2 = 0x00040000 + ta0;
1688: int ta3 = 0x00060000 + ta0;
1689: int ts = CRTC.crtR10TxXCurr & 7;
1690: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
1691: int db = da + XEiJ.pnlScreenWidth;
1692: if (rh) {
1693: int half = XEiJ.pnlScreenWidth >> 4 << 3;
1694: tc = tc + (half >> 3) & CRTC.crtMask511;
1695: da += half;
1696: }
1697: if (ts == 0) {
1698: while (da < db) {
1699: int tp = (VideoController.VCN_TXP3[MainMemory.mmrM8[ta3 + tc] & 255] |
1700: VideoController.VCN_TXP2[MainMemory.mmrM8[ta2 + tc] & 255] |
1701: VideoController.VCN_TXP1[MainMemory.mmrM8[ta1 + tc] & 255] |
1702: VideoController.VCN_TXP0[MainMemory.mmrM8[ta0 + tc] & 255]);
1703: tc = tc + 1 & CRTC.crtMask511;
1704: XEiJ.pnlBM[da] = (VideoController.vcnPal32TS[tp >>> 28]);
1705: XEiJ.pnlBM[da + 1] = (VideoController.vcnPal32TS[tp >>> 24 & 15]);
1706: XEiJ.pnlBM[da + 2] = (VideoController.vcnPal32TS[tp >>> 20 & 15]);
1707: XEiJ.pnlBM[da + 3] = (VideoController.vcnPal32TS[tp >>> 16 & 15]);
1708: XEiJ.pnlBM[da + 4] = (VideoController.vcnPal32TS[tp >>> 12 & 15]);
1709: XEiJ.pnlBM[da + 5] = (VideoController.vcnPal32TS[tp >>> 8 & 15]);
1710: XEiJ.pnlBM[da + 6] = (VideoController.vcnPal32TS[tp >>> 4 & 15]);
1711: XEiJ.pnlBM[da + 7] = (VideoController.vcnPal32TS[tp & 15]);
1712: da += 8;
1713: }
1714: } else {
1715:
1716: int tt = ts + 8;
1717: ts += 16;
1718:
1719: int p0 = MainMemory.mmrM8[ta0 + tc] << ts;
1720: int p1 = MainMemory.mmrM8[ta1 + tc] << ts;
1721: int p2 = MainMemory.mmrM8[ta2 + tc] << ts;
1722: int p3 = MainMemory.mmrM8[ta3 + tc] << ts;
1723: tc = tc + 1 & CRTC.crtMask511;
1724: while (da < db) {
1725:
1726:
1727: p0 = (p0 >> tt | MainMemory.mmrM8[ta0 + tc] & 255) << ts;
1728: p1 = (p1 >> tt | MainMemory.mmrM8[ta1 + tc] & 255) << ts;
1729: p2 = (p2 >> tt | MainMemory.mmrM8[ta2 + tc] & 255) << ts;
1730: p3 = (p3 >> tt | MainMemory.mmrM8[ta3 + tc] & 255) << ts;
1731: int tp = (VideoController.VCN_TXP3[p3 >>> 24] |
1732: VideoController.VCN_TXP2[p2 >>> 24] |
1733: VideoController.VCN_TXP1[p1 >>> 24] |
1734: VideoController.VCN_TXP0[p0 >>> 24]);
1735: tc = tc + 1 & CRTC.crtMask511;
1736: XEiJ.pnlBM[da] = (VideoController.vcnPal32TS[tp >>> 28]);
1737: XEiJ.pnlBM[da + 1] = (VideoController.vcnPal32TS[tp >>> 24 & 15]);
1738: XEiJ.pnlBM[da + 2] = (VideoController.vcnPal32TS[tp >>> 20 & 15]);
1739: XEiJ.pnlBM[da + 3] = (VideoController.vcnPal32TS[tp >>> 16 & 15]);
1740: XEiJ.pnlBM[da + 4] = (VideoController.vcnPal32TS[tp >>> 12 & 15]);
1741: XEiJ.pnlBM[da + 5] = (VideoController.vcnPal32TS[tp >>> 8 & 15]);
1742: XEiJ.pnlBM[da + 6] = (VideoController.vcnPal32TS[tp >>> 4 & 15]);
1743: XEiJ.pnlBM[da + 7] = (VideoController.vcnPal32TS[tp & 15]);
1744: da += 8;
1745: }
1746: }
1747: }
1748: },
1749:
1750:
1751:
1752:
1753:
1754:
1755: XT {
1756: @Override public void drawRaster (int src, int dst, boolean rh) {
1757: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
1758:
1759: case 0b00010000:
1760: case 0b00010001:
1761: case 0b00010010:
1762: case 0b00010011:
1763: T.drawRaster (src, dst, rh);
1764: break;
1765:
1766: case 0b00010100:
1767: case 0b00010101:
1768: case 0b00010110:
1769: case 0b00010111:
1770: T.drawRaster (src, dst, rh);
1771: break;
1772:
1773: case 0b00011000:
1774: T.drawRaster (src, dst, rh);
1775: break;
1776:
1777: case 0b00011001:
1778: T.drawRaster (src, dst, rh);
1779: break;
1780:
1781: case 0b00011010:
1782: T.drawRaster (src, dst, rh);
1783: break;
1784:
1785: case 0b00011011:
1786: T.drawRaster (src, dst, rh);
1787: break;
1788:
1789: case 0b00011101:
1790: T.drawRaster (src, dst, rh);
1791: break;
1792:
1793: case 0b00011110:
1794: T.drawRaster (src, dst, rh);
1795: break;
1796:
1797: case 0b00011111:
1798: T.drawRaster (src, dst, rh);
1799: break;
1800:
1801: case 0b01000000:
1802: case 0b01000001:
1803: case 0b01000010:
1804: case 0b01000011:
1805: case 0b01000100:
1806: case 0b01000101:
1807: case 0b01000110:
1808: case 0b01000111:
1809: case 0b01001000:
1810: case 0b01001001:
1811: case 0b01001010:
1812: case 0b01001011:
1813: case 0b01001100:
1814: case 0b01001101:
1815: case 0b01001110:
1816: case 0b01001111:
1817: case 0b01010000:
1818: case 0b01010001:
1819: case 0b01010010:
1820: case 0b01010011:
1821: case 0b01010100:
1822: case 0b01010101:
1823: case 0b01010110:
1824: case 0b01010111:
1825: case 0b01011000:
1826: case 0b01011001:
1827: case 0b01011010:
1828: case 0b01011011:
1829: case 0b01011100:
1830: case 0b01011101:
1831: case 0b01011110:
1832: case 0b01011111:
1833: N.drawRaster (src, dst, rh);
1834: break;
1835: default:
1836: T.drawRaster (src, dst, rh);
1837: VideoController.vcnReportUnimplemented (XT);
1838: }
1839: }
1840: },
1841:
1842:
1843:
1844:
1845:
1846:
1847:
1848:
1849:
1850:
1851:
1852:
1853:
1854:
1855:
1856:
1857:
1858:
1859:
1860:
1861:
1862:
1863:
1864: ST {
1865: @Override public void drawRaster (int src, int dst, boolean rh) {
1866: SpriteScreen.sprStep3 ();
1867: int sx = 16;
1868: int ty = CRTC.crtR11TxYZero + src & 1023;
1869: int tc = (ty & CRTC.crtMask3) << 7 | CRTC.crtR10TxXCurr >> 3;
1870: int ta0 = 0x00e00000 + ((ty & CRTC.crtMaskMinus4) << 7);
1871: int ta1 = 0x00020000 + ta0;
1872: int ta2 = 0x00040000 + ta0;
1873: int ta3 = 0x00060000 + ta0;
1874: int ts = CRTC.crtR10TxXCurr & 7;
1875: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
1876: int db = da + XEiJ.pnlScreenWidth;
1877: if (rh) {
1878: int half = XEiJ.pnlScreenWidth >> 4 << 3;
1879: sx += half;
1880: tc = tc + (half >> 3) & CRTC.crtMask511;
1881: da += half;
1882: }
1883: if (ts == 0) {
1884: while (da < db) {
1885: int tp = (VideoController.VCN_TXP3[MainMemory.mmrM8[ta3 + tc] & 255] |
1886: VideoController.VCN_TXP2[MainMemory.mmrM8[ta2 + tc] & 255] |
1887: VideoController.VCN_TXP1[MainMemory.mmrM8[ta1 + tc] & 255] |
1888: VideoController.VCN_TXP0[MainMemory.mmrM8[ta0 + tc] & 255]);
1889: tc = tc + 1 & CRTC.crtMask511;
1890: int p, q;
1891: XEiJ.pnlBM[da] = (((p = SpriteScreen.sprBuffer[sx]) & 15) != 0 || (q = tp >>> 28) == 0 ?
1892: VideoController.vcnPal32TS[p] :
1893: VideoController.vcnPal32TS[q]);
1894: XEiJ.pnlBM[da + 1] = (((p = SpriteScreen.sprBuffer[sx + 1]) & 15) != 0 || (q = tp >>> 24 & 15) == 0 ?
1895: VideoController.vcnPal32TS[p] :
1896: VideoController.vcnPal32TS[q]);
1897: XEiJ.pnlBM[da + 2] = (((p = SpriteScreen.sprBuffer[sx + 2]) & 15) != 0 || (q = tp >>> 20 & 15) == 0 ?
1898: VideoController.vcnPal32TS[p] :
1899: VideoController.vcnPal32TS[q]);
1900: XEiJ.pnlBM[da + 3] = (((p = SpriteScreen.sprBuffer[sx + 3]) & 15) != 0 || (q = tp >>> 16 & 15) == 0 ?
1901: VideoController.vcnPal32TS[p] :
1902: VideoController.vcnPal32TS[q]);
1903: XEiJ.pnlBM[da + 4] = (((p = SpriteScreen.sprBuffer[sx + 4]) & 15) != 0 || (q = tp >>> 12 & 15) == 0 ?
1904: VideoController.vcnPal32TS[p] :
1905: VideoController.vcnPal32TS[q]);
1906: XEiJ.pnlBM[da + 5] = (((p = SpriteScreen.sprBuffer[sx + 5]) & 15) != 0 || (q = tp >>> 8 & 15) == 0 ?
1907: VideoController.vcnPal32TS[p] :
1908: VideoController.vcnPal32TS[q]);
1909: XEiJ.pnlBM[da + 6] = (((p = SpriteScreen.sprBuffer[sx + 6]) & 15) != 0 || (q = tp >>> 4 & 15) == 0 ?
1910: VideoController.vcnPal32TS[p] :
1911: VideoController.vcnPal32TS[q]);
1912: XEiJ.pnlBM[da + 7] = (((p = SpriteScreen.sprBuffer[sx + 7]) & 15) != 0 || (q = tp & 15) == 0 ?
1913: VideoController.vcnPal32TS[p] :
1914: VideoController.vcnPal32TS[q]);
1915: sx += 8;
1916: da += 8;
1917: }
1918: } else {
1919:
1920: int tt = ts + 8;
1921: ts += 16;
1922:
1923: int p0 = MainMemory.mmrM8[ta0 + tc] << ts;
1924: int p1 = MainMemory.mmrM8[ta1 + tc] << ts;
1925: int p2 = MainMemory.mmrM8[ta2 + tc] << ts;
1926: int p3 = MainMemory.mmrM8[ta3 + tc] << ts;
1927: tc = tc + 1 & CRTC.crtMask511;
1928: while (da < db) {
1929:
1930:
1931: p0 = (p0 >> tt | MainMemory.mmrM8[ta0 + tc] & 255) << ts;
1932: p1 = (p1 >> tt | MainMemory.mmrM8[ta1 + tc] & 255) << ts;
1933: p2 = (p2 >> tt | MainMemory.mmrM8[ta2 + tc] & 255) << ts;
1934: p3 = (p3 >> tt | MainMemory.mmrM8[ta3 + tc] & 255) << ts;
1935: int tp = (VideoController.VCN_TXP3[p3 >>> 24] |
1936: VideoController.VCN_TXP2[p2 >>> 24] |
1937: VideoController.VCN_TXP1[p1 >>> 24] |
1938: VideoController.VCN_TXP0[p0 >>> 24]);
1939: tc = tc + 1 & CRTC.crtMask511;
1940: int p, q;
1941: XEiJ.pnlBM[da] = (((p = SpriteScreen.sprBuffer[sx]) & 15) != 0 || (q = tp >>> 28) == 0 ?
1942: VideoController.vcnPal32TS[p] :
1943: VideoController.vcnPal32TS[q]);
1944: XEiJ.pnlBM[da + 1] = (((p = SpriteScreen.sprBuffer[sx + 1]) & 15) != 0 || (q = tp >>> 24 & 15) == 0 ?
1945: VideoController.vcnPal32TS[p] :
1946: VideoController.vcnPal32TS[q]);
1947: XEiJ.pnlBM[da + 2] = (((p = SpriteScreen.sprBuffer[sx + 2]) & 15) != 0 || (q = tp >>> 20 & 15) == 0 ?
1948: VideoController.vcnPal32TS[p] :
1949: VideoController.vcnPal32TS[q]);
1950: XEiJ.pnlBM[da + 3] = (((p = SpriteScreen.sprBuffer[sx + 3]) & 15) != 0 || (q = tp >>> 16 & 15) == 0 ?
1951: VideoController.vcnPal32TS[p] :
1952: VideoController.vcnPal32TS[q]);
1953: XEiJ.pnlBM[da + 4] = (((p = SpriteScreen.sprBuffer[sx + 4]) & 15) != 0 || (q = tp >>> 12 & 15) == 0 ?
1954: VideoController.vcnPal32TS[p] :
1955: VideoController.vcnPal32TS[q]);
1956: XEiJ.pnlBM[da + 5] = (((p = SpriteScreen.sprBuffer[sx + 5]) & 15) != 0 || (q = tp >>> 8 & 15) == 0 ?
1957: VideoController.vcnPal32TS[p] :
1958: VideoController.vcnPal32TS[q]);
1959: XEiJ.pnlBM[da + 6] = (((p = SpriteScreen.sprBuffer[sx + 6]) & 15) != 0 || (q = tp >>> 4 & 15) == 0 ?
1960: VideoController.vcnPal32TS[p] :
1961: VideoController.vcnPal32TS[q]);
1962: XEiJ.pnlBM[da + 7] = (((p = SpriteScreen.sprBuffer[sx + 7]) & 15) != 0 || (q = tp & 15) == 0 ?
1963: VideoController.vcnPal32TS[p] :
1964: VideoController.vcnPal32TS[q]);
1965: sx += 8;
1966: da += 8;
1967: }
1968: }
1969: }
1970: },
1971:
1972:
1973:
1974:
1975:
1976:
1977: XST {
1978: @Override public void drawRaster (int src, int dst, boolean rh) {
1979: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
1980:
1981: case 0b00010000:
1982: case 0b00010001:
1983: case 0b00010010:
1984: case 0b00010011:
1985: ST.drawRaster (src, dst, rh);
1986: break;
1987:
1988: case 0b00010100:
1989: case 0b00010101:
1990: case 0b00010110:
1991: case 0b00010111:
1992: ST.drawRaster (src, dst, rh);
1993: break;
1994:
1995: case 0b00011000:
1996: ST.drawRaster (src, dst, rh);
1997: break;
1998:
1999: case 0b00011001:
2000: ST.drawRaster (src, dst, rh);
2001: break;
2002:
2003: case 0b00011010:
2004: ST.drawRaster (src, dst, rh);
2005: break;
2006:
2007: case 0b00011011:
2008: ST.drawRaster (src, dst, rh);
2009: break;
2010:
2011: case 0b00011101:
2012: ST.drawRaster (src, dst, rh);
2013: break;
2014:
2015: case 0b00011110:
2016: ST.drawRaster (src, dst, rh);
2017: break;
2018:
2019: case 0b00011111:
2020: ST.drawRaster (src, dst, rh);
2021: break;
2022:
2023: case 0b01000000:
2024: case 0b01000001:
2025: case 0b01000010:
2026: case 0b01000011:
2027: case 0b01000100:
2028: case 0b01000101:
2029: case 0b01000110:
2030: case 0b01000111:
2031: case 0b01001000:
2032: case 0b01001001:
2033: case 0b01001010:
2034: case 0b01001011:
2035: case 0b01001100:
2036: case 0b01001101:
2037: case 0b01001110:
2038: case 0b01001111:
2039: case 0b01010000:
2040: case 0b01010001:
2041: case 0b01010010:
2042: case 0b01010011:
2043: case 0b01010100:
2044: case 0b01010101:
2045: case 0b01010110:
2046: case 0b01010111:
2047: case 0b01011000:
2048: case 0b01011001:
2049: case 0b01011010:
2050: case 0b01011011:
2051: case 0b01011100:
2052: case 0b01011101:
2053: case 0b01011110:
2054: case 0b01011111:
2055: N.drawRaster (src, dst, rh);
2056: break;
2057: default:
2058: ST.drawRaster (src, dst, rh);
2059: VideoController.vcnReportUnimplemented (XST);
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:
2085:
2086: TS {
2087: @Override public void drawRaster (int src, int dst, boolean rh) {
2088: SpriteScreen.sprStep3 ();
2089: int sx = 16;
2090: int ty = CRTC.crtR11TxYZero + src & 1023;
2091: int tc = (ty & CRTC.crtMask3) << 7 | CRTC.crtR10TxXCurr >> 3;
2092: int ta0 = 0x00e00000 + ((ty & CRTC.crtMaskMinus4) << 7);
2093: int ta1 = 0x00020000 + ta0;
2094: int ta2 = 0x00040000 + ta0;
2095: int ta3 = 0x00060000 + ta0;
2096: int ts = CRTC.crtR10TxXCurr & 7;
2097: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2098: int db = da + XEiJ.pnlScreenWidth;
2099: if (rh) {
2100: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2101: sx += half;
2102: tc = tc + (half >> 3) & CRTC.crtMask511;
2103: da += half;
2104: }
2105: if (ts == 0) {
2106: while (da < db) {
2107: int tp = (VideoController.VCN_TXP3[MainMemory.mmrM8[ta3 + tc] & 255] |
2108: VideoController.VCN_TXP2[MainMemory.mmrM8[ta2 + tc] & 255] |
2109: VideoController.VCN_TXP1[MainMemory.mmrM8[ta1 + tc] & 255] |
2110: VideoController.VCN_TXP0[MainMemory.mmrM8[ta0 + tc] & 255]);
2111: tc = tc + 1 & CRTC.crtMask511;
2112: int p;
2113: XEiJ.pnlBM[da] = ((p = tp >>> 28) != 0 ?
2114: VideoController.vcnPal32TS[p] :
2115: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx]]);
2116: XEiJ.pnlBM[da + 1] = ((p = tp >>> 24 & 15) != 0 ?
2117: VideoController.vcnPal32TS[p] :
2118: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 1]]);
2119: XEiJ.pnlBM[da + 2] = ((p = tp >>> 20 & 15) != 0 ?
2120: VideoController.vcnPal32TS[p] :
2121: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 2]]);
2122: XEiJ.pnlBM[da + 3] = ((p = tp >>> 16 & 15) != 0 ?
2123: VideoController.vcnPal32TS[p] :
2124: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 3]]);
2125: XEiJ.pnlBM[da + 4] = ((p = tp >>> 12 & 15) != 0 ?
2126: VideoController.vcnPal32TS[p] :
2127: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 4]]);
2128: XEiJ.pnlBM[da + 5] = ((p = tp >>> 8 & 15) != 0 ?
2129: VideoController.vcnPal32TS[p] :
2130: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 5]]);
2131: XEiJ.pnlBM[da + 6] = ((p = tp >>> 4 & 15) != 0 ?
2132: VideoController.vcnPal32TS[p] :
2133: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 6]]);
2134: XEiJ.pnlBM[da + 7] = ((p = tp & 15) != 0 ?
2135: VideoController.vcnPal32TS[p] :
2136: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 7]]);
2137: sx += 8;
2138: da += 8;
2139: }
2140: } else {
2141:
2142: int tt = ts + 8;
2143: ts += 16;
2144:
2145: int p0 = MainMemory.mmrM8[ta0 + tc] << ts;
2146: int p1 = MainMemory.mmrM8[ta1 + tc] << ts;
2147: int p2 = MainMemory.mmrM8[ta2 + tc] << ts;
2148: int p3 = MainMemory.mmrM8[ta3 + tc] << ts;
2149: tc = tc + 1 & CRTC.crtMask511;
2150: while (da < db) {
2151:
2152:
2153: p0 = (p0 >> tt | MainMemory.mmrM8[ta0 + tc] & 255) << ts;
2154: p1 = (p1 >> tt | MainMemory.mmrM8[ta1 + tc] & 255) << ts;
2155: p2 = (p2 >> tt | MainMemory.mmrM8[ta2 + tc] & 255) << ts;
2156: p3 = (p3 >> tt | MainMemory.mmrM8[ta3 + tc] & 255) << ts;
2157: int tp = (VideoController.VCN_TXP3[p3 >>> 24] |
2158: VideoController.VCN_TXP2[p2 >>> 24] |
2159: VideoController.VCN_TXP1[p1 >>> 24] |
2160: VideoController.VCN_TXP0[p0 >>> 24]);
2161: tc = tc + 1 & CRTC.crtMask511;
2162: int p;
2163: XEiJ.pnlBM[da] = ((p = tp >>> 28) != 0 ?
2164: VideoController.vcnPal32TS[p] :
2165: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx]]);
2166: XEiJ.pnlBM[da + 1] = ((p = tp >>> 24 & 15) != 0 ?
2167: VideoController.vcnPal32TS[p] :
2168: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 1]]);
2169: XEiJ.pnlBM[da + 2] = ((p = tp >>> 20 & 15) != 0 ?
2170: VideoController.vcnPal32TS[p] :
2171: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 2]]);
2172: XEiJ.pnlBM[da + 3] = ((p = tp >>> 16 & 15) != 0 ?
2173: VideoController.vcnPal32TS[p] :
2174: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 3]]);
2175: XEiJ.pnlBM[da + 4] = ((p = tp >>> 12 & 15) != 0 ?
2176: VideoController.vcnPal32TS[p] :
2177: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 4]]);
2178: XEiJ.pnlBM[da + 5] = ((p = tp >>> 8 & 15) != 0 ?
2179: VideoController.vcnPal32TS[p] :
2180: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 5]]);
2181: XEiJ.pnlBM[da + 6] = ((p = tp >>> 4 & 15) != 0 ?
2182: VideoController.vcnPal32TS[p] :
2183: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 6]]);
2184: XEiJ.pnlBM[da + 7] = ((p = tp & 15) != 0 ?
2185: VideoController.vcnPal32TS[p] :
2186: VideoController.vcnPal32TS[SpriteScreen.sprBuffer[sx + 7]]);
2187: sx += 8;
2188: da += 8;
2189: }
2190: }
2191: }
2192: },
2193:
2194:
2195:
2196:
2197:
2198:
2199: XTS {
2200: @Override public void drawRaster (int src, int dst, boolean rh) {
2201: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
2202:
2203: case 0b00010000:
2204: case 0b00010001:
2205: case 0b00010010:
2206: case 0b00010011:
2207: TS.drawRaster (src, dst, rh);
2208: break;
2209:
2210: case 0b00010100:
2211: case 0b00010101:
2212: case 0b00010110:
2213: case 0b00010111:
2214: TS.drawRaster (src, dst, rh);
2215: break;
2216:
2217: case 0b00011000:
2218: TS.drawRaster (src, dst, rh);
2219: break;
2220:
2221: case 0b00011001:
2222: TS.drawRaster (src, dst, rh);
2223: break;
2224:
2225: case 0b00011010:
2226: TS.drawRaster (src, dst, rh);
2227: break;
2228:
2229: case 0b00011011:
2230: TS.drawRaster (src, dst, rh);
2231: break;
2232:
2233: case 0b00011101:
2234: TS.drawRaster (src, dst, rh);
2235: break;
2236:
2237: case 0b00011110:
2238: TS.drawRaster (src, dst, rh);
2239: break;
2240:
2241: case 0b00011111:
2242: TS.drawRaster (src, dst, rh);
2243: break;
2244:
2245: case 0b01000000:
2246: case 0b01000001:
2247: case 0b01000010:
2248: case 0b01000011:
2249: case 0b01000100:
2250: case 0b01000101:
2251: case 0b01000110:
2252: case 0b01000111:
2253: case 0b01001000:
2254: case 0b01001001:
2255: case 0b01001010:
2256: case 0b01001011:
2257: case 0b01001100:
2258: case 0b01001101:
2259: case 0b01001110:
2260: case 0b01001111:
2261: case 0b01010000:
2262: case 0b01010001:
2263: case 0b01010010:
2264: case 0b01010011:
2265: case 0b01010100:
2266: case 0b01010101:
2267: case 0b01010110:
2268: case 0b01010111:
2269: case 0b01011000:
2270: case 0b01011001:
2271: case 0b01011010:
2272: case 0b01011011:
2273: case 0b01011100:
2274: case 0b01011101:
2275: case 0b01011110:
2276: case 0b01011111:
2277: N.drawRaster (src, dst, rh);
2278: break;
2279: default:
2280: TS.drawRaster (src, dst, rh);
2281: VideoController.vcnReportUnimplemented (XTS);
2282: }
2283: }
2284: },
2285:
2286:
2287:
2288:
2289:
2290:
2291:
2292:
2293:
2294:
2295:
2296:
2297:
2298:
2299:
2300:
2301:
2302:
2303:
2304:
2305: E1 {
2306: @Override public void drawRaster (int src, int dst, boolean rh) {
2307: int pn = VideoController.vcnReg2Curr & 3;
2308: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2309: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2310: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2311: int db = da + XEiJ.pnlScreenWidth;
2312: if (rh) {
2313: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2314: gx1st += half << 1;
2315: da += half;
2316: }
2317: while (da < db) {
2318: XEiJ.pnlBM[da] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st & 1023]]);
2319: XEiJ.pnlBM[da + 1] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]]);
2320: XEiJ.pnlBM[da + 2] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]]);
2321: XEiJ.pnlBM[da + 3] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]]);
2322: XEiJ.pnlBM[da + 4] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]]);
2323: XEiJ.pnlBM[da + 5] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]]);
2324: XEiJ.pnlBM[da + 6] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]]);
2325: XEiJ.pnlBM[da + 7] = (VideoController.vcnPal32G8[MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]]);
2326: gx1st += 16;
2327: da += 8;
2328: }
2329: }
2330: },
2331:
2332:
2333:
2334:
2335:
2336:
2337: XE1 {
2338: @Override public void drawRaster (int src, int dst, boolean rh) {
2339: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
2340:
2341: case 0b00010000:
2342: case 0b00010001:
2343: case 0b00010010:
2344: case 0b00010011:
2345: E1.drawRaster (src, dst, rh);
2346: break;
2347:
2348: case 0b00010100:
2349: case 0b00010101:
2350: case 0b00010110:
2351: case 0b00010111:
2352: E1_XWP.drawRaster (src, dst, rh);
2353: break;
2354:
2355: case 0b00011000:
2356: E1.drawRaster (src, dst, rh);
2357: break;
2358:
2359: case 0b00011001:
2360: E1_XHCT.drawRaster (src, dst, rh);
2361: break;
2362:
2363: case 0b00011010:
2364: E1_XHCG.drawRaster (src, dst, rh);
2365: break;
2366:
2367: case 0b00011011:
2368: E1_XHCGT.drawRaster (src, dst, rh);
2369: break;
2370:
2371: case 0b00011101:
2372: E1_XHPT.drawRaster (src, dst, rh);
2373: break;
2374:
2375: case 0b00011110:
2376: E1_XHPG.drawRaster (src, dst, rh);
2377: break;
2378:
2379: case 0b00011111:
2380: E1_XHPGT.drawRaster (src, dst, rh);
2381: break;
2382:
2383: case 0b01000000:
2384: case 0b01000001:
2385: case 0b01000010:
2386: case 0b01000011:
2387: case 0b01000100:
2388: case 0b01000101:
2389: case 0b01000110:
2390: case 0b01000111:
2391: case 0b01001000:
2392: case 0b01001001:
2393: case 0b01001010:
2394: case 0b01001011:
2395: case 0b01001100:
2396: case 0b01001101:
2397: case 0b01001110:
2398: case 0b01001111:
2399: case 0b01010000:
2400: case 0b01010001:
2401: case 0b01010010:
2402: case 0b01010011:
2403: case 0b01010100:
2404: case 0b01010101:
2405: case 0b01010110:
2406: case 0b01010111:
2407: case 0b01011000:
2408: case 0b01011001:
2409: case 0b01011010:
2410: case 0b01011011:
2411: case 0b01011100:
2412: case 0b01011101:
2413: case 0b01011110:
2414: case 0b01011111:
2415: E1_A.drawRaster (src, dst, rh);
2416: break;
2417: default:
2418: E1.drawRaster (src, dst, rh);
2419: VideoController.vcnReportUnimplemented (XE1);
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:
2446:
2447:
2448: E1_XWP {
2449: @Override public void drawRaster (int src, int dst, boolean rh) {
2450: int pn = VideoController.vcnReg2Curr & 3;
2451: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2452: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2453: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2454: int db = da + XEiJ.pnlScreenWidth;
2455: if (rh) {
2456: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2457: gx1st += half << 1;
2458: da += half;
2459: }
2460: while (da < db) {
2461: int p;
2462: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) <= 1 ?
2463: VideoController.vcnPal32G8[0] :
2464: (p & 1) == 0 ?
2465: VideoController.vcnPal32G8[p] :
2466: VideoController.vcnPal32G8[p & -2]);
2467: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) <= 1 ?
2468: VideoController.vcnPal32G8[0] :
2469: (p & 1) == 0 ?
2470: VideoController.vcnPal32G8[p] :
2471: VideoController.vcnPal32G8[p & -2]);
2472: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) <= 1 ?
2473: VideoController.vcnPal32G8[0] :
2474: (p & 1) == 0 ?
2475: VideoController.vcnPal32G8[p] :
2476: VideoController.vcnPal32G8[p & -2]);
2477: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) <= 1 ?
2478: VideoController.vcnPal32G8[0] :
2479: (p & 1) == 0 ?
2480: VideoController.vcnPal32G8[p] :
2481: VideoController.vcnPal32G8[p & -2]);
2482: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) <= 1 ?
2483: VideoController.vcnPal32G8[0] :
2484: (p & 1) == 0 ?
2485: VideoController.vcnPal32G8[p] :
2486: VideoController.vcnPal32G8[p & -2]);
2487: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) <= 1 ?
2488: VideoController.vcnPal32G8[0] :
2489: (p & 1) == 0 ?
2490: VideoController.vcnPal32G8[p] :
2491: VideoController.vcnPal32G8[p & -2]);
2492: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) <= 1 ?
2493: VideoController.vcnPal32G8[0] :
2494: (p & 1) == 0 ?
2495: VideoController.vcnPal32G8[p] :
2496: VideoController.vcnPal32G8[p & -2]);
2497: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) <= 1 ?
2498: VideoController.vcnPal32G8[0] :
2499: (p & 1) == 0 ?
2500: VideoController.vcnPal32G8[p] :
2501: VideoController.vcnPal32G8[p & -2]);
2502: gx1st += 16;
2503: da += 8;
2504: }
2505: }
2506: },
2507:
2508:
2509:
2510:
2511:
2512:
2513:
2514:
2515:
2516:
2517:
2518:
2519:
2520:
2521:
2522:
2523:
2524:
2525:
2526:
2527:
2528:
2529:
2530: E1_XHCT {
2531: @Override public void drawRaster (int src, int dst, boolean rh) {
2532: int pn = VideoController.vcnReg2Curr & 3;
2533: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2534: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2535: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2536: int db = da + XEiJ.pnlScreenWidth;
2537: if (rh) {
2538: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2539: gx1st += half << 1;
2540: da += half;
2541: }
2542: while (da < db) {
2543: int p;
2544: XEiJ.pnlBM[da] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st & 1023]) & -2] & 1) != 0 ?
2545: VideoController.vcnPalTbl[
2546: VideoController.vcnMix2 (
2547: VideoController.vcnPal16G8[p],
2548: 0)] :
2549: VideoController.vcnPal32G8[p]);
2550: XEiJ.pnlBM[da + 1] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) & -2] & 1) != 0 ?
2551: VideoController.vcnPalTbl[
2552: VideoController.vcnMix2 (
2553: VideoController.vcnPal16G8[p],
2554: 0)] :
2555: VideoController.vcnPal32G8[p]);
2556: XEiJ.pnlBM[da + 2] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) & -2] & 1) != 0 ?
2557: VideoController.vcnPalTbl[
2558: VideoController.vcnMix2 (
2559: VideoController.vcnPal16G8[p],
2560: 0)] :
2561: VideoController.vcnPal32G8[p]);
2562: XEiJ.pnlBM[da + 3] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) & -2] & 1) != 0 ?
2563: VideoController.vcnPalTbl[
2564: VideoController.vcnMix2 (
2565: VideoController.vcnPal16G8[p],
2566: 0)] :
2567: VideoController.vcnPal32G8[p]);
2568: XEiJ.pnlBM[da + 4] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) & -2] & 1) != 0 ?
2569: VideoController.vcnPalTbl[
2570: VideoController.vcnMix2 (
2571: VideoController.vcnPal16G8[p],
2572: 0)] :
2573: VideoController.vcnPal32G8[p]);
2574: XEiJ.pnlBM[da + 5] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) & -2] & 1) != 0 ?
2575: VideoController.vcnPalTbl[
2576: VideoController.vcnMix2 (
2577: VideoController.vcnPal16G8[p],
2578: 0)] :
2579: VideoController.vcnPal32G8[p]);
2580: XEiJ.pnlBM[da + 6] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) & -2] & 1) != 0 ?
2581: VideoController.vcnPalTbl[
2582: VideoController.vcnMix2 (
2583: VideoController.vcnPal16G8[p],
2584: 0)] :
2585: VideoController.vcnPal32G8[p]);
2586: XEiJ.pnlBM[da + 7] = ((VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) & -2] & 1) != 0 ?
2587: VideoController.vcnPalTbl[
2588: VideoController.vcnMix2 (
2589: VideoController.vcnPal16G8[p],
2590: 0)] :
2591: VideoController.vcnPal32G8[p]);
2592: gx1st += 16;
2593: da += 8;
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:
2621:
2622:
2623: E1_XHCG {
2624: @Override public void drawRaster (int src, int dst, boolean rh) {
2625: int pn = VideoController.vcnReg2Curr & 3;
2626: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2627: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2628: pn = VideoController.vcnReg2Curr >> 2 & 3;
2629: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
2630: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2631: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2632: int db = da + XEiJ.pnlScreenWidth;
2633: if (rh) {
2634: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2635: gx1st += half << 1;
2636: gx2nd += half << 1;
2637: da += half;
2638: }
2639: while (da < db) {
2640: int p, q;
2641: XEiJ.pnlBM[da] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st & 1023]) & -2]) & 1) != 0 ?
2642: VideoController.vcnPalTbl[
2643: VideoController.vcnMix2 (
2644: p,
2645: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
2646: (q & 1) != 0 ?
2647: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
2648: VideoController.vcnPal32G8[q]);
2649: XEiJ.pnlBM[da + 1] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) & -2]) & 1) != 0 ?
2650: VideoController.vcnPalTbl[
2651: VideoController.vcnMix2 (
2652: p,
2653: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
2654: (q & 1) != 0 ?
2655: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
2656: VideoController.vcnPal32G8[q]);
2657: XEiJ.pnlBM[da + 2] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) & -2]) & 1) != 0 ?
2658: VideoController.vcnPalTbl[
2659: VideoController.vcnMix2 (
2660: p,
2661: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
2662: (q & 1) != 0 ?
2663: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
2664: VideoController.vcnPal32G8[q]);
2665: XEiJ.pnlBM[da + 3] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) & -2]) & 1) != 0 ?
2666: VideoController.vcnPalTbl[
2667: VideoController.vcnMix2 (
2668: p,
2669: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
2670: (q & 1) != 0 ?
2671: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
2672: VideoController.vcnPal32G8[q]);
2673: XEiJ.pnlBM[da + 4] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) & -2]) & 1) != 0 ?
2674: VideoController.vcnPalTbl[
2675: VideoController.vcnMix2 (
2676: p,
2677: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
2678: (q & 1) != 0 ?
2679: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
2680: VideoController.vcnPal32G8[q]);
2681: XEiJ.pnlBM[da + 5] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) & -2]) & 1) != 0 ?
2682: VideoController.vcnPalTbl[
2683: VideoController.vcnMix2 (
2684: p,
2685: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
2686: (q & 1) != 0 ?
2687: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
2688: VideoController.vcnPal32G8[q]);
2689: XEiJ.pnlBM[da + 6] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) & -2]) & 1) != 0 ?
2690: VideoController.vcnPalTbl[
2691: VideoController.vcnMix2 (
2692: p,
2693: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
2694: (q & 1) != 0 ?
2695: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
2696: VideoController.vcnPal32G8[q]);
2697: XEiJ.pnlBM[da + 7] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) & -2]) & 1) != 0 ?
2698: VideoController.vcnPalTbl[
2699: VideoController.vcnMix2 (
2700: p,
2701: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
2702: (q & 1) != 0 ?
2703: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
2704: VideoController.vcnPal32G8[q]);
2705: gx1st += 16;
2706: gx2nd += 16;
2707: da += 8;
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:
2735:
2736:
2737: E1_XHCGT {
2738: @Override public void drawRaster (int src, int dst, boolean rh) {
2739: int pn = VideoController.vcnReg2Curr & 3;
2740: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2741: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2742: pn = VideoController.vcnReg2Curr >> 2 & 3;
2743: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
2744: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2745: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2746: int db = da + XEiJ.pnlScreenWidth;
2747: if (rh) {
2748: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2749: gx1st += half << 1;
2750: gx2nd += half << 1;
2751: da += half;
2752: }
2753: while (da < db) {
2754: int p, q;
2755: XEiJ.pnlBM[da] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st & 1023]) & -2]) & 1) != 0 ?
2756: VideoController.vcnPalTbl[
2757: VideoController.vcnMix2 (
2758: VideoController.vcnMix2 (
2759: p,
2760: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
2761: 0)] :
2762: (q & 1) != 0 ?
2763: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
2764: VideoController.vcnPal32G8[q]);
2765: XEiJ.pnlBM[da + 1] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) & -2]) & 1) != 0 ?
2766: VideoController.vcnPalTbl[
2767: VideoController.vcnMix2 (
2768: VideoController.vcnMix2 (
2769: p,
2770: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
2771: 0)] :
2772: (q & 1) != 0 ?
2773: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
2774: VideoController.vcnPal32G8[q]);
2775: XEiJ.pnlBM[da + 2] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) & -2]) & 1) != 0 ?
2776: VideoController.vcnPalTbl[
2777: VideoController.vcnMix2 (
2778: VideoController.vcnMix2 (
2779: p,
2780: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
2781: 0)] :
2782: (q & 1) != 0 ?
2783: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
2784: VideoController.vcnPal32G8[q]);
2785: XEiJ.pnlBM[da + 3] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) & -2]) & 1) != 0 ?
2786: VideoController.vcnPalTbl[
2787: VideoController.vcnMix2 (
2788: VideoController.vcnMix2 (
2789: p,
2790: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
2791: 0)] :
2792: (q & 1) != 0 ?
2793: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
2794: VideoController.vcnPal32G8[q]);
2795: XEiJ.pnlBM[da + 4] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) & -2]) & 1) != 0 ?
2796: VideoController.vcnPalTbl[
2797: VideoController.vcnMix2 (
2798: VideoController.vcnMix2 (
2799: p,
2800: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
2801: 0)] :
2802: (q & 1) != 0 ?
2803: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
2804: VideoController.vcnPal32G8[q]);
2805: XEiJ.pnlBM[da + 5] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) & -2]) & 1) != 0 ?
2806: VideoController.vcnPalTbl[
2807: VideoController.vcnMix2 (
2808: VideoController.vcnMix2 (
2809: p,
2810: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
2811: 0)] :
2812: (q & 1) != 0 ?
2813: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
2814: VideoController.vcnPal32G8[q]);
2815: XEiJ.pnlBM[da + 6] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) & -2]) & 1) != 0 ?
2816: VideoController.vcnPalTbl[
2817: VideoController.vcnMix2 (
2818: VideoController.vcnMix2 (
2819: p,
2820: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
2821: 0)] :
2822: (q & 1) != 0 ?
2823: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
2824: VideoController.vcnPal32G8[q]);
2825: XEiJ.pnlBM[da + 7] = (((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) & -2]) & 1) != 0 ?
2826: VideoController.vcnPalTbl[
2827: VideoController.vcnMix2 (
2828: VideoController.vcnMix2 (
2829: p,
2830: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
2831: 0)] :
2832: (q & 1) != 0 ?
2833: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
2834: VideoController.vcnPal32G8[q]);
2835: gx1st += 16;
2836: gx2nd += 16;
2837: da += 8;
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:
2864:
2865:
2866: E1_XHPT {
2867: @Override public void drawRaster (int src, int dst, boolean rh) {
2868: int pn = VideoController.vcnReg2Curr & 3;
2869: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2870: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2871: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2872: int db = da + XEiJ.pnlScreenWidth;
2873: if (rh) {
2874: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2875: gx1st += half << 1;
2876: da += half;
2877: }
2878: while (da < db) {
2879: int p;
2880: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) <= 1 ?
2881: VideoController.vcnPal32G8[0] :
2882: (p & 1) == 0 ?
2883: VideoController.vcnPal32G8[p] :
2884: VideoController.vcnPalTbl[
2885: VideoController.vcnMix2 (
2886: VideoController.vcnPal16G8[p & -2],
2887: 0)]);
2888: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) <= 1 ?
2889: VideoController.vcnPal32G8[0] :
2890: (p & 1) == 0 ?
2891: VideoController.vcnPal32G8[p] :
2892: VideoController.vcnPalTbl[
2893: VideoController.vcnMix2 (
2894: VideoController.vcnPal16G8[p & -2],
2895: 0)]);
2896: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) <= 1 ?
2897: VideoController.vcnPal32G8[0] :
2898: (p & 1) == 0 ?
2899: VideoController.vcnPal32G8[p] :
2900: VideoController.vcnPalTbl[
2901: VideoController.vcnMix2 (
2902: VideoController.vcnPal16G8[p & -2],
2903: 0)]);
2904: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) <= 1 ?
2905: VideoController.vcnPal32G8[0] :
2906: (p & 1) == 0 ?
2907: VideoController.vcnPal32G8[p] :
2908: VideoController.vcnPalTbl[
2909: VideoController.vcnMix2 (
2910: VideoController.vcnPal16G8[p & -2],
2911: 0)]);
2912: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) <= 1 ?
2913: VideoController.vcnPal32G8[0] :
2914: (p & 1) == 0 ?
2915: VideoController.vcnPal32G8[p] :
2916: VideoController.vcnPalTbl[
2917: VideoController.vcnMix2 (
2918: VideoController.vcnPal16G8[p & -2],
2919: 0)]);
2920: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) <= 1 ?
2921: VideoController.vcnPal32G8[0] :
2922: (p & 1) == 0 ?
2923: VideoController.vcnPal32G8[p] :
2924: VideoController.vcnPalTbl[
2925: VideoController.vcnMix2 (
2926: VideoController.vcnPal16G8[p & -2],
2927: 0)]);
2928: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) <= 1 ?
2929: VideoController.vcnPal32G8[0] :
2930: (p & 1) == 0 ?
2931: VideoController.vcnPal32G8[p] :
2932: VideoController.vcnPalTbl[
2933: VideoController.vcnMix2 (
2934: VideoController.vcnPal16G8[p & -2],
2935: 0)]);
2936: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) <= 1 ?
2937: VideoController.vcnPal32G8[0] :
2938: (p & 1) == 0 ?
2939: VideoController.vcnPal32G8[p] :
2940: VideoController.vcnPalTbl[
2941: VideoController.vcnMix2 (
2942: VideoController.vcnPal16G8[p & -2],
2943: 0)]);
2944: gx1st += 16;
2945: da += 8;
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:
2972:
2973:
2974: E1_XHPG {
2975: @Override public void drawRaster (int src, int dst, boolean rh) {
2976: int pn = VideoController.vcnReg2Curr & 3;
2977: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
2978: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2979: pn = VideoController.vcnReg2Curr >> 2 & 3;
2980: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
2981: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
2982: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
2983: int db = da + XEiJ.pnlScreenWidth;
2984: if (rh) {
2985: int half = XEiJ.pnlScreenWidth >> 4 << 3;
2986: gx1st += half << 1;
2987: gx2nd += half << 1;
2988: da += half;
2989: }
2990: while (da < db) {
2991: int p;
2992: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) <= 1 ?
2993: VideoController.vcnPal32G8[0] :
2994: (p & 1) == 0 ?
2995: VideoController.vcnPal32G8[p] :
2996: VideoController.vcnPalTbl[
2997: VideoController.vcnMix2 (
2998: VideoController.vcnPal16G8[p & -2],
2999: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])]);
3000: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) <= 1 ?
3001: VideoController.vcnPal32G8[0] :
3002: (p & 1) == 0 ?
3003: VideoController.vcnPal32G8[p] :
3004: VideoController.vcnPalTbl[
3005: VideoController.vcnMix2 (
3006: VideoController.vcnPal16G8[p & -2],
3007: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])]);
3008: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) <= 1 ?
3009: VideoController.vcnPal32G8[0] :
3010: (p & 1) == 0 ?
3011: VideoController.vcnPal32G8[p] :
3012: VideoController.vcnPalTbl[
3013: VideoController.vcnMix2 (
3014: VideoController.vcnPal16G8[p & -2],
3015: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])]);
3016: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) <= 1 ?
3017: VideoController.vcnPal32G8[0] :
3018: (p & 1) == 0 ?
3019: VideoController.vcnPal32G8[p] :
3020: VideoController.vcnPalTbl[
3021: VideoController.vcnMix2 (
3022: VideoController.vcnPal16G8[p & -2],
3023: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])]);
3024: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) <= 1 ?
3025: VideoController.vcnPal32G8[0] :
3026: (p & 1) == 0 ?
3027: VideoController.vcnPal32G8[p] :
3028: VideoController.vcnPalTbl[
3029: VideoController.vcnMix2 (
3030: VideoController.vcnPal16G8[p & -2],
3031: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])]);
3032: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) <= 1 ?
3033: VideoController.vcnPal32G8[0] :
3034: (p & 1) == 0 ?
3035: VideoController.vcnPal32G8[p] :
3036: VideoController.vcnPalTbl[
3037: VideoController.vcnMix2 (
3038: VideoController.vcnPal16G8[p & -2],
3039: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])]);
3040: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) <= 1 ?
3041: VideoController.vcnPal32G8[0] :
3042: (p & 1) == 0 ?
3043: VideoController.vcnPal32G8[p] :
3044: VideoController.vcnPalTbl[
3045: VideoController.vcnMix2 (
3046: VideoController.vcnPal16G8[p & -2],
3047: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])]);
3048: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) <= 1 ?
3049: VideoController.vcnPal32G8[0] :
3050: (p & 1) == 0 ?
3051: VideoController.vcnPal32G8[p] :
3052: VideoController.vcnPalTbl[
3053: VideoController.vcnMix2 (
3054: VideoController.vcnPal16G8[p & -2],
3055: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])]);
3056: gx1st += 16;
3057: gx2nd += 16;
3058: da += 8;
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:
3085:
3086:
3087: E1_XHPGT {
3088: @Override public void drawRaster (int src, int dst, boolean rh) {
3089: int pn = VideoController.vcnReg2Curr & 3;
3090: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3091: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3092: pn = VideoController.vcnReg2Curr >> 2 & 3;
3093: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3094: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3095: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3096: int db = da + XEiJ.pnlScreenWidth;
3097: if (rh) {
3098: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3099: gx1st += half << 1;
3100: gx2nd += half << 1;
3101: da += half;
3102: }
3103: while (da < db) {
3104: int p;
3105: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) <= 1 ?
3106: VideoController.vcnPal32G8[0] :
3107: (p & 1) == 0 ?
3108: VideoController.vcnPal32G8[p] :
3109: VideoController.vcnPalTbl[
3110: VideoController.vcnMix2 (
3111: VideoController.vcnMix2 (
3112: VideoController.vcnPal16G8[p & -2],
3113: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
3114: 0)]);
3115: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) <= 1 ?
3116: VideoController.vcnPal32G8[0] :
3117: (p & 1) == 0 ?
3118: VideoController.vcnPal32G8[p] :
3119: VideoController.vcnPalTbl[
3120: VideoController.vcnMix2 (
3121: VideoController.vcnMix2 (
3122: VideoController.vcnPal16G8[p & -2],
3123: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
3124: 0)]);
3125: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) <= 1 ?
3126: VideoController.vcnPal32G8[0] :
3127: (p & 1) == 0 ?
3128: VideoController.vcnPal32G8[p] :
3129: VideoController.vcnPalTbl[
3130: VideoController.vcnMix2 (
3131: VideoController.vcnMix2 (
3132: VideoController.vcnPal16G8[p & -2],
3133: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
3134: 0)]);
3135: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) <= 1 ?
3136: VideoController.vcnPal32G8[0] :
3137: (p & 1) == 0 ?
3138: VideoController.vcnPal32G8[p] :
3139: VideoController.vcnPalTbl[
3140: VideoController.vcnMix2 (
3141: VideoController.vcnMix2 (
3142: VideoController.vcnPal16G8[p & -2],
3143: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
3144: 0)]);
3145: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) <= 1 ?
3146: VideoController.vcnPal32G8[0] :
3147: (p & 1) == 0 ?
3148: VideoController.vcnPal32G8[p] :
3149: VideoController.vcnPalTbl[
3150: VideoController.vcnMix2 (
3151: VideoController.vcnMix2 (
3152: VideoController.vcnPal16G8[p & -2],
3153: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
3154: 0)]);
3155: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) <= 1 ?
3156: VideoController.vcnPal32G8[0] :
3157: (p & 1) == 0 ?
3158: VideoController.vcnPal32G8[p] :
3159: VideoController.vcnPalTbl[
3160: VideoController.vcnMix2 (
3161: VideoController.vcnMix2 (
3162: VideoController.vcnPal16G8[p & -2],
3163: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
3164: 0)]);
3165: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) <= 1 ?
3166: VideoController.vcnPal32G8[0] :
3167: (p & 1) == 0 ?
3168: VideoController.vcnPal32G8[p] :
3169: VideoController.vcnPalTbl[
3170: VideoController.vcnMix2 (
3171: VideoController.vcnMix2 (
3172: VideoController.vcnPal16G8[p & -2],
3173: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
3174: 0)]);
3175: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) <= 1 ?
3176: VideoController.vcnPal32G8[0] :
3177: (p & 1) == 0 ?
3178: VideoController.vcnPal32G8[p] :
3179: VideoController.vcnPalTbl[
3180: VideoController.vcnMix2 (
3181: VideoController.vcnMix2 (
3182: VideoController.vcnPal16G8[p & -2],
3183: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
3184: 0)]);
3185: gx1st += 16;
3186: gx2nd += 16;
3187: da += 8;
3188: }
3189: }
3190: },
3191:
3192:
3193:
3194:
3195:
3196:
3197:
3198:
3199:
3200:
3201:
3202:
3203:
3204:
3205:
3206:
3207:
3208:
3209:
3210:
3211: E1_A {
3212: @Override public void drawRaster (int src, int dst, boolean rh) {
3213: int pn = VideoController.vcnReg2Curr & 3;
3214: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3215: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3216: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3217: int db = da + XEiJ.pnlScreenWidth;
3218: if (rh) {
3219: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3220: gx1st += half << 1;
3221: da += half;
3222: }
3223: while (da < db) {
3224: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
3225: VideoController.vcnMix2 (
3226: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st & 1023]],
3227: VideoController.vcnPal16TS[0])]);
3228: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
3229: VideoController.vcnMix2 (
3230: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]],
3231: VideoController.vcnPal16TS[0])]);
3232: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
3233: VideoController.vcnMix2 (
3234: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]],
3235: VideoController.vcnPal16TS[0])]);
3236: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
3237: VideoController.vcnMix2 (
3238: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]],
3239: VideoController.vcnPal16TS[0])]);
3240: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
3241: VideoController.vcnMix2 (
3242: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]],
3243: VideoController.vcnPal16TS[0])]);
3244: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
3245: VideoController.vcnMix2 (
3246: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]],
3247: VideoController.vcnPal16TS[0])]);
3248: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
3249: VideoController.vcnMix2 (
3250: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]],
3251: VideoController.vcnPal16TS[0])]);
3252: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
3253: VideoController.vcnMix2 (
3254: VideoController.vcnPal16G8[MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]],
3255: VideoController.vcnPal16TS[0])]);
3256: gx1st += 16;
3257: da += 8;
3258: }
3259: }
3260: },
3261:
3262:
3263:
3264:
3265:
3266:
3267:
3268:
3269:
3270:
3271:
3272:
3273:
3274:
3275:
3276:
3277:
3278:
3279:
3280:
3281:
3282:
3283:
3284: E2 {
3285: @Override public void drawRaster (int src, int dst, boolean rh) {
3286: int pn = VideoController.vcnReg2Curr & 3;
3287: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3288: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3289: pn = VideoController.vcnReg2Curr >> 2 & 3;
3290: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3291: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3292: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3293: int db = da + XEiJ.pnlScreenWidth;
3294: if (rh) {
3295: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3296: gx1st += half << 1;
3297: gx2nd += half << 1;
3298: da += half;
3299: }
3300: while (da < db) {
3301: int p;
3302: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
3303: VideoController.vcnPal32G8[p] :
3304: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023]]);
3305: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
3306: VideoController.vcnPal32G8[p] :
3307: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]]);
3308: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
3309: VideoController.vcnPal32G8[p] :
3310: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]]);
3311: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
3312: VideoController.vcnPal32G8[p] :
3313: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]]);
3314: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
3315: VideoController.vcnPal32G8[p] :
3316: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]]);
3317: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
3318: VideoController.vcnPal32G8[p] :
3319: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]]);
3320: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
3321: VideoController.vcnPal32G8[p] :
3322: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]]);
3323: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
3324: VideoController.vcnPal32G8[p] :
3325: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]]);
3326: gx1st += 16;
3327: gx2nd += 16;
3328: da += 8;
3329: }
3330: }
3331: },
3332:
3333:
3334:
3335:
3336:
3337:
3338: XE2 {
3339: @Override public void drawRaster (int src, int dst, boolean rh) {
3340: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
3341:
3342: case 0b00010000:
3343: case 0b00010001:
3344: case 0b00010010:
3345: case 0b00010011:
3346: E2.drawRaster (src, dst, rh);
3347: break;
3348:
3349: case 0b00010100:
3350: case 0b00010101:
3351: case 0b00010110:
3352: case 0b00010111:
3353: E2_XWP.drawRaster (src, dst, rh);
3354: break;
3355:
3356: case 0b00011000:
3357: E2.drawRaster (src, dst, rh);
3358: break;
3359:
3360: case 0b00011001:
3361: E2_XHCT.drawRaster (src, dst, rh);
3362: break;
3363:
3364: case 0b00011010:
3365: E2_XHCG.drawRaster (src, dst, rh);
3366: break;
3367:
3368: case 0b00011011:
3369: E2_XHCGT.drawRaster (src, dst, rh);
3370: break;
3371:
3372: case 0b00011101:
3373: E2_XHPT.drawRaster (src, dst, rh);
3374: break;
3375:
3376: case 0b00011110:
3377: E2_XHPG.drawRaster (src, dst, rh);
3378: break;
3379:
3380: case 0b00011111:
3381: E2_XHPGT.drawRaster (src, dst, rh);
3382: break;
3383:
3384: case 0b01000000:
3385: case 0b01000001:
3386: case 0b01000010:
3387: case 0b01000011:
3388: case 0b01000100:
3389: case 0b01000101:
3390: case 0b01000110:
3391: case 0b01000111:
3392: case 0b01001000:
3393: case 0b01001001:
3394: case 0b01001010:
3395: case 0b01001011:
3396: case 0b01001100:
3397: case 0b01001101:
3398: case 0b01001110:
3399: case 0b01001111:
3400: case 0b01010000:
3401: case 0b01010001:
3402: case 0b01010010:
3403: case 0b01010011:
3404: case 0b01010100:
3405: case 0b01010101:
3406: case 0b01010110:
3407: case 0b01010111:
3408: case 0b01011000:
3409: case 0b01011001:
3410: case 0b01011010:
3411: case 0b01011011:
3412: case 0b01011100:
3413: case 0b01011101:
3414: case 0b01011110:
3415: case 0b01011111:
3416: E2_A.drawRaster (src, dst, rh);
3417: break;
3418: default:
3419: E2.drawRaster (src, dst, rh);
3420: VideoController.vcnReportUnimplemented (XE2);
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:
3449:
3450:
3451: E2_XWP {
3452: @Override public void drawRaster (int src, int dst, boolean rh) {
3453: int pn = VideoController.vcnReg2Curr & 3;
3454: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3455: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3456: pn = VideoController.vcnReg2Curr >> 2 & 3;
3457: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3458: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3459: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3460: int db = da + XEiJ.pnlScreenWidth;
3461: if (rh) {
3462: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3463: gx1st += half << 1;
3464: gx2nd += half << 1;
3465: da += half;
3466: }
3467: while (da < db) {
3468: int p;
3469: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
3470: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2] :
3471: p == 1 ?
3472: VideoController.vcnPal32G8[0] :
3473: (p & 1) == 0 ?
3474: VideoController.vcnPal32G8[p] :
3475: VideoController.vcnPal32G8[p & -2]);
3476: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
3477: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2] :
3478: p == 1 ?
3479: VideoController.vcnPal32G8[0] :
3480: (p & 1) == 0 ?
3481: VideoController.vcnPal32G8[p] :
3482: VideoController.vcnPal32G8[p & -2]);
3483: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
3484: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2] :
3485: p == 1 ?
3486: VideoController.vcnPal32G8[0] :
3487: (p & 1) == 0 ?
3488: VideoController.vcnPal32G8[p] :
3489: VideoController.vcnPal32G8[p & -2]);
3490: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
3491: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2] :
3492: p == 1 ?
3493: VideoController.vcnPal32G8[0] :
3494: (p & 1) == 0 ?
3495: VideoController.vcnPal32G8[p] :
3496: VideoController.vcnPal32G8[p & -2]);
3497: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
3498: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2] :
3499: p == 1 ?
3500: VideoController.vcnPal32G8[0] :
3501: (p & 1) == 0 ?
3502: VideoController.vcnPal32G8[p] :
3503: VideoController.vcnPal32G8[p & -2]);
3504: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
3505: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2] :
3506: p == 1 ?
3507: VideoController.vcnPal32G8[0] :
3508: (p & 1) == 0 ?
3509: VideoController.vcnPal32G8[p] :
3510: VideoController.vcnPal32G8[p & -2]);
3511: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
3512: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2] :
3513: p == 1 ?
3514: VideoController.vcnPal32G8[0] :
3515: (p & 1) == 0 ?
3516: VideoController.vcnPal32G8[p] :
3517: VideoController.vcnPal32G8[p & -2]);
3518: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
3519: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2] :
3520: p == 1 ?
3521: VideoController.vcnPal32G8[0] :
3522: (p & 1) == 0 ?
3523: VideoController.vcnPal32G8[p] :
3524: VideoController.vcnPal32G8[p & -2]);
3525: gx1st += 16;
3526: gx2nd += 16;
3527: da += 8;
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:
3558:
3559:
3560: E2_XHCT {
3561: @Override public void drawRaster (int src, int dst, boolean rh) {
3562: int pn = VideoController.vcnReg2Curr & 3;
3563: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3564: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3565: pn = VideoController.vcnReg2Curr >> 2 & 3;
3566: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3567: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3568: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3569: int db = da + XEiJ.pnlScreenWidth;
3570: if (rh) {
3571: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3572: gx1st += half << 1;
3573: gx2nd += half << 1;
3574: da += half;
3575: }
3576: while (da < db) {
3577: int p;
3578: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
3579: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3580: VideoController.vcnPalTbl[
3581: VideoController.vcnMix2 (
3582: VideoController.vcnPal16G8[p],
3583: 0)] :
3584: VideoController.vcnPal32G8[p] :
3585: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) & -2] & 1) != 0 ?
3586: VideoController.vcnPalTbl[
3587: VideoController.vcnMix2 (
3588: VideoController.vcnPal16G8[p],
3589: 0)] :
3590: VideoController.vcnPal32G8[p]);
3591: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
3592: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3593: VideoController.vcnPalTbl[
3594: VideoController.vcnMix2 (
3595: VideoController.vcnPal16G8[p],
3596: 0)] :
3597: VideoController.vcnPal32G8[p] :
3598: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) & -2] & 1) != 0 ?
3599: VideoController.vcnPalTbl[
3600: VideoController.vcnMix2 (
3601: VideoController.vcnPal16G8[p],
3602: 0)] :
3603: VideoController.vcnPal32G8[p]);
3604: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
3605: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3606: VideoController.vcnPalTbl[
3607: VideoController.vcnMix2 (
3608: VideoController.vcnPal16G8[p],
3609: 0)] :
3610: VideoController.vcnPal32G8[p] :
3611: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) & -2] & 1) != 0 ?
3612: VideoController.vcnPalTbl[
3613: VideoController.vcnMix2 (
3614: VideoController.vcnPal16G8[p],
3615: 0)] :
3616: VideoController.vcnPal32G8[p]);
3617: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
3618: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3619: VideoController.vcnPalTbl[
3620: VideoController.vcnMix2 (
3621: VideoController.vcnPal16G8[p],
3622: 0)] :
3623: VideoController.vcnPal32G8[p] :
3624: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) & -2] & 1) != 0 ?
3625: VideoController.vcnPalTbl[
3626: VideoController.vcnMix2 (
3627: VideoController.vcnPal16G8[p],
3628: 0)] :
3629: VideoController.vcnPal32G8[p]);
3630: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
3631: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3632: VideoController.vcnPalTbl[
3633: VideoController.vcnMix2 (
3634: VideoController.vcnPal16G8[p],
3635: 0)] :
3636: VideoController.vcnPal32G8[p] :
3637: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) & -2] & 1) != 0 ?
3638: VideoController.vcnPalTbl[
3639: VideoController.vcnMix2 (
3640: VideoController.vcnPal16G8[p],
3641: 0)] :
3642: VideoController.vcnPal32G8[p]);
3643: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
3644: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3645: VideoController.vcnPalTbl[
3646: VideoController.vcnMix2 (
3647: VideoController.vcnPal16G8[p],
3648: 0)] :
3649: VideoController.vcnPal32G8[p] :
3650: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) & -2] & 1) != 0 ?
3651: VideoController.vcnPalTbl[
3652: VideoController.vcnMix2 (
3653: VideoController.vcnPal16G8[p],
3654: 0)] :
3655: VideoController.vcnPal32G8[p]);
3656: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
3657: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3658: VideoController.vcnPalTbl[
3659: VideoController.vcnMix2 (
3660: VideoController.vcnPal16G8[p],
3661: 0)] :
3662: VideoController.vcnPal32G8[p] :
3663: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) & -2] & 1) != 0 ?
3664: VideoController.vcnPalTbl[
3665: VideoController.vcnMix2 (
3666: VideoController.vcnPal16G8[p],
3667: 0)] :
3668: VideoController.vcnPal32G8[p]);
3669: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
3670: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
3671: VideoController.vcnPalTbl[
3672: VideoController.vcnMix2 (
3673: VideoController.vcnPal16G8[p],
3674: 0)] :
3675: VideoController.vcnPal32G8[p] :
3676: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) & -2] & 1) != 0 ?
3677: VideoController.vcnPalTbl[
3678: VideoController.vcnMix2 (
3679: VideoController.vcnPal16G8[p],
3680: 0)] :
3681: VideoController.vcnPal32G8[p]);
3682: gx1st += 16;
3683: gx2nd += 16;
3684: da += 8;
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:
3718:
3719:
3720: E2_XHCG {
3721: @Override public void drawRaster (int src, int dst, boolean rh) {
3722: int pn = VideoController.vcnReg2Curr & 3;
3723: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3724: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3725: pn = VideoController.vcnReg2Curr >> 2 & 3;
3726: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3727: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3728: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3729: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3730: int db = da + XEiJ.pnlScreenWidth;
3731: if (rh) {
3732: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3733: gx1st += half << 1;
3734: gx2nd += half << 1;
3735: da += half;
3736: }
3737: while (da < db) {
3738: int p, q;
3739: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
3740: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3741: VideoController.vcnPalTbl[
3742: VideoController.vcnMix2 (
3743: q,
3744: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
3745: (p & 1) != 0 ?
3746: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
3747: VideoController.vcnPal32G8[p] :
3748: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) & -2]) & 1) != 0 ?
3749: VideoController.vcnPalTbl[
3750: VideoController.vcnMix2 (
3751: p,
3752: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
3753: VideoController.vcnPal32G8[q]);
3754: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
3755: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3756: VideoController.vcnPalTbl[
3757: VideoController.vcnMix2 (
3758: q,
3759: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
3760: (p & 1) != 0 ?
3761: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
3762: VideoController.vcnPal32G8[p] :
3763: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) & -2]) & 1) != 0 ?
3764: VideoController.vcnPalTbl[
3765: VideoController.vcnMix2 (
3766: p,
3767: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
3768: VideoController.vcnPal32G8[q]);
3769: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
3770: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3771: VideoController.vcnPalTbl[
3772: VideoController.vcnMix2 (
3773: q,
3774: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
3775: (p & 1) != 0 ?
3776: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
3777: VideoController.vcnPal32G8[p] :
3778: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) & -2]) & 1) != 0 ?
3779: VideoController.vcnPalTbl[
3780: VideoController.vcnMix2 (
3781: p,
3782: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
3783: VideoController.vcnPal32G8[q]);
3784: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
3785: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3786: VideoController.vcnPalTbl[
3787: VideoController.vcnMix2 (
3788: q,
3789: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
3790: (p & 1) != 0 ?
3791: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
3792: VideoController.vcnPal32G8[p] :
3793: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) & -2]) & 1) != 0 ?
3794: VideoController.vcnPalTbl[
3795: VideoController.vcnMix2 (
3796: p,
3797: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
3798: VideoController.vcnPal32G8[q]);
3799: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
3800: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3801: VideoController.vcnPalTbl[
3802: VideoController.vcnMix2 (
3803: q,
3804: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
3805: (p & 1) != 0 ?
3806: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
3807: VideoController.vcnPal32G8[p] :
3808: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) & -2]) & 1) != 0 ?
3809: VideoController.vcnPalTbl[
3810: VideoController.vcnMix2 (
3811: p,
3812: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
3813: VideoController.vcnPal32G8[q]);
3814: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
3815: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3816: VideoController.vcnPalTbl[
3817: VideoController.vcnMix2 (
3818: q,
3819: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
3820: (p & 1) != 0 ?
3821: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
3822: VideoController.vcnPal32G8[p] :
3823: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) & -2]) & 1) != 0 ?
3824: VideoController.vcnPalTbl[
3825: VideoController.vcnMix2 (
3826: p,
3827: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
3828: VideoController.vcnPal32G8[q]);
3829: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
3830: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3831: VideoController.vcnPalTbl[
3832: VideoController.vcnMix2 (
3833: q,
3834: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
3835: (p & 1) != 0 ?
3836: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
3837: VideoController.vcnPal32G8[p] :
3838: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) & -2]) & 1) != 0 ?
3839: VideoController.vcnPalTbl[
3840: VideoController.vcnMix2 (
3841: p,
3842: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
3843: VideoController.vcnPal32G8[q]);
3844: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
3845: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3846: VideoController.vcnPalTbl[
3847: VideoController.vcnMix2 (
3848: q,
3849: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
3850: (p & 1) != 0 ?
3851: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
3852: VideoController.vcnPal32G8[p] :
3853: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) & -2]) & 1) != 0 ?
3854: VideoController.vcnPalTbl[
3855: VideoController.vcnMix2 (
3856: p,
3857: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
3858: VideoController.vcnPal32G8[q]);
3859: gx1st += 16;
3860: gx2nd += 16;
3861: da += 8;
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:
3895:
3896:
3897: E2_XHCGT {
3898: @Override public void drawRaster (int src, int dst, boolean rh) {
3899: int pn = VideoController.vcnReg2Curr & 3;
3900: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
3901: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3902: pn = VideoController.vcnReg2Curr >> 2 & 3;
3903: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
3904: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3905: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
3906: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
3907: int db = da + XEiJ.pnlScreenWidth;
3908: if (rh) {
3909: int half = XEiJ.pnlScreenWidth >> 4 << 3;
3910: gx1st += half << 1;
3911: gx2nd += half << 1;
3912: da += half;
3913: }
3914: while (da < db) {
3915: int p, q;
3916: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
3917: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3918: VideoController.vcnPalTbl[
3919: VideoController.vcnMix2 (
3920: VideoController.vcnMix2 (
3921: q,
3922: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
3923: 0)] :
3924: (p & 1) != 0 ?
3925: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
3926: VideoController.vcnPal32G8[p] :
3927: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) & -2]) & 1) != 0 ?
3928: VideoController.vcnPalTbl[
3929: VideoController.vcnMix2 (
3930: VideoController.vcnMix2 (
3931: p,
3932: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
3933: 0)] :
3934: VideoController.vcnPal32G8[q]);
3935: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
3936: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3937: VideoController.vcnPalTbl[
3938: VideoController.vcnMix2 (
3939: VideoController.vcnMix2 (
3940: q,
3941: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
3942: 0)] :
3943: (p & 1) != 0 ?
3944: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
3945: VideoController.vcnPal32G8[p] :
3946: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) & -2]) & 1) != 0 ?
3947: VideoController.vcnPalTbl[
3948: VideoController.vcnMix2 (
3949: VideoController.vcnMix2 (
3950: p,
3951: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
3952: 0)] :
3953: VideoController.vcnPal32G8[q]);
3954: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
3955: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3956: VideoController.vcnPalTbl[
3957: VideoController.vcnMix2 (
3958: VideoController.vcnMix2 (
3959: q,
3960: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
3961: 0)] :
3962: (p & 1) != 0 ?
3963: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
3964: VideoController.vcnPal32G8[p] :
3965: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) & -2]) & 1) != 0 ?
3966: VideoController.vcnPalTbl[
3967: VideoController.vcnMix2 (
3968: VideoController.vcnMix2 (
3969: p,
3970: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
3971: 0)] :
3972: VideoController.vcnPal32G8[q]);
3973: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
3974: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3975: VideoController.vcnPalTbl[
3976: VideoController.vcnMix2 (
3977: VideoController.vcnMix2 (
3978: q,
3979: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
3980: 0)] :
3981: (p & 1) != 0 ?
3982: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
3983: VideoController.vcnPal32G8[p] :
3984: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) & -2]) & 1) != 0 ?
3985: VideoController.vcnPalTbl[
3986: VideoController.vcnMix2 (
3987: VideoController.vcnMix2 (
3988: p,
3989: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
3990: 0)] :
3991: VideoController.vcnPal32G8[q]);
3992: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
3993: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
3994: VideoController.vcnPalTbl[
3995: VideoController.vcnMix2 (
3996: VideoController.vcnMix2 (
3997: q,
3998: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
3999: 0)] :
4000: (p & 1) != 0 ?
4001: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
4002: VideoController.vcnPal32G8[p] :
4003: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) & -2]) & 1) != 0 ?
4004: VideoController.vcnPalTbl[
4005: VideoController.vcnMix2 (
4006: VideoController.vcnMix2 (
4007: p,
4008: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
4009: 0)] :
4010: VideoController.vcnPal32G8[q]);
4011: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
4012: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
4013: VideoController.vcnPalTbl[
4014: VideoController.vcnMix2 (
4015: VideoController.vcnMix2 (
4016: q,
4017: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
4018: 0)] :
4019: (p & 1) != 0 ?
4020: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
4021: VideoController.vcnPal32G8[p] :
4022: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) & -2]) & 1) != 0 ?
4023: VideoController.vcnPalTbl[
4024: VideoController.vcnMix2 (
4025: VideoController.vcnMix2 (
4026: p,
4027: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
4028: 0)] :
4029: VideoController.vcnPal32G8[q]);
4030: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
4031: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
4032: VideoController.vcnPalTbl[
4033: VideoController.vcnMix2 (
4034: VideoController.vcnMix2 (
4035: q,
4036: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
4037: 0)] :
4038: (p & 1) != 0 ?
4039: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
4040: VideoController.vcnPal32G8[p] :
4041: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) & -2]) & 1) != 0 ?
4042: VideoController.vcnPalTbl[
4043: VideoController.vcnMix2 (
4044: VideoController.vcnMix2 (
4045: p,
4046: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
4047: 0)] :
4048: VideoController.vcnPal32G8[q]);
4049: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
4050: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
4051: VideoController.vcnPalTbl[
4052: VideoController.vcnMix2 (
4053: VideoController.vcnMix2 (
4054: q,
4055: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
4056: 0)] :
4057: (p & 1) != 0 ?
4058: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
4059: VideoController.vcnPal32G8[p] :
4060: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) & -2]) & 1) != 0 ?
4061: VideoController.vcnPalTbl[
4062: VideoController.vcnMix2 (
4063: VideoController.vcnMix2 (
4064: p,
4065: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
4066: 0)] :
4067: VideoController.vcnPal32G8[q]);
4068: gx1st += 16;
4069: gx2nd += 16;
4070: da += 8;
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:
4099:
4100:
4101: E2_XHPT {
4102: @Override public void drawRaster (int src, int dst, boolean rh) {
4103: int pn = VideoController.vcnReg2Curr & 3;
4104: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4105: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4106: pn = VideoController.vcnReg2Curr >> 2 & 3;
4107: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4108: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4109: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4110: int db = da + XEiJ.pnlScreenWidth;
4111: if (rh) {
4112: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4113: gx1st += half << 1;
4114: gx2nd += half << 1;
4115: da += half;
4116: }
4117: while (da < db) {
4118: int p;
4119: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
4120: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2] :
4121: p == 1 ?
4122: VideoController.vcnPal32G8[0] :
4123: (p & 1) == 0 ?
4124: VideoController.vcnPal32G8[p] :
4125: VideoController.vcnPalTbl[
4126: VideoController.vcnMix2 (
4127: VideoController.vcnPal16G8[p & -2],
4128: 0)]);
4129: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
4130: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2] :
4131: p == 1 ?
4132: VideoController.vcnPal32G8[0] :
4133: (p & 1) == 0 ?
4134: VideoController.vcnPal32G8[p] :
4135: VideoController.vcnPalTbl[
4136: VideoController.vcnMix2 (
4137: VideoController.vcnPal16G8[p & -2],
4138: 0)]);
4139: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
4140: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2] :
4141: p == 1 ?
4142: VideoController.vcnPal32G8[0] :
4143: (p & 1) == 0 ?
4144: VideoController.vcnPal32G8[p] :
4145: VideoController.vcnPalTbl[
4146: VideoController.vcnMix2 (
4147: VideoController.vcnPal16G8[p & -2],
4148: 0)]);
4149: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
4150: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2] :
4151: p == 1 ?
4152: VideoController.vcnPal32G8[0] :
4153: (p & 1) == 0 ?
4154: VideoController.vcnPal32G8[p] :
4155: VideoController.vcnPalTbl[
4156: VideoController.vcnMix2 (
4157: VideoController.vcnPal16G8[p & -2],
4158: 0)]);
4159: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
4160: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2] :
4161: p == 1 ?
4162: VideoController.vcnPal32G8[0] :
4163: (p & 1) == 0 ?
4164: VideoController.vcnPal32G8[p] :
4165: VideoController.vcnPalTbl[
4166: VideoController.vcnMix2 (
4167: VideoController.vcnPal16G8[p & -2],
4168: 0)]);
4169: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
4170: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2] :
4171: p == 1 ?
4172: VideoController.vcnPal32G8[0] :
4173: (p & 1) == 0 ?
4174: VideoController.vcnPal32G8[p] :
4175: VideoController.vcnPalTbl[
4176: VideoController.vcnMix2 (
4177: VideoController.vcnPal16G8[p & -2],
4178: 0)]);
4179: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
4180: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2] :
4181: p == 1 ?
4182: VideoController.vcnPal32G8[0] :
4183: (p & 1) == 0 ?
4184: VideoController.vcnPal32G8[p] :
4185: VideoController.vcnPalTbl[
4186: VideoController.vcnMix2 (
4187: VideoController.vcnPal16G8[p & -2],
4188: 0)]);
4189: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
4190: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2] :
4191: p == 1 ?
4192: VideoController.vcnPal32G8[0] :
4193: (p & 1) == 0 ?
4194: VideoController.vcnPal32G8[p] :
4195: VideoController.vcnPalTbl[
4196: VideoController.vcnMix2 (
4197: VideoController.vcnPal16G8[p & -2],
4198: 0)]);
4199: gx1st += 16;
4200: gx2nd += 16;
4201: da += 8;
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:
4230:
4231:
4232: E2_XHPG {
4233: @Override public void drawRaster (int src, int dst, boolean rh) {
4234: int pn = VideoController.vcnReg2Curr & 3;
4235: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4236: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4237: pn = VideoController.vcnReg2Curr >> 2 & 3;
4238: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4239: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4240: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4241: int db = da + XEiJ.pnlScreenWidth;
4242: if (rh) {
4243: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4244: gx1st += half << 1;
4245: gx2nd += half << 1;
4246: da += half;
4247: }
4248: while (da < db) {
4249: int p;
4250: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
4251: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2] :
4252: p == 1 ?
4253: VideoController.vcnPal32G8[0] :
4254: (p & 1) == 0 ?
4255: VideoController.vcnPal32G8[p] :
4256: VideoController.vcnPalTbl[
4257: VideoController.vcnMix2 (
4258: VideoController.vcnPal16G8[p & -2],
4259: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] | 1])]);
4260: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
4261: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2] :
4262: p == 1 ?
4263: VideoController.vcnPal32G8[0] :
4264: (p & 1) == 0 ?
4265: VideoController.vcnPal32G8[p] :
4266: VideoController.vcnPalTbl[
4267: VideoController.vcnMix2 (
4268: VideoController.vcnPal16G8[p & -2],
4269: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] | 1])]);
4270: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
4271: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2] :
4272: p == 1 ?
4273: VideoController.vcnPal32G8[0] :
4274: (p & 1) == 0 ?
4275: VideoController.vcnPal32G8[p] :
4276: VideoController.vcnPalTbl[
4277: VideoController.vcnMix2 (
4278: VideoController.vcnPal16G8[p & -2],
4279: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] | 1])]);
4280: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
4281: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2] :
4282: p == 1 ?
4283: VideoController.vcnPal32G8[0] :
4284: (p & 1) == 0 ?
4285: VideoController.vcnPal32G8[p] :
4286: VideoController.vcnPalTbl[
4287: VideoController.vcnMix2 (
4288: VideoController.vcnPal16G8[p & -2],
4289: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] | 1])]);
4290: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
4291: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2] :
4292: p == 1 ?
4293: VideoController.vcnPal32G8[0] :
4294: (p & 1) == 0 ?
4295: VideoController.vcnPal32G8[p] :
4296: VideoController.vcnPalTbl[
4297: VideoController.vcnMix2 (
4298: VideoController.vcnPal16G8[p & -2],
4299: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] | 1])]);
4300: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
4301: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2] :
4302: p == 1 ?
4303: VideoController.vcnPal32G8[0] :
4304: (p & 1) == 0 ?
4305: VideoController.vcnPal32G8[p] :
4306: VideoController.vcnPalTbl[
4307: VideoController.vcnMix2 (
4308: VideoController.vcnPal16G8[p & -2],
4309: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] | 1])]);
4310: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
4311: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2] :
4312: p == 1 ?
4313: VideoController.vcnPal32G8[0] :
4314: (p & 1) == 0 ?
4315: VideoController.vcnPal32G8[p] :
4316: VideoController.vcnPalTbl[
4317: VideoController.vcnMix2 (
4318: VideoController.vcnPal16G8[p & -2],
4319: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] | 1])]);
4320: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
4321: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2] :
4322: p == 1 ?
4323: VideoController.vcnPal32G8[0] :
4324: (p & 1) == 0 ?
4325: VideoController.vcnPal32G8[p] :
4326: VideoController.vcnPalTbl[
4327: VideoController.vcnMix2 (
4328: VideoController.vcnPal16G8[p & -2],
4329: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] | 1])]);
4330: gx1st += 16;
4331: gx2nd += 16;
4332: da += 8;
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:
4361:
4362:
4363: E2_XHPGT {
4364: @Override public void drawRaster (int src, int dst, boolean rh) {
4365: int pn = VideoController.vcnReg2Curr & 3;
4366: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4367: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4368: pn = VideoController.vcnReg2Curr >> 2 & 3;
4369: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4370: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4371: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4372: int db = da + XEiJ.pnlScreenWidth;
4373: if (rh) {
4374: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4375: gx1st += half << 1;
4376: gx2nd += half << 1;
4377: da += half;
4378: }
4379: while (da < db) {
4380: int p;
4381: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
4382: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2] :
4383: p == 1 ?
4384: VideoController.vcnPal32G8[0] :
4385: (p & 1) == 0 ?
4386: VideoController.vcnPal32G8[p] :
4387: VideoController.vcnPalTbl[
4388: VideoController.vcnMix2 (
4389: VideoController.vcnMix2 (
4390: VideoController.vcnPal16G8[p & -2],
4391: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023] | 1]),
4392: 0)]);
4393: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
4394: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2] :
4395: p == 1 ?
4396: VideoController.vcnPal32G8[0] :
4397: (p & 1) == 0 ?
4398: VideoController.vcnPal32G8[p] :
4399: VideoController.vcnPalTbl[
4400: VideoController.vcnMix2 (
4401: VideoController.vcnMix2 (
4402: VideoController.vcnPal16G8[p & -2],
4403: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] | 1]),
4404: 0)]);
4405: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
4406: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2] :
4407: p == 1 ?
4408: VideoController.vcnPal32G8[0] :
4409: (p & 1) == 0 ?
4410: VideoController.vcnPal32G8[p] :
4411: VideoController.vcnPalTbl[
4412: VideoController.vcnMix2 (
4413: VideoController.vcnMix2 (
4414: VideoController.vcnPal16G8[p & -2],
4415: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] | 1]),
4416: 0)]);
4417: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
4418: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2] :
4419: p == 1 ?
4420: VideoController.vcnPal32G8[0] :
4421: (p & 1) == 0 ?
4422: VideoController.vcnPal32G8[p] :
4423: VideoController.vcnPalTbl[
4424: VideoController.vcnMix2 (
4425: VideoController.vcnMix2 (
4426: VideoController.vcnPal16G8[p & -2],
4427: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] | 1]),
4428: 0)]);
4429: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
4430: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2] :
4431: p == 1 ?
4432: VideoController.vcnPal32G8[0] :
4433: (p & 1) == 0 ?
4434: VideoController.vcnPal32G8[p] :
4435: VideoController.vcnPalTbl[
4436: VideoController.vcnMix2 (
4437: VideoController.vcnMix2 (
4438: VideoController.vcnPal16G8[p & -2],
4439: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] | 1]),
4440: 0)]);
4441: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
4442: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2] :
4443: p == 1 ?
4444: VideoController.vcnPal32G8[0] :
4445: (p & 1) == 0 ?
4446: VideoController.vcnPal32G8[p] :
4447: VideoController.vcnPalTbl[
4448: VideoController.vcnMix2 (
4449: VideoController.vcnMix2 (
4450: VideoController.vcnPal16G8[p & -2],
4451: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] | 1]),
4452: 0)]);
4453: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
4454: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2] :
4455: p == 1 ?
4456: VideoController.vcnPal32G8[0] :
4457: (p & 1) == 0 ?
4458: VideoController.vcnPal32G8[p] :
4459: VideoController.vcnPalTbl[
4460: VideoController.vcnMix2 (
4461: VideoController.vcnMix2 (
4462: VideoController.vcnPal16G8[p & -2],
4463: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] | 1]),
4464: 0)]);
4465: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
4466: VideoController.vcnPal32G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2] :
4467: p == 1 ?
4468: VideoController.vcnPal32G8[0] :
4469: (p & 1) == 0 ?
4470: VideoController.vcnPal32G8[p] :
4471: VideoController.vcnPalTbl[
4472: VideoController.vcnMix2 (
4473: VideoController.vcnMix2 (
4474: VideoController.vcnPal16G8[p & -2],
4475: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] | 1]),
4476: 0)]);
4477: gx1st += 16;
4478: gx2nd += 16;
4479: da += 8;
4480: }
4481: }
4482: },
4483:
4484:
4485:
4486:
4487:
4488:
4489:
4490:
4491:
4492:
4493:
4494:
4495:
4496:
4497:
4498:
4499:
4500:
4501:
4502:
4503:
4504:
4505:
4506: E2_A {
4507: @Override public void drawRaster (int src, int dst, boolean rh) {
4508: int pn = VideoController.vcnReg2Curr & 3;
4509: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4510: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4511: pn = VideoController.vcnReg2Curr >> 2 & 3;
4512: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4513: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4514: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4515: int db = da + XEiJ.pnlScreenWidth;
4516: if (rh) {
4517: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4518: gx1st += half << 1;
4519: gx2nd += half << 1;
4520: da += half;
4521: }
4522: while (da < db) {
4523: int p;
4524: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
4525: (p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
4526: VideoController.vcnMix2 (
4527: VideoController.vcnPal16G8[p],
4528: VideoController.vcnPal16TS[0]) :
4529: VideoController.vcnMix2 (
4530: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd & 1023]],
4531: VideoController.vcnPal16TS[0])]);
4532: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
4533: (p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
4534: VideoController.vcnMix2 (
4535: VideoController.vcnPal16G8[p],
4536: VideoController.vcnPal16TS[0]) :
4537: VideoController.vcnMix2 (
4538: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]],
4539: VideoController.vcnPal16TS[0])]);
4540: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
4541: (p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
4542: VideoController.vcnMix2 (
4543: VideoController.vcnPal16G8[p],
4544: VideoController.vcnPal16TS[0]) :
4545: VideoController.vcnMix2 (
4546: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]],
4547: VideoController.vcnPal16TS[0])]);
4548: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
4549: (p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
4550: VideoController.vcnMix2 (
4551: VideoController.vcnPal16G8[p],
4552: VideoController.vcnPal16TS[0]) :
4553: VideoController.vcnMix2 (
4554: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]],
4555: VideoController.vcnPal16TS[0])]);
4556: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
4557: (p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
4558: VideoController.vcnMix2 (
4559: VideoController.vcnPal16G8[p],
4560: VideoController.vcnPal16TS[0]) :
4561: VideoController.vcnMix2 (
4562: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]],
4563: VideoController.vcnPal16TS[0])]);
4564: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
4565: (p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
4566: VideoController.vcnMix2 (
4567: VideoController.vcnPal16G8[p],
4568: VideoController.vcnPal16TS[0]) :
4569: VideoController.vcnMix2 (
4570: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]],
4571: VideoController.vcnPal16TS[0])]);
4572: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
4573: (p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
4574: VideoController.vcnMix2 (
4575: VideoController.vcnPal16G8[p],
4576: VideoController.vcnPal16TS[0]) :
4577: VideoController.vcnMix2 (
4578: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]],
4579: VideoController.vcnPal16TS[0])]);
4580: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
4581: (p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
4582: VideoController.vcnMix2 (
4583: VideoController.vcnPal16G8[p],
4584: VideoController.vcnPal16TS[0]) :
4585: VideoController.vcnMix2 (
4586: VideoController.vcnPal16G8[MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]],
4587: VideoController.vcnPal16TS[0])]);
4588: gx1st += 16;
4589: gx2nd += 16;
4590: da += 8;
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:
4618:
4619:
4620: E3 {
4621: @Override public void drawRaster (int src, int dst, boolean rh) {
4622: int pn = VideoController.vcnReg2Curr & 3;
4623: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4624: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4625: pn = VideoController.vcnReg2Curr >> 2 & 3;
4626: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4627: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4628: pn = VideoController.vcnReg2Curr >> 4 & 3;
4629: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
4630: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4631: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4632: int db = da + XEiJ.pnlScreenWidth;
4633: if (rh) {
4634: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4635: gx1st += half << 1;
4636: gx2nd += half << 1;
4637: gx3rd += half << 1;
4638: da += half;
4639: }
4640: while (da < db) {
4641: int p;
4642: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
4643: VideoController.vcnPal32G8[p] :
4644: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
4645: VideoController.vcnPal32G8[p] :
4646: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023]]);
4647: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
4648: VideoController.vcnPal32G8[p] :
4649: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
4650: VideoController.vcnPal32G8[p] :
4651: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]]);
4652: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
4653: VideoController.vcnPal32G8[p] :
4654: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
4655: VideoController.vcnPal32G8[p] :
4656: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]]);
4657: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
4658: VideoController.vcnPal32G8[p] :
4659: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
4660: VideoController.vcnPal32G8[p] :
4661: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]]);
4662: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
4663: VideoController.vcnPal32G8[p] :
4664: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
4665: VideoController.vcnPal32G8[p] :
4666: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]]);
4667: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
4668: VideoController.vcnPal32G8[p] :
4669: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
4670: VideoController.vcnPal32G8[p] :
4671: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]]);
4672: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
4673: VideoController.vcnPal32G8[p] :
4674: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
4675: VideoController.vcnPal32G8[p] :
4676: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]]);
4677: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
4678: VideoController.vcnPal32G8[p] :
4679: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
4680: VideoController.vcnPal32G8[p] :
4681: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]]);
4682: gx1st += 16;
4683: gx2nd += 16;
4684: gx3rd += 16;
4685: da += 8;
4686: }
4687: }
4688: },
4689:
4690:
4691:
4692:
4693:
4694:
4695: XE3 {
4696: @Override public void drawRaster (int src, int dst, boolean rh) {
4697: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
4698:
4699: case 0b00010000:
4700: case 0b00010001:
4701: case 0b00010010:
4702: case 0b00010011:
4703: E3.drawRaster (src, dst, rh);
4704: break;
4705:
4706: case 0b00010100:
4707: case 0b00010101:
4708: case 0b00010110:
4709: case 0b00010111:
4710: E3_XWP.drawRaster (src, dst, rh);
4711: break;
4712:
4713: case 0b00011000:
4714: E3.drawRaster (src, dst, rh);
4715: break;
4716:
4717: case 0b00011001:
4718: E3_XHCT.drawRaster (src, dst, rh);
4719: break;
4720:
4721: case 0b00011010:
4722: E3_XHCG.drawRaster (src, dst, rh);
4723: break;
4724:
4725: case 0b00011011:
4726: E3_XHCGT.drawRaster (src, dst, rh);
4727: break;
4728:
4729: case 0b00011101:
4730: E3_XHPT.drawRaster (src, dst, rh);
4731: break;
4732:
4733: case 0b00011110:
4734: E3_XHPG.drawRaster (src, dst, rh);
4735: break;
4736:
4737: case 0b00011111:
4738: E3_XHPGT.drawRaster (src, dst, rh);
4739: break;
4740:
4741: case 0b01000000:
4742: case 0b01000001:
4743: case 0b01000010:
4744: case 0b01000011:
4745: case 0b01000100:
4746: case 0b01000101:
4747: case 0b01000110:
4748: case 0b01000111:
4749: case 0b01001000:
4750: case 0b01001001:
4751: case 0b01001010:
4752: case 0b01001011:
4753: case 0b01001100:
4754: case 0b01001101:
4755: case 0b01001110:
4756: case 0b01001111:
4757: case 0b01010000:
4758: case 0b01010001:
4759: case 0b01010010:
4760: case 0b01010011:
4761: case 0b01010100:
4762: case 0b01010101:
4763: case 0b01010110:
4764: case 0b01010111:
4765: case 0b01011000:
4766: case 0b01011001:
4767: case 0b01011010:
4768: case 0b01011011:
4769: case 0b01011100:
4770: case 0b01011101:
4771: case 0b01011110:
4772: case 0b01011111:
4773: E3_A.drawRaster (src, dst, rh);
4774: break;
4775: default:
4776: E3.drawRaster (src, dst, rh);
4777: VideoController.vcnReportUnimplemented (XE3);
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:
4809:
4810:
4811: E3_XWP {
4812: @Override public void drawRaster (int src, int dst, boolean rh) {
4813: int pn = VideoController.vcnReg2Curr & 3;
4814: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4815: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4816: pn = VideoController.vcnReg2Curr >> 2 & 3;
4817: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4818: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4819: pn = VideoController.vcnReg2Curr >> 4 & 3;
4820: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
4821: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4822: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4823: int db = da + XEiJ.pnlScreenWidth;
4824: if (rh) {
4825: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4826: gx1st += half << 1;
4827: gx2nd += half << 1;
4828: gx3rd += half << 1;
4829: da += half;
4830: }
4831: while (da < db) {
4832: int p;
4833: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
4834: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
4835: VideoController.vcnPal32G8[p] :
4836: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2] :
4837: p == 1 ?
4838: VideoController.vcnPal32G8[0] :
4839: (p & 1) == 0 ?
4840: VideoController.vcnPal32G8[p] :
4841: VideoController.vcnPal32G8[p & -2]);
4842: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
4843: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
4844: VideoController.vcnPal32G8[p] :
4845: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2] :
4846: p == 1 ?
4847: VideoController.vcnPal32G8[0] :
4848: (p & 1) == 0 ?
4849: VideoController.vcnPal32G8[p] :
4850: VideoController.vcnPal32G8[p & -2]);
4851: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
4852: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
4853: VideoController.vcnPal32G8[p] :
4854: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2] :
4855: p == 1 ?
4856: VideoController.vcnPal32G8[0] :
4857: (p & 1) == 0 ?
4858: VideoController.vcnPal32G8[p] :
4859: VideoController.vcnPal32G8[p & -2]);
4860: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
4861: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
4862: VideoController.vcnPal32G8[p] :
4863: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2] :
4864: p == 1 ?
4865: VideoController.vcnPal32G8[0] :
4866: (p & 1) == 0 ?
4867: VideoController.vcnPal32G8[p] :
4868: VideoController.vcnPal32G8[p & -2]);
4869: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
4870: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
4871: VideoController.vcnPal32G8[p] :
4872: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2] :
4873: p == 1 ?
4874: VideoController.vcnPal32G8[0] :
4875: (p & 1) == 0 ?
4876: VideoController.vcnPal32G8[p] :
4877: VideoController.vcnPal32G8[p & -2]);
4878: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
4879: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
4880: VideoController.vcnPal32G8[p] :
4881: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2] :
4882: p == 1 ?
4883: VideoController.vcnPal32G8[0] :
4884: (p & 1) == 0 ?
4885: VideoController.vcnPal32G8[p] :
4886: VideoController.vcnPal32G8[p & -2]);
4887: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
4888: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
4889: VideoController.vcnPal32G8[p] :
4890: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2] :
4891: p == 1 ?
4892: VideoController.vcnPal32G8[0] :
4893: (p & 1) == 0 ?
4894: VideoController.vcnPal32G8[p] :
4895: VideoController.vcnPal32G8[p & -2]);
4896: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
4897: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
4898: VideoController.vcnPal32G8[p] :
4899: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2] :
4900: p == 1 ?
4901: VideoController.vcnPal32G8[0] :
4902: (p & 1) == 0 ?
4903: VideoController.vcnPal32G8[p] :
4904: VideoController.vcnPal32G8[p & -2]);
4905: gx1st += 16;
4906: gx2nd += 16;
4907: gx3rd += 16;
4908: da += 8;
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:
4945:
4946:
4947: E3_XHCT {
4948: @Override public void drawRaster (int src, int dst, boolean rh) {
4949: int pn = VideoController.vcnReg2Curr & 3;
4950: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
4951: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4952: pn = VideoController.vcnReg2Curr >> 2 & 3;
4953: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
4954: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4955: pn = VideoController.vcnReg2Curr >> 4 & 3;
4956: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
4957: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
4958: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
4959: int db = da + XEiJ.pnlScreenWidth;
4960: if (rh) {
4961: int half = XEiJ.pnlScreenWidth >> 4 << 3;
4962: gx1st += half << 1;
4963: gx2nd += half << 1;
4964: gx3rd += half << 1;
4965: da += half;
4966: }
4967: while (da < db) {
4968: int p;
4969: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
4970: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
4971: VideoController.vcnPalTbl[
4972: VideoController.vcnMix2 (
4973: VideoController.vcnPal16G8[p],
4974: 0)] :
4975: VideoController.vcnPal32G8[p] :
4976: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
4977: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
4978: VideoController.vcnPalTbl[
4979: VideoController.vcnMix2 (
4980: VideoController.vcnPal16G8[p],
4981: 0)] :
4982: VideoController.vcnPal32G8[p] :
4983: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) & -2] & 1) != 0 ?
4984: VideoController.vcnPalTbl[
4985: VideoController.vcnMix2 (
4986: VideoController.vcnPal16G8[p],
4987: 0)] :
4988: VideoController.vcnPal32G8[p]);
4989: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
4990: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
4991: VideoController.vcnPalTbl[
4992: VideoController.vcnMix2 (
4993: VideoController.vcnPal16G8[p],
4994: 0)] :
4995: VideoController.vcnPal32G8[p] :
4996: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
4997: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
4998: VideoController.vcnPalTbl[
4999: VideoController.vcnMix2 (
5000: VideoController.vcnPal16G8[p],
5001: 0)] :
5002: VideoController.vcnPal32G8[p] :
5003: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) & -2] & 1) != 0 ?
5004: VideoController.vcnPalTbl[
5005: VideoController.vcnMix2 (
5006: VideoController.vcnPal16G8[p],
5007: 0)] :
5008: VideoController.vcnPal32G8[p]);
5009: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
5010: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5011: VideoController.vcnPalTbl[
5012: VideoController.vcnMix2 (
5013: VideoController.vcnPal16G8[p],
5014: 0)] :
5015: VideoController.vcnPal32G8[p] :
5016: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
5017: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5018: VideoController.vcnPalTbl[
5019: VideoController.vcnMix2 (
5020: VideoController.vcnPal16G8[p],
5021: 0)] :
5022: VideoController.vcnPal32G8[p] :
5023: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) & -2] & 1) != 0 ?
5024: VideoController.vcnPalTbl[
5025: VideoController.vcnMix2 (
5026: VideoController.vcnPal16G8[p],
5027: 0)] :
5028: VideoController.vcnPal32G8[p]);
5029: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
5030: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5031: VideoController.vcnPalTbl[
5032: VideoController.vcnMix2 (
5033: VideoController.vcnPal16G8[p],
5034: 0)] :
5035: VideoController.vcnPal32G8[p] :
5036: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
5037: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5038: VideoController.vcnPalTbl[
5039: VideoController.vcnMix2 (
5040: VideoController.vcnPal16G8[p],
5041: 0)] :
5042: VideoController.vcnPal32G8[p] :
5043: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) & -2] & 1) != 0 ?
5044: VideoController.vcnPalTbl[
5045: VideoController.vcnMix2 (
5046: VideoController.vcnPal16G8[p],
5047: 0)] :
5048: VideoController.vcnPal32G8[p]);
5049: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
5050: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5051: VideoController.vcnPalTbl[
5052: VideoController.vcnMix2 (
5053: VideoController.vcnPal16G8[p],
5054: 0)] :
5055: VideoController.vcnPal32G8[p] :
5056: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
5057: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5058: VideoController.vcnPalTbl[
5059: VideoController.vcnMix2 (
5060: VideoController.vcnPal16G8[p],
5061: 0)] :
5062: VideoController.vcnPal32G8[p] :
5063: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) & -2] & 1) != 0 ?
5064: VideoController.vcnPalTbl[
5065: VideoController.vcnMix2 (
5066: VideoController.vcnPal16G8[p],
5067: 0)] :
5068: VideoController.vcnPal32G8[p]);
5069: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
5070: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5071: VideoController.vcnPalTbl[
5072: VideoController.vcnMix2 (
5073: VideoController.vcnPal16G8[p],
5074: 0)] :
5075: VideoController.vcnPal32G8[p] :
5076: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
5077: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5078: VideoController.vcnPalTbl[
5079: VideoController.vcnMix2 (
5080: VideoController.vcnPal16G8[p],
5081: 0)] :
5082: VideoController.vcnPal32G8[p] :
5083: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) & -2] & 1) != 0 ?
5084: VideoController.vcnPalTbl[
5085: VideoController.vcnMix2 (
5086: VideoController.vcnPal16G8[p],
5087: 0)] :
5088: VideoController.vcnPal32G8[p]);
5089: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
5090: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5091: VideoController.vcnPalTbl[
5092: VideoController.vcnMix2 (
5093: VideoController.vcnPal16G8[p],
5094: 0)] :
5095: VideoController.vcnPal32G8[p] :
5096: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
5097: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5098: VideoController.vcnPalTbl[
5099: VideoController.vcnMix2 (
5100: VideoController.vcnPal16G8[p],
5101: 0)] :
5102: VideoController.vcnPal32G8[p] :
5103: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) & -2] & 1) != 0 ?
5104: VideoController.vcnPalTbl[
5105: VideoController.vcnMix2 (
5106: VideoController.vcnPal16G8[p],
5107: 0)] :
5108: VideoController.vcnPal32G8[p]);
5109: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
5110: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5111: VideoController.vcnPalTbl[
5112: VideoController.vcnMix2 (
5113: VideoController.vcnPal16G8[p],
5114: 0)] :
5115: VideoController.vcnPal32G8[p] :
5116: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
5117: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
5118: VideoController.vcnPalTbl[
5119: VideoController.vcnMix2 (
5120: VideoController.vcnPal16G8[p],
5121: 0)] :
5122: VideoController.vcnPal32G8[p] :
5123: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) & -2] & 1) != 0 ?
5124: VideoController.vcnPalTbl[
5125: VideoController.vcnMix2 (
5126: VideoController.vcnPal16G8[p],
5127: 0)] :
5128: VideoController.vcnPal32G8[p]);
5129: gx1st += 16;
5130: gx2nd += 16;
5131: gx3rd += 16;
5132: da += 8;
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:
5175:
5176:
5177: E3_XHCG {
5178: @Override public void drawRaster (int src, int dst, boolean rh) {
5179: int pn = VideoController.vcnReg2Curr & 3;
5180: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
5181: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5182: pn = VideoController.vcnReg2Curr >> 2 & 3;
5183: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
5184: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5185: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5186: pn = VideoController.vcnReg2Curr >> 4 & 3;
5187: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
5188: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5189: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
5190: int db = da + XEiJ.pnlScreenWidth;
5191: if (rh) {
5192: int half = XEiJ.pnlScreenWidth >> 4 << 3;
5193: gx1st += half << 1;
5194: gx2nd += half << 1;
5195: gx3rd += half << 1;
5196: da += half;
5197: }
5198: while (da < db) {
5199: int p, q;
5200: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
5201: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5202: VideoController.vcnPalTbl[
5203: VideoController.vcnMix2 (
5204: q,
5205: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
5206: (p & 1) != 0 ?
5207: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
5208: VideoController.vcnPal32G8[p] :
5209: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
5210: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5211: VideoController.vcnPalTbl[
5212: VideoController.vcnMix2 (
5213: q,
5214: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
5215: VideoController.vcnPal32G8[p] :
5216: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) & -2]) & 1) != 0 ?
5217: VideoController.vcnPalTbl[
5218: VideoController.vcnMix2 (
5219: p,
5220: VideoController.vcnPal16G8[1])] :
5221: (q & 1) != 0 ?
5222: VideoController.vcnPal32G8[1] :
5223: VideoController.vcnPal32G8[q]);
5224: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
5225: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5226: VideoController.vcnPalTbl[
5227: VideoController.vcnMix2 (
5228: q,
5229: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
5230: (p & 1) != 0 ?
5231: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
5232: VideoController.vcnPal32G8[p] :
5233: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
5234: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5235: VideoController.vcnPalTbl[
5236: VideoController.vcnMix2 (
5237: q,
5238: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
5239: VideoController.vcnPal32G8[p] :
5240: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) & -2]) & 1) != 0 ?
5241: VideoController.vcnPalTbl[
5242: VideoController.vcnMix2 (
5243: p,
5244: VideoController.vcnPal16G8[1])] :
5245: (q & 1) != 0 ?
5246: VideoController.vcnPal32G8[1] :
5247: VideoController.vcnPal32G8[q]);
5248: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
5249: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5250: VideoController.vcnPalTbl[
5251: VideoController.vcnMix2 (
5252: q,
5253: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
5254: (p & 1) != 0 ?
5255: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
5256: VideoController.vcnPal32G8[p] :
5257: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
5258: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5259: VideoController.vcnPalTbl[
5260: VideoController.vcnMix2 (
5261: q,
5262: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
5263: VideoController.vcnPal32G8[p] :
5264: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) & -2]) & 1) != 0 ?
5265: VideoController.vcnPalTbl[
5266: VideoController.vcnMix2 (
5267: p,
5268: VideoController.vcnPal16G8[1])] :
5269: (q & 1) != 0 ?
5270: VideoController.vcnPal32G8[1] :
5271: VideoController.vcnPal32G8[q]);
5272: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
5273: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5274: VideoController.vcnPalTbl[
5275: VideoController.vcnMix2 (
5276: q,
5277: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
5278: (p & 1) != 0 ?
5279: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
5280: VideoController.vcnPal32G8[p] :
5281: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
5282: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5283: VideoController.vcnPalTbl[
5284: VideoController.vcnMix2 (
5285: q,
5286: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
5287: VideoController.vcnPal32G8[p] :
5288: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) & -2]) & 1) != 0 ?
5289: VideoController.vcnPalTbl[
5290: VideoController.vcnMix2 (
5291: p,
5292: VideoController.vcnPal16G8[1])] :
5293: (q & 1) != 0 ?
5294: VideoController.vcnPal32G8[1] :
5295: VideoController.vcnPal32G8[q]);
5296: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
5297: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5298: VideoController.vcnPalTbl[
5299: VideoController.vcnMix2 (
5300: q,
5301: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
5302: (p & 1) != 0 ?
5303: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
5304: VideoController.vcnPal32G8[p] :
5305: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
5306: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5307: VideoController.vcnPalTbl[
5308: VideoController.vcnMix2 (
5309: q,
5310: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
5311: VideoController.vcnPal32G8[p] :
5312: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) & -2]) & 1) != 0 ?
5313: VideoController.vcnPalTbl[
5314: VideoController.vcnMix2 (
5315: p,
5316: VideoController.vcnPal16G8[1])] :
5317: (q & 1) != 0 ?
5318: VideoController.vcnPal32G8[1] :
5319: VideoController.vcnPal32G8[q]);
5320: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
5321: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5322: VideoController.vcnPalTbl[
5323: VideoController.vcnMix2 (
5324: q,
5325: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
5326: (p & 1) != 0 ?
5327: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
5328: VideoController.vcnPal32G8[p] :
5329: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
5330: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5331: VideoController.vcnPalTbl[
5332: VideoController.vcnMix2 (
5333: q,
5334: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
5335: VideoController.vcnPal32G8[p] :
5336: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) & -2]) & 1) != 0 ?
5337: VideoController.vcnPalTbl[
5338: VideoController.vcnMix2 (
5339: p,
5340: VideoController.vcnPal16G8[1])] :
5341: (q & 1) != 0 ?
5342: VideoController.vcnPal32G8[1] :
5343: VideoController.vcnPal32G8[q]);
5344: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
5345: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5346: VideoController.vcnPalTbl[
5347: VideoController.vcnMix2 (
5348: q,
5349: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
5350: (p & 1) != 0 ?
5351: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
5352: VideoController.vcnPal32G8[p] :
5353: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
5354: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5355: VideoController.vcnPalTbl[
5356: VideoController.vcnMix2 (
5357: q,
5358: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
5359: VideoController.vcnPal32G8[p] :
5360: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) & -2]) & 1) != 0 ?
5361: VideoController.vcnPalTbl[
5362: VideoController.vcnMix2 (
5363: p,
5364: VideoController.vcnPal16G8[1])] :
5365: (q & 1) != 0 ?
5366: VideoController.vcnPal32G8[1] :
5367: VideoController.vcnPal32G8[q]);
5368: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
5369: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5370: VideoController.vcnPalTbl[
5371: VideoController.vcnMix2 (
5372: q,
5373: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
5374: (p & 1) != 0 ?
5375: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
5376: VideoController.vcnPal32G8[p] :
5377: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
5378: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5379: VideoController.vcnPalTbl[
5380: VideoController.vcnMix2 (
5381: q,
5382: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
5383: VideoController.vcnPal32G8[p] :
5384: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) & -2]) & 1) != 0 ?
5385: VideoController.vcnPalTbl[
5386: VideoController.vcnMix2 (
5387: p,
5388: VideoController.vcnPal16G8[1])] :
5389: (q & 1) != 0 ?
5390: VideoController.vcnPal32G8[1] :
5391: VideoController.vcnPal32G8[q]);
5392: gx1st += 16;
5393: gx2nd += 16;
5394: gx3rd += 16;
5395: da += 8;
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:
5438:
5439:
5440: E3_XHCGT {
5441: @Override public void drawRaster (int src, int dst, boolean rh) {
5442: int pn = VideoController.vcnReg2Curr & 3;
5443: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
5444: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5445: pn = VideoController.vcnReg2Curr >> 2 & 3;
5446: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
5447: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5448: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5449: pn = VideoController.vcnReg2Curr >> 4 & 3;
5450: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
5451: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5452: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
5453: int db = da + XEiJ.pnlScreenWidth;
5454: if (rh) {
5455: int half = XEiJ.pnlScreenWidth >> 4 << 3;
5456: gx1st += half << 1;
5457: gx2nd += half << 1;
5458: gx3rd += half << 1;
5459: da += half;
5460: }
5461: while (da < db) {
5462: int p, q;
5463: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
5464: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5465: VideoController.vcnPalTbl[
5466: VideoController.vcnMix2 (
5467: VideoController.vcnMix2 (
5468: q,
5469: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
5470: 0)] :
5471: (p & 1) != 0 ?
5472: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
5473: VideoController.vcnPal32G8[p] :
5474: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
5475: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5476: VideoController.vcnPalTbl[
5477: VideoController.vcnMix2 (
5478: VideoController.vcnMix2 (
5479: q,
5480: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
5481: 0)] :
5482: VideoController.vcnPal32G8[p] :
5483: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) & -2]) & 1) != 0 ?
5484: VideoController.vcnPalTbl[
5485: VideoController.vcnMix2 (
5486: VideoController.vcnMix2 (
5487: p,
5488: VideoController.vcnPal16G8[1]),
5489: 0)] :
5490: (q & 1) != 0 ?
5491: VideoController.vcnPal32G8[1] :
5492: VideoController.vcnPal32G8[q]);
5493: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
5494: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5495: VideoController.vcnPalTbl[
5496: VideoController.vcnMix2 (
5497: VideoController.vcnMix2 (
5498: q,
5499: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
5500: 0)] :
5501: (p & 1) != 0 ?
5502: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
5503: VideoController.vcnPal32G8[p] :
5504: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
5505: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5506: VideoController.vcnPalTbl[
5507: VideoController.vcnMix2 (
5508: VideoController.vcnMix2 (
5509: q,
5510: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
5511: 0)] :
5512: VideoController.vcnPal32G8[p] :
5513: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) & -2]) & 1) != 0 ?
5514: VideoController.vcnPalTbl[
5515: VideoController.vcnMix2 (
5516: VideoController.vcnMix2 (
5517: p,
5518: VideoController.vcnPal16G8[1]),
5519: 0)] :
5520: (q & 1) != 0 ?
5521: VideoController.vcnPal32G8[1] :
5522: VideoController.vcnPal32G8[q]);
5523: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
5524: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5525: VideoController.vcnPalTbl[
5526: VideoController.vcnMix2 (
5527: VideoController.vcnMix2 (
5528: q,
5529: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
5530: 0)] :
5531: (p & 1) != 0 ?
5532: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
5533: VideoController.vcnPal32G8[p] :
5534: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
5535: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5536: VideoController.vcnPalTbl[
5537: VideoController.vcnMix2 (
5538: VideoController.vcnMix2 (
5539: q,
5540: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
5541: 0)] :
5542: VideoController.vcnPal32G8[p] :
5543: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) & -2]) & 1) != 0 ?
5544: VideoController.vcnPalTbl[
5545: VideoController.vcnMix2 (
5546: VideoController.vcnMix2 (
5547: p,
5548: VideoController.vcnPal16G8[1]),
5549: 0)] :
5550: (q & 1) != 0 ?
5551: VideoController.vcnPal32G8[1] :
5552: VideoController.vcnPal32G8[q]);
5553: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
5554: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5555: VideoController.vcnPalTbl[
5556: VideoController.vcnMix2 (
5557: VideoController.vcnMix2 (
5558: q,
5559: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
5560: 0)] :
5561: (p & 1) != 0 ?
5562: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
5563: VideoController.vcnPal32G8[p] :
5564: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
5565: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5566: VideoController.vcnPalTbl[
5567: VideoController.vcnMix2 (
5568: VideoController.vcnMix2 (
5569: q,
5570: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
5571: 0)] :
5572: VideoController.vcnPal32G8[p] :
5573: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) & -2]) & 1) != 0 ?
5574: VideoController.vcnPalTbl[
5575: VideoController.vcnMix2 (
5576: VideoController.vcnMix2 (
5577: p,
5578: VideoController.vcnPal16G8[1]),
5579: 0)] :
5580: (q & 1) != 0 ?
5581: VideoController.vcnPal32G8[1] :
5582: VideoController.vcnPal32G8[q]);
5583: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
5584: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5585: VideoController.vcnPalTbl[
5586: VideoController.vcnMix2 (
5587: VideoController.vcnMix2 (
5588: q,
5589: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
5590: 0)] :
5591: (p & 1) != 0 ?
5592: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
5593: VideoController.vcnPal32G8[p] :
5594: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
5595: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5596: VideoController.vcnPalTbl[
5597: VideoController.vcnMix2 (
5598: VideoController.vcnMix2 (
5599: q,
5600: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
5601: 0)] :
5602: VideoController.vcnPal32G8[p] :
5603: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) & -2]) & 1) != 0 ?
5604: VideoController.vcnPalTbl[
5605: VideoController.vcnMix2 (
5606: VideoController.vcnMix2 (
5607: p,
5608: VideoController.vcnPal16G8[1]),
5609: 0)] :
5610: (q & 1) != 0 ?
5611: VideoController.vcnPal32G8[1] :
5612: VideoController.vcnPal32G8[q]);
5613: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
5614: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5615: VideoController.vcnPalTbl[
5616: VideoController.vcnMix2 (
5617: VideoController.vcnMix2 (
5618: q,
5619: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
5620: 0)] :
5621: (p & 1) != 0 ?
5622: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
5623: VideoController.vcnPal32G8[p] :
5624: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
5625: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5626: VideoController.vcnPalTbl[
5627: VideoController.vcnMix2 (
5628: VideoController.vcnMix2 (
5629: q,
5630: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
5631: 0)] :
5632: VideoController.vcnPal32G8[p] :
5633: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) & -2]) & 1) != 0 ?
5634: VideoController.vcnPalTbl[
5635: VideoController.vcnMix2 (
5636: VideoController.vcnMix2 (
5637: p,
5638: VideoController.vcnPal16G8[1]),
5639: 0)] :
5640: (q & 1) != 0 ?
5641: VideoController.vcnPal32G8[1] :
5642: VideoController.vcnPal32G8[q]);
5643: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
5644: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5645: VideoController.vcnPalTbl[
5646: VideoController.vcnMix2 (
5647: VideoController.vcnMix2 (
5648: q,
5649: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
5650: 0)] :
5651: (p & 1) != 0 ?
5652: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
5653: VideoController.vcnPal32G8[p] :
5654: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
5655: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5656: VideoController.vcnPalTbl[
5657: VideoController.vcnMix2 (
5658: VideoController.vcnMix2 (
5659: q,
5660: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
5661: 0)] :
5662: VideoController.vcnPal32G8[p] :
5663: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) & -2]) & 1) != 0 ?
5664: VideoController.vcnPalTbl[
5665: VideoController.vcnMix2 (
5666: VideoController.vcnMix2 (
5667: p,
5668: VideoController.vcnPal16G8[1]),
5669: 0)] :
5670: (q & 1) != 0 ?
5671: VideoController.vcnPal32G8[1] :
5672: VideoController.vcnPal32G8[q]);
5673: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
5674: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5675: VideoController.vcnPalTbl[
5676: VideoController.vcnMix2 (
5677: VideoController.vcnMix2 (
5678: q,
5679: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
5680: 0)] :
5681: (p & 1) != 0 ?
5682: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
5683: VideoController.vcnPal32G8[p] :
5684: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
5685: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
5686: VideoController.vcnPalTbl[
5687: VideoController.vcnMix2 (
5688: VideoController.vcnMix2 (
5689: q,
5690: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
5691: 0)] :
5692: VideoController.vcnPal32G8[p] :
5693: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) & -2]) & 1) != 0 ?
5694: VideoController.vcnPalTbl[
5695: VideoController.vcnMix2 (
5696: VideoController.vcnMix2 (
5697: p,
5698: VideoController.vcnPal16G8[1]),
5699: 0)] :
5700: (q & 1) != 0 ?
5701: VideoController.vcnPal32G8[1] :
5702: VideoController.vcnPal32G8[q]);
5703: gx1st += 16;
5704: gx2nd += 16;
5705: gx3rd += 16;
5706: da += 8;
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:
5738:
5739:
5740: E3_XHPT {
5741: @Override public void drawRaster (int src, int dst, boolean rh) {
5742: int pn = VideoController.vcnReg2Curr & 3;
5743: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
5744: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5745: pn = VideoController.vcnReg2Curr >> 2 & 3;
5746: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
5747: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5748: pn = VideoController.vcnReg2Curr >> 4 & 3;
5749: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
5750: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5751: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
5752: int db = da + XEiJ.pnlScreenWidth;
5753: if (rh) {
5754: int half = XEiJ.pnlScreenWidth >> 4 << 3;
5755: gx1st += half << 1;
5756: gx2nd += half << 1;
5757: gx3rd += half << 1;
5758: da += half;
5759: }
5760: while (da < db) {
5761: int p;
5762: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
5763: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
5764: VideoController.vcnPal32G8[p] :
5765: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2] :
5766: p == 1 ?
5767: VideoController.vcnPal32G8[0] :
5768: (p & 1) == 0 ?
5769: VideoController.vcnPal32G8[p] :
5770: VideoController.vcnPalTbl[
5771: VideoController.vcnMix2 (
5772: VideoController.vcnPal16G8[p & -2],
5773: 0)]);
5774: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
5775: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
5776: VideoController.vcnPal32G8[p] :
5777: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2] :
5778: p == 1 ?
5779: VideoController.vcnPal32G8[0] :
5780: (p & 1) == 0 ?
5781: VideoController.vcnPal32G8[p] :
5782: VideoController.vcnPalTbl[
5783: VideoController.vcnMix2 (
5784: VideoController.vcnPal16G8[p & -2],
5785: 0)]);
5786: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
5787: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
5788: VideoController.vcnPal32G8[p] :
5789: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2] :
5790: p == 1 ?
5791: VideoController.vcnPal32G8[0] :
5792: (p & 1) == 0 ?
5793: VideoController.vcnPal32G8[p] :
5794: VideoController.vcnPalTbl[
5795: VideoController.vcnMix2 (
5796: VideoController.vcnPal16G8[p & -2],
5797: 0)]);
5798: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
5799: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
5800: VideoController.vcnPal32G8[p] :
5801: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2] :
5802: p == 1 ?
5803: VideoController.vcnPal32G8[0] :
5804: (p & 1) == 0 ?
5805: VideoController.vcnPal32G8[p] :
5806: VideoController.vcnPalTbl[
5807: VideoController.vcnMix2 (
5808: VideoController.vcnPal16G8[p & -2],
5809: 0)]);
5810: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
5811: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
5812: VideoController.vcnPal32G8[p] :
5813: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2] :
5814: p == 1 ?
5815: VideoController.vcnPal32G8[0] :
5816: (p & 1) == 0 ?
5817: VideoController.vcnPal32G8[p] :
5818: VideoController.vcnPalTbl[
5819: VideoController.vcnMix2 (
5820: VideoController.vcnPal16G8[p & -2],
5821: 0)]);
5822: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
5823: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
5824: VideoController.vcnPal32G8[p] :
5825: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2] :
5826: p == 1 ?
5827: VideoController.vcnPal32G8[0] :
5828: (p & 1) == 0 ?
5829: VideoController.vcnPal32G8[p] :
5830: VideoController.vcnPalTbl[
5831: VideoController.vcnMix2 (
5832: VideoController.vcnPal16G8[p & -2],
5833: 0)]);
5834: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
5835: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
5836: VideoController.vcnPal32G8[p] :
5837: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2] :
5838: p == 1 ?
5839: VideoController.vcnPal32G8[0] :
5840: (p & 1) == 0 ?
5841: VideoController.vcnPal32G8[p] :
5842: VideoController.vcnPalTbl[
5843: VideoController.vcnMix2 (
5844: VideoController.vcnPal16G8[p & -2],
5845: 0)]);
5846: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
5847: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
5848: VideoController.vcnPal32G8[p] :
5849: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2] :
5850: p == 1 ?
5851: VideoController.vcnPal32G8[0] :
5852: (p & 1) == 0 ?
5853: VideoController.vcnPal32G8[p] :
5854: VideoController.vcnPalTbl[
5855: VideoController.vcnMix2 (
5856: VideoController.vcnPal16G8[p & -2],
5857: 0)]);
5858: gx1st += 16;
5859: gx2nd += 16;
5860: gx3rd += 16;
5861: da += 8;
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:
5893:
5894:
5895: E3_XHPG {
5896: @Override public void drawRaster (int src, int dst, boolean rh) {
5897: int pn = VideoController.vcnReg2Curr & 3;
5898: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
5899: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5900: pn = VideoController.vcnReg2Curr >> 2 & 3;
5901: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
5902: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5903: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5904: pn = VideoController.vcnReg2Curr >> 4 & 3;
5905: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
5906: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
5907: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
5908: int db = da + XEiJ.pnlScreenWidth;
5909: if (rh) {
5910: int half = XEiJ.pnlScreenWidth >> 4 << 3;
5911: gx1st += half << 1;
5912: gx2nd += half << 1;
5913: gx3rd += half << 1;
5914: da += half;
5915: }
5916: while (da < db) {
5917: int p;
5918: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
5919: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
5920: VideoController.vcnPal32G8[p] :
5921: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2] :
5922: p == 1 ?
5923: VideoController.vcnPal32G8[0] :
5924: (p & 1) == 0 ?
5925: VideoController.vcnPal32G8[p] :
5926: VideoController.vcnPalTbl[
5927: VideoController.vcnMix2 (
5928: VideoController.vcnPal16G8[p & -2],
5929: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])]);
5930: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
5931: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
5932: VideoController.vcnPal32G8[p] :
5933: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2] :
5934: p == 1 ?
5935: VideoController.vcnPal32G8[0] :
5936: (p & 1) == 0 ?
5937: VideoController.vcnPal32G8[p] :
5938: VideoController.vcnPalTbl[
5939: VideoController.vcnMix2 (
5940: VideoController.vcnPal16G8[p & -2],
5941: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])]);
5942: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
5943: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
5944: VideoController.vcnPal32G8[p] :
5945: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2] :
5946: p == 1 ?
5947: VideoController.vcnPal32G8[0] :
5948: (p & 1) == 0 ?
5949: VideoController.vcnPal32G8[p] :
5950: VideoController.vcnPalTbl[
5951: VideoController.vcnMix2 (
5952: VideoController.vcnPal16G8[p & -2],
5953: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])]);
5954: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
5955: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
5956: VideoController.vcnPal32G8[p] :
5957: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2] :
5958: p == 1 ?
5959: VideoController.vcnPal32G8[0] :
5960: (p & 1) == 0 ?
5961: VideoController.vcnPal32G8[p] :
5962: VideoController.vcnPalTbl[
5963: VideoController.vcnMix2 (
5964: VideoController.vcnPal16G8[p & -2],
5965: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])]);
5966: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
5967: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
5968: VideoController.vcnPal32G8[p] :
5969: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2] :
5970: p == 1 ?
5971: VideoController.vcnPal32G8[0] :
5972: (p & 1) == 0 ?
5973: VideoController.vcnPal32G8[p] :
5974: VideoController.vcnPalTbl[
5975: VideoController.vcnMix2 (
5976: VideoController.vcnPal16G8[p & -2],
5977: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])]);
5978: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
5979: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
5980: VideoController.vcnPal32G8[p] :
5981: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2] :
5982: p == 1 ?
5983: VideoController.vcnPal32G8[0] :
5984: (p & 1) == 0 ?
5985: VideoController.vcnPal32G8[p] :
5986: VideoController.vcnPalTbl[
5987: VideoController.vcnMix2 (
5988: VideoController.vcnPal16G8[p & -2],
5989: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])]);
5990: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
5991: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
5992: VideoController.vcnPal32G8[p] :
5993: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2] :
5994: p == 1 ?
5995: VideoController.vcnPal32G8[0] :
5996: (p & 1) == 0 ?
5997: VideoController.vcnPal32G8[p] :
5998: VideoController.vcnPalTbl[
5999: VideoController.vcnMix2 (
6000: VideoController.vcnPal16G8[p & -2],
6001: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])]);
6002: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
6003: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
6004: VideoController.vcnPal32G8[p] :
6005: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2] :
6006: p == 1 ?
6007: VideoController.vcnPal32G8[0] :
6008: (p & 1) == 0 ?
6009: VideoController.vcnPal32G8[p] :
6010: VideoController.vcnPalTbl[
6011: VideoController.vcnMix2 (
6012: VideoController.vcnPal16G8[p & -2],
6013: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])]);
6014: gx1st += 16;
6015: gx2nd += 16;
6016: gx3rd += 16;
6017: da += 8;
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:
6049:
6050:
6051: E3_XHPGT {
6052: @Override public void drawRaster (int src, int dst, boolean rh) {
6053: int pn = VideoController.vcnReg2Curr & 3;
6054: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6055: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6056: pn = VideoController.vcnReg2Curr >> 2 & 3;
6057: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6058: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6059: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6060: pn = VideoController.vcnReg2Curr >> 4 & 3;
6061: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6062: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6063: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6064: int db = da + XEiJ.pnlScreenWidth;
6065: if (rh) {
6066: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6067: gx1st += half << 1;
6068: gx2nd += half << 1;
6069: gx3rd += half << 1;
6070: da += half;
6071: }
6072: while (da < db) {
6073: int p;
6074: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
6075: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
6076: VideoController.vcnPal32G8[p] :
6077: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2] :
6078: p == 1 ?
6079: VideoController.vcnPal32G8[0] :
6080: (p & 1) == 0 ?
6081: VideoController.vcnPal32G8[p] :
6082: VideoController.vcnPalTbl[
6083: VideoController.vcnMix2 (
6084: VideoController.vcnMix2 (
6085: VideoController.vcnPal16G8[p & -2],
6086: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
6087: 0)]);
6088: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
6089: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
6090: VideoController.vcnPal32G8[p] :
6091: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2] :
6092: p == 1 ?
6093: VideoController.vcnPal32G8[0] :
6094: (p & 1) == 0 ?
6095: VideoController.vcnPal32G8[p] :
6096: VideoController.vcnPalTbl[
6097: VideoController.vcnMix2 (
6098: VideoController.vcnMix2 (
6099: VideoController.vcnPal16G8[p & -2],
6100: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
6101: 0)]);
6102: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
6103: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
6104: VideoController.vcnPal32G8[p] :
6105: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2] :
6106: p == 1 ?
6107: VideoController.vcnPal32G8[0] :
6108: (p & 1) == 0 ?
6109: VideoController.vcnPal32G8[p] :
6110: VideoController.vcnPalTbl[
6111: VideoController.vcnMix2 (
6112: VideoController.vcnMix2 (
6113: VideoController.vcnPal16G8[p & -2],
6114: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
6115: 0)]);
6116: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
6117: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
6118: VideoController.vcnPal32G8[p] :
6119: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2] :
6120: p == 1 ?
6121: VideoController.vcnPal32G8[0] :
6122: (p & 1) == 0 ?
6123: VideoController.vcnPal32G8[p] :
6124: VideoController.vcnPalTbl[
6125: VideoController.vcnMix2 (
6126: VideoController.vcnMix2 (
6127: VideoController.vcnPal16G8[p & -2],
6128: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
6129: 0)]);
6130: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
6131: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
6132: VideoController.vcnPal32G8[p] :
6133: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2] :
6134: p == 1 ?
6135: VideoController.vcnPal32G8[0] :
6136: (p & 1) == 0 ?
6137: VideoController.vcnPal32G8[p] :
6138: VideoController.vcnPalTbl[
6139: VideoController.vcnMix2 (
6140: VideoController.vcnMix2 (
6141: VideoController.vcnPal16G8[p & -2],
6142: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
6143: 0)]);
6144: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
6145: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
6146: VideoController.vcnPal32G8[p] :
6147: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2] :
6148: p == 1 ?
6149: VideoController.vcnPal32G8[0] :
6150: (p & 1) == 0 ?
6151: VideoController.vcnPal32G8[p] :
6152: VideoController.vcnPalTbl[
6153: VideoController.vcnMix2 (
6154: VideoController.vcnMix2 (
6155: VideoController.vcnPal16G8[p & -2],
6156: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
6157: 0)]);
6158: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
6159: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
6160: VideoController.vcnPal32G8[p] :
6161: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2] :
6162: p == 1 ?
6163: VideoController.vcnPal32G8[0] :
6164: (p & 1) == 0 ?
6165: VideoController.vcnPal32G8[p] :
6166: VideoController.vcnPalTbl[
6167: VideoController.vcnMix2 (
6168: VideoController.vcnMix2 (
6169: VideoController.vcnPal16G8[p & -2],
6170: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
6171: 0)]);
6172: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
6173: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
6174: VideoController.vcnPal32G8[p] :
6175: VideoController.vcnPal32G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2] :
6176: p == 1 ?
6177: VideoController.vcnPal32G8[0] :
6178: (p & 1) == 0 ?
6179: VideoController.vcnPal32G8[p] :
6180: VideoController.vcnPalTbl[
6181: VideoController.vcnMix2 (
6182: VideoController.vcnMix2 (
6183: VideoController.vcnPal16G8[p & -2],
6184: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
6185: 0)]);
6186: gx1st += 16;
6187: gx2nd += 16;
6188: gx3rd += 16;
6189: da += 8;
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:
6217:
6218:
6219: E3_A {
6220: @Override public void drawRaster (int src, int dst, boolean rh) {
6221: int pn = VideoController.vcnReg2Curr & 3;
6222: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6223: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6224: pn = VideoController.vcnReg2Curr >> 2 & 3;
6225: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6226: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6227: pn = VideoController.vcnReg2Curr >> 4 & 3;
6228: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6229: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6230: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6231: int db = da + XEiJ.pnlScreenWidth;
6232: if (rh) {
6233: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6234: gx1st += half << 1;
6235: gx2nd += half << 1;
6236: gx3rd += half << 1;
6237: da += half;
6238: }
6239: while (da < db) {
6240: int p;
6241: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
6242: (p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
6243: VideoController.vcnMix2 (
6244: VideoController.vcnPal16G8[p],
6245: VideoController.vcnPal16TS[0]) :
6246: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
6247: VideoController.vcnMix2 (
6248: VideoController.vcnPal16G8[p],
6249: VideoController.vcnPal16TS[0]) :
6250: VideoController.vcnMix2 (
6251: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd & 1023]],
6252: VideoController.vcnPal16TS[0])]);
6253: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
6254: (p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
6255: VideoController.vcnMix2 (
6256: VideoController.vcnPal16G8[p],
6257: VideoController.vcnPal16TS[0]) :
6258: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
6259: VideoController.vcnMix2 (
6260: VideoController.vcnPal16G8[p],
6261: VideoController.vcnPal16TS[0]) :
6262: VideoController.vcnMix2 (
6263: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]],
6264: VideoController.vcnPal16TS[0])]);
6265: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
6266: (p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
6267: VideoController.vcnMix2 (
6268: VideoController.vcnPal16G8[p],
6269: VideoController.vcnPal16TS[0]) :
6270: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
6271: VideoController.vcnMix2 (
6272: VideoController.vcnPal16G8[p],
6273: VideoController.vcnPal16TS[0]) :
6274: VideoController.vcnMix2 (
6275: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]],
6276: VideoController.vcnPal16TS[0])]);
6277: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
6278: (p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
6279: VideoController.vcnMix2 (
6280: VideoController.vcnPal16G8[p],
6281: VideoController.vcnPal16TS[0]) :
6282: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
6283: VideoController.vcnMix2 (
6284: VideoController.vcnPal16G8[p],
6285: VideoController.vcnPal16TS[0]) :
6286: VideoController.vcnMix2 (
6287: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]],
6288: VideoController.vcnPal16TS[0])]);
6289: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
6290: (p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
6291: VideoController.vcnMix2 (
6292: VideoController.vcnPal16G8[p],
6293: VideoController.vcnPal16TS[0]) :
6294: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
6295: VideoController.vcnMix2 (
6296: VideoController.vcnPal16G8[p],
6297: VideoController.vcnPal16TS[0]) :
6298: VideoController.vcnMix2 (
6299: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]],
6300: VideoController.vcnPal16TS[0])]);
6301: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
6302: (p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
6303: VideoController.vcnMix2 (
6304: VideoController.vcnPal16G8[p],
6305: VideoController.vcnPal16TS[0]) :
6306: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
6307: VideoController.vcnMix2 (
6308: VideoController.vcnPal16G8[p],
6309: VideoController.vcnPal16TS[0]) :
6310: VideoController.vcnMix2 (
6311: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]],
6312: VideoController.vcnPal16TS[0])]);
6313: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
6314: (p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
6315: VideoController.vcnMix2 (
6316: VideoController.vcnPal16G8[p],
6317: VideoController.vcnPal16TS[0]) :
6318: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
6319: VideoController.vcnMix2 (
6320: VideoController.vcnPal16G8[p],
6321: VideoController.vcnPal16TS[0]) :
6322: VideoController.vcnMix2 (
6323: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]],
6324: VideoController.vcnPal16TS[0])]);
6325: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
6326: (p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
6327: VideoController.vcnMix2 (
6328: VideoController.vcnPal16G8[p],
6329: VideoController.vcnPal16TS[0]) :
6330: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
6331: VideoController.vcnMix2 (
6332: VideoController.vcnPal16G8[p],
6333: VideoController.vcnPal16TS[0]) :
6334: VideoController.vcnMix2 (
6335: VideoController.vcnPal16G8[MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]],
6336: VideoController.vcnPal16TS[0])]);
6337: gx1st += 16;
6338: gx2nd += 16;
6339: gx3rd += 16;
6340: da += 8;
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:
6371:
6372:
6373: E4 {
6374: @Override public void drawRaster (int src, int dst, boolean rh) {
6375: int pn = VideoController.vcnReg2Curr & 3;
6376: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6377: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6378: pn = VideoController.vcnReg2Curr >> 2 & 3;
6379: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6380: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6381: pn = VideoController.vcnReg2Curr >> 4 & 3;
6382: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6383: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6384: pn = VideoController.vcnReg2Curr >> 6 & 3;
6385: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
6386: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6387: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6388: int db = da + XEiJ.pnlScreenWidth;
6389: if (rh) {
6390: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6391: gx1st += half << 1;
6392: gx2nd += half << 1;
6393: gx3rd += half << 1;
6394: gx4th += half << 1;
6395: da += half;
6396: }
6397: while (da < db) {
6398: int p;
6399: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
6400: VideoController.vcnPal32G8[p] :
6401: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
6402: VideoController.vcnPal32G8[p] :
6403: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
6404: VideoController.vcnPal32G8[p] :
6405: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023]]);
6406: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
6407: VideoController.vcnPal32G8[p] :
6408: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
6409: VideoController.vcnPal32G8[p] :
6410: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
6411: VideoController.vcnPal32G8[p] :
6412: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]]);
6413: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
6414: VideoController.vcnPal32G8[p] :
6415: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
6416: VideoController.vcnPal32G8[p] :
6417: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
6418: VideoController.vcnPal32G8[p] :
6419: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]]);
6420: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
6421: VideoController.vcnPal32G8[p] :
6422: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
6423: VideoController.vcnPal32G8[p] :
6424: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
6425: VideoController.vcnPal32G8[p] :
6426: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]]);
6427: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
6428: VideoController.vcnPal32G8[p] :
6429: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
6430: VideoController.vcnPal32G8[p] :
6431: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
6432: VideoController.vcnPal32G8[p] :
6433: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]]);
6434: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
6435: VideoController.vcnPal32G8[p] :
6436: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
6437: VideoController.vcnPal32G8[p] :
6438: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
6439: VideoController.vcnPal32G8[p] :
6440: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]]);
6441: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
6442: VideoController.vcnPal32G8[p] :
6443: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
6444: VideoController.vcnPal32G8[p] :
6445: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
6446: VideoController.vcnPal32G8[p] :
6447: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]]);
6448: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
6449: VideoController.vcnPal32G8[p] :
6450: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
6451: VideoController.vcnPal32G8[p] :
6452: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
6453: VideoController.vcnPal32G8[p] :
6454: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]]);
6455: gx1st += 16;
6456: gx2nd += 16;
6457: gx3rd += 16;
6458: gx4th += 16;
6459: da += 8;
6460: }
6461: }
6462: },
6463:
6464:
6465:
6466:
6467:
6468:
6469: XE4 {
6470: @Override public void drawRaster (int src, int dst, boolean rh) {
6471: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
6472:
6473: case 0b00010000:
6474: case 0b00010001:
6475: case 0b00010010:
6476: case 0b00010011:
6477: E4.drawRaster (src, dst, rh);
6478: break;
6479:
6480: case 0b00010100:
6481: case 0b00010101:
6482: case 0b00010110:
6483: case 0b00010111:
6484: E4_XWP.drawRaster (src, dst, rh);
6485: break;
6486:
6487: case 0b00011000:
6488: E4.drawRaster (src, dst, rh);
6489: break;
6490:
6491: case 0b00011001:
6492: E4_XHCT.drawRaster (src, dst, rh);
6493: break;
6494:
6495: case 0b00011010:
6496: E4_XHCG.drawRaster (src, dst, rh);
6497: break;
6498:
6499: case 0b00011011:
6500: E4_XHCGT.drawRaster (src, dst, rh);
6501: break;
6502:
6503: case 0b00011101:
6504: E4_XHPT.drawRaster (src, dst, rh);
6505: break;
6506:
6507: case 0b00011110:
6508: E4_XHPG.drawRaster (src, dst, rh);
6509: break;
6510:
6511: case 0b00011111:
6512: E4_XHPGT.drawRaster (src, dst, rh);
6513: break;
6514:
6515: case 0b01000000:
6516: case 0b01000001:
6517: case 0b01000010:
6518: case 0b01000011:
6519: case 0b01000100:
6520: case 0b01000101:
6521: case 0b01000110:
6522: case 0b01000111:
6523: case 0b01001000:
6524: case 0b01001001:
6525: case 0b01001010:
6526: case 0b01001011:
6527: case 0b01001100:
6528: case 0b01001101:
6529: case 0b01001110:
6530: case 0b01001111:
6531: case 0b01010000:
6532: case 0b01010001:
6533: case 0b01010010:
6534: case 0b01010011:
6535: case 0b01010100:
6536: case 0b01010101:
6537: case 0b01010110:
6538: case 0b01010111:
6539: case 0b01011000:
6540: case 0b01011001:
6541: case 0b01011010:
6542: case 0b01011011:
6543: case 0b01011100:
6544: case 0b01011101:
6545: case 0b01011110:
6546: case 0b01011111:
6547: E4_A.drawRaster (src, dst, rh);
6548: break;
6549: default:
6550: E4.drawRaster (src, dst, rh);
6551: VideoController.vcnReportUnimplemented (XE4);
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:
6586:
6587:
6588: E4_XWP {
6589: @Override public void drawRaster (int src, int dst, boolean rh) {
6590: int pn = VideoController.vcnReg2Curr & 3;
6591: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6592: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6593: pn = VideoController.vcnReg2Curr >> 2 & 3;
6594: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6595: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6596: pn = VideoController.vcnReg2Curr >> 4 & 3;
6597: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6598: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6599: pn = VideoController.vcnReg2Curr >> 6 & 3;
6600: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
6601: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6602: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6603: int db = da + XEiJ.pnlScreenWidth;
6604: if (rh) {
6605: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6606: gx1st += half << 1;
6607: gx2nd += half << 1;
6608: gx3rd += half << 1;
6609: gx4th += half << 1;
6610: da += half;
6611: }
6612: while (da < db) {
6613: int p;
6614: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
6615: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
6616: VideoController.vcnPal32G8[p] :
6617: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2) != 0 ?
6618: VideoController.vcnPal32G8[p] :
6619: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023] & -2] :
6620: p == 1 ?
6621: VideoController.vcnPal32G8[0] :
6622: (p & 1) == 0 ?
6623: VideoController.vcnPal32G8[p] :
6624: VideoController.vcnPal32G8[p & -2]);
6625: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
6626: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
6627: VideoController.vcnPal32G8[p] :
6628: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2) != 0 ?
6629: VideoController.vcnPal32G8[p] :
6630: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] & -2] :
6631: p == 1 ?
6632: VideoController.vcnPal32G8[0] :
6633: (p & 1) == 0 ?
6634: VideoController.vcnPal32G8[p] :
6635: VideoController.vcnPal32G8[p & -2]);
6636: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
6637: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
6638: VideoController.vcnPal32G8[p] :
6639: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2) != 0 ?
6640: VideoController.vcnPal32G8[p] :
6641: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] & -2] :
6642: p == 1 ?
6643: VideoController.vcnPal32G8[0] :
6644: (p & 1) == 0 ?
6645: VideoController.vcnPal32G8[p] :
6646: VideoController.vcnPal32G8[p & -2]);
6647: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
6648: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
6649: VideoController.vcnPal32G8[p] :
6650: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2) != 0 ?
6651: VideoController.vcnPal32G8[p] :
6652: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] & -2] :
6653: p == 1 ?
6654: VideoController.vcnPal32G8[0] :
6655: (p & 1) == 0 ?
6656: VideoController.vcnPal32G8[p] :
6657: VideoController.vcnPal32G8[p & -2]);
6658: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
6659: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
6660: VideoController.vcnPal32G8[p] :
6661: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2) != 0 ?
6662: VideoController.vcnPal32G8[p] :
6663: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] & -2] :
6664: p == 1 ?
6665: VideoController.vcnPal32G8[0] :
6666: (p & 1) == 0 ?
6667: VideoController.vcnPal32G8[p] :
6668: VideoController.vcnPal32G8[p & -2]);
6669: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
6670: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
6671: VideoController.vcnPal32G8[p] :
6672: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2) != 0 ?
6673: VideoController.vcnPal32G8[p] :
6674: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] & -2] :
6675: p == 1 ?
6676: VideoController.vcnPal32G8[0] :
6677: (p & 1) == 0 ?
6678: VideoController.vcnPal32G8[p] :
6679: VideoController.vcnPal32G8[p & -2]);
6680: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
6681: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
6682: VideoController.vcnPal32G8[p] :
6683: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2) != 0 ?
6684: VideoController.vcnPal32G8[p] :
6685: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] & -2] :
6686: p == 1 ?
6687: VideoController.vcnPal32G8[0] :
6688: (p & 1) == 0 ?
6689: VideoController.vcnPal32G8[p] :
6690: VideoController.vcnPal32G8[p & -2]);
6691: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
6692: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
6693: VideoController.vcnPal32G8[p] :
6694: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2) != 0 ?
6695: VideoController.vcnPal32G8[p] :
6696: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] & -2] :
6697: p == 1 ?
6698: VideoController.vcnPal32G8[0] :
6699: (p & 1) == 0 ?
6700: VideoController.vcnPal32G8[p] :
6701: VideoController.vcnPal32G8[p & -2]);
6702: gx1st += 16;
6703: gx2nd += 16;
6704: gx3rd += 16;
6705: gx4th += 16;
6706: da += 8;
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:
6749:
6750:
6751: E4_XHCT {
6752: @Override public void drawRaster (int src, int dst, boolean rh) {
6753: int pn = VideoController.vcnReg2Curr & 3;
6754: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
6755: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6756: pn = VideoController.vcnReg2Curr >> 2 & 3;
6757: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
6758: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6759: pn = VideoController.vcnReg2Curr >> 4 & 3;
6760: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
6761: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6762: pn = VideoController.vcnReg2Curr >> 6 & 3;
6763: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
6764: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
6765: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
6766: int db = da + XEiJ.pnlScreenWidth;
6767: if (rh) {
6768: int half = XEiJ.pnlScreenWidth >> 4 << 3;
6769: gx1st += half << 1;
6770: gx2nd += half << 1;
6771: gx3rd += half << 1;
6772: gx4th += half << 1;
6773: da += half;
6774: }
6775: while (da < db) {
6776: int p;
6777: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
6778: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6779: VideoController.vcnPalTbl[
6780: VideoController.vcnMix2 (
6781: VideoController.vcnPal16G8[p],
6782: 0)] :
6783: VideoController.vcnPal32G8[p] :
6784: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
6785: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6786: VideoController.vcnPalTbl[
6787: VideoController.vcnMix2 (
6788: VideoController.vcnPal16G8[p],
6789: 0)] :
6790: VideoController.vcnPal32G8[p] :
6791: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
6792: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6793: VideoController.vcnPalTbl[
6794: VideoController.vcnMix2 (
6795: VideoController.vcnPal16G8[p],
6796: 0)] :
6797: VideoController.vcnPal32G8[p] :
6798: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th & 1023]) & -2] & 1) != 0 ?
6799: VideoController.vcnPalTbl[
6800: VideoController.vcnMix2 (
6801: VideoController.vcnPal16G8[p],
6802: 0)] :
6803: VideoController.vcnPal32G8[p]);
6804: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
6805: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6806: VideoController.vcnPalTbl[
6807: VideoController.vcnMix2 (
6808: VideoController.vcnPal16G8[p],
6809: 0)] :
6810: VideoController.vcnPal32G8[p] :
6811: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
6812: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6813: VideoController.vcnPalTbl[
6814: VideoController.vcnMix2 (
6815: VideoController.vcnPal16G8[p],
6816: 0)] :
6817: VideoController.vcnPal32G8[p] :
6818: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
6819: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6820: VideoController.vcnPalTbl[
6821: VideoController.vcnMix2 (
6822: VideoController.vcnPal16G8[p],
6823: 0)] :
6824: VideoController.vcnPal32G8[p] :
6825: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]) & -2] & 1) != 0 ?
6826: VideoController.vcnPalTbl[
6827: VideoController.vcnMix2 (
6828: VideoController.vcnPal16G8[p],
6829: 0)] :
6830: VideoController.vcnPal32G8[p]);
6831: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
6832: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6833: VideoController.vcnPalTbl[
6834: VideoController.vcnMix2 (
6835: VideoController.vcnPal16G8[p],
6836: 0)] :
6837: VideoController.vcnPal32G8[p] :
6838: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
6839: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6840: VideoController.vcnPalTbl[
6841: VideoController.vcnMix2 (
6842: VideoController.vcnPal16G8[p],
6843: 0)] :
6844: VideoController.vcnPal32G8[p] :
6845: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
6846: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6847: VideoController.vcnPalTbl[
6848: VideoController.vcnMix2 (
6849: VideoController.vcnPal16G8[p],
6850: 0)] :
6851: VideoController.vcnPal32G8[p] :
6852: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]) & -2] & 1) != 0 ?
6853: VideoController.vcnPalTbl[
6854: VideoController.vcnMix2 (
6855: VideoController.vcnPal16G8[p],
6856: 0)] :
6857: VideoController.vcnPal32G8[p]);
6858: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
6859: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6860: VideoController.vcnPalTbl[
6861: VideoController.vcnMix2 (
6862: VideoController.vcnPal16G8[p],
6863: 0)] :
6864: VideoController.vcnPal32G8[p] :
6865: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
6866: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6867: VideoController.vcnPalTbl[
6868: VideoController.vcnMix2 (
6869: VideoController.vcnPal16G8[p],
6870: 0)] :
6871: VideoController.vcnPal32G8[p] :
6872: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
6873: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6874: VideoController.vcnPalTbl[
6875: VideoController.vcnMix2 (
6876: VideoController.vcnPal16G8[p],
6877: 0)] :
6878: VideoController.vcnPal32G8[p] :
6879: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]) & -2] & 1) != 0 ?
6880: VideoController.vcnPalTbl[
6881: VideoController.vcnMix2 (
6882: VideoController.vcnPal16G8[p],
6883: 0)] :
6884: VideoController.vcnPal32G8[p]);
6885: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
6886: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6887: VideoController.vcnPalTbl[
6888: VideoController.vcnMix2 (
6889: VideoController.vcnPal16G8[p],
6890: 0)] :
6891: VideoController.vcnPal32G8[p] :
6892: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
6893: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6894: VideoController.vcnPalTbl[
6895: VideoController.vcnMix2 (
6896: VideoController.vcnPal16G8[p],
6897: 0)] :
6898: VideoController.vcnPal32G8[p] :
6899: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
6900: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6901: VideoController.vcnPalTbl[
6902: VideoController.vcnMix2 (
6903: VideoController.vcnPal16G8[p],
6904: 0)] :
6905: VideoController.vcnPal32G8[p] :
6906: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]) & -2] & 1) != 0 ?
6907: VideoController.vcnPalTbl[
6908: VideoController.vcnMix2 (
6909: VideoController.vcnPal16G8[p],
6910: 0)] :
6911: VideoController.vcnPal32G8[p]);
6912: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
6913: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6914: VideoController.vcnPalTbl[
6915: VideoController.vcnMix2 (
6916: VideoController.vcnPal16G8[p],
6917: 0)] :
6918: VideoController.vcnPal32G8[p] :
6919: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
6920: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6921: VideoController.vcnPalTbl[
6922: VideoController.vcnMix2 (
6923: VideoController.vcnPal16G8[p],
6924: 0)] :
6925: VideoController.vcnPal32G8[p] :
6926: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
6927: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6928: VideoController.vcnPalTbl[
6929: VideoController.vcnMix2 (
6930: VideoController.vcnPal16G8[p],
6931: 0)] :
6932: VideoController.vcnPal32G8[p] :
6933: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]) & -2] & 1) != 0 ?
6934: VideoController.vcnPalTbl[
6935: VideoController.vcnMix2 (
6936: VideoController.vcnPal16G8[p],
6937: 0)] :
6938: VideoController.vcnPal32G8[p]);
6939: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
6940: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6941: VideoController.vcnPalTbl[
6942: VideoController.vcnMix2 (
6943: VideoController.vcnPal16G8[p],
6944: 0)] :
6945: VideoController.vcnPal32G8[p] :
6946: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
6947: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6948: VideoController.vcnPalTbl[
6949: VideoController.vcnMix2 (
6950: VideoController.vcnPal16G8[p],
6951: 0)] :
6952: VideoController.vcnPal32G8[p] :
6953: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
6954: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6955: VideoController.vcnPalTbl[
6956: VideoController.vcnMix2 (
6957: VideoController.vcnPal16G8[p],
6958: 0)] :
6959: VideoController.vcnPal32G8[p] :
6960: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]) & -2] & 1) != 0 ?
6961: VideoController.vcnPalTbl[
6962: VideoController.vcnMix2 (
6963: VideoController.vcnPal16G8[p],
6964: 0)] :
6965: VideoController.vcnPal32G8[p]);
6966: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
6967: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6968: VideoController.vcnPalTbl[
6969: VideoController.vcnMix2 (
6970: VideoController.vcnPal16G8[p],
6971: 0)] :
6972: VideoController.vcnPal32G8[p] :
6973: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
6974: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6975: VideoController.vcnPalTbl[
6976: VideoController.vcnMix2 (
6977: VideoController.vcnPal16G8[p],
6978: 0)] :
6979: VideoController.vcnPal32G8[p] :
6980: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
6981: (VideoController.vcnPal16G8[p & -2] & 1) != 0 ?
6982: VideoController.vcnPalTbl[
6983: VideoController.vcnMix2 (
6984: VideoController.vcnPal16G8[p],
6985: 0)] :
6986: VideoController.vcnPal32G8[p] :
6987: (VideoController.vcnPal16G8[(p = MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]) & -2] & 1) != 0 ?
6988: VideoController.vcnPalTbl[
6989: VideoController.vcnMix2 (
6990: VideoController.vcnPal16G8[p],
6991: 0)] :
6992: VideoController.vcnPal32G8[p]);
6993: gx1st += 16;
6994: gx2nd += 16;
6995: gx3rd += 16;
6996: gx4th += 16;
6997: da += 8;
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:
7049:
7050:
7051: E4_XHCG {
7052: @Override public void drawRaster (int src, int dst, boolean rh) {
7053: int pn = VideoController.vcnReg2Curr & 3;
7054: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
7055: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7056: pn = VideoController.vcnReg2Curr >> 2 & 3;
7057: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
7058: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7059: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7060: pn = VideoController.vcnReg2Curr >> 4 & 3;
7061: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
7062: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7063: pn = VideoController.vcnReg2Curr >> 6 & 3;
7064: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
7065: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7066: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
7067: int db = da + XEiJ.pnlScreenWidth;
7068: if (rh) {
7069: int half = XEiJ.pnlScreenWidth >> 4 << 3;
7070: gx1st += half << 1;
7071: gx2nd += half << 1;
7072: gx3rd += half << 1;
7073: gx4th += half << 1;
7074: da += half;
7075: }
7076: while (da < db) {
7077: int p, q;
7078: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
7079: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7080: VideoController.vcnPalTbl[
7081: VideoController.vcnMix2 (
7082: q,
7083: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
7084: (p & 1) != 0 ?
7085: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
7086: VideoController.vcnPal32G8[p] :
7087: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
7088: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7089: VideoController.vcnPalTbl[
7090: VideoController.vcnMix2 (
7091: q,
7092: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])] :
7093: VideoController.vcnPal32G8[p] :
7094: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
7095: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7096: VideoController.vcnPalTbl[
7097: VideoController.vcnMix2 (
7098: q,
7099: VideoController.vcnPal16G8[1])] :
7100: (p & 1) != 0 ?
7101: VideoController.vcnPal32G8[1] :
7102: VideoController.vcnPal32G8[p] :
7103: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th & 1023]) & -2]) & 1) != 0 ?
7104: VideoController.vcnPalTbl[
7105: VideoController.vcnMix2 (
7106: p,
7107: VideoController.vcnPal16G8[1])] :
7108: (q & 1) != 0 ?
7109: VideoController.vcnPal32G8[1] :
7110: VideoController.vcnPal32G8[q]);
7111: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
7112: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7113: VideoController.vcnPalTbl[
7114: VideoController.vcnMix2 (
7115: q,
7116: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
7117: (p & 1) != 0 ?
7118: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
7119: VideoController.vcnPal32G8[p] :
7120: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
7121: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7122: VideoController.vcnPalTbl[
7123: VideoController.vcnMix2 (
7124: q,
7125: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])] :
7126: VideoController.vcnPal32G8[p] :
7127: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
7128: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7129: VideoController.vcnPalTbl[
7130: VideoController.vcnMix2 (
7131: q,
7132: VideoController.vcnPal16G8[1])] :
7133: (p & 1) != 0 ?
7134: VideoController.vcnPal32G8[1] :
7135: VideoController.vcnPal32G8[p] :
7136: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]) & -2]) & 1) != 0 ?
7137: VideoController.vcnPalTbl[
7138: VideoController.vcnMix2 (
7139: p,
7140: VideoController.vcnPal16G8[1])] :
7141: (q & 1) != 0 ?
7142: VideoController.vcnPal32G8[1] :
7143: VideoController.vcnPal32G8[q]);
7144: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
7145: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7146: VideoController.vcnPalTbl[
7147: VideoController.vcnMix2 (
7148: q,
7149: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
7150: (p & 1) != 0 ?
7151: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
7152: VideoController.vcnPal32G8[p] :
7153: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
7154: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7155: VideoController.vcnPalTbl[
7156: VideoController.vcnMix2 (
7157: q,
7158: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])] :
7159: VideoController.vcnPal32G8[p] :
7160: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
7161: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7162: VideoController.vcnPalTbl[
7163: VideoController.vcnMix2 (
7164: q,
7165: VideoController.vcnPal16G8[1])] :
7166: (p & 1) != 0 ?
7167: VideoController.vcnPal32G8[1] :
7168: VideoController.vcnPal32G8[p] :
7169: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]) & -2]) & 1) != 0 ?
7170: VideoController.vcnPalTbl[
7171: VideoController.vcnMix2 (
7172: p,
7173: VideoController.vcnPal16G8[1])] :
7174: (q & 1) != 0 ?
7175: VideoController.vcnPal32G8[1] :
7176: VideoController.vcnPal32G8[q]);
7177: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
7178: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7179: VideoController.vcnPalTbl[
7180: VideoController.vcnMix2 (
7181: q,
7182: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
7183: (p & 1) != 0 ?
7184: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
7185: VideoController.vcnPal32G8[p] :
7186: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
7187: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7188: VideoController.vcnPalTbl[
7189: VideoController.vcnMix2 (
7190: q,
7191: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])] :
7192: VideoController.vcnPal32G8[p] :
7193: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
7194: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7195: VideoController.vcnPalTbl[
7196: VideoController.vcnMix2 (
7197: q,
7198: VideoController.vcnPal16G8[1])] :
7199: (p & 1) != 0 ?
7200: VideoController.vcnPal32G8[1] :
7201: VideoController.vcnPal32G8[p] :
7202: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]) & -2]) & 1) != 0 ?
7203: VideoController.vcnPalTbl[
7204: VideoController.vcnMix2 (
7205: p,
7206: VideoController.vcnPal16G8[1])] :
7207: (q & 1) != 0 ?
7208: VideoController.vcnPal32G8[1] :
7209: VideoController.vcnPal32G8[q]);
7210: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
7211: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7212: VideoController.vcnPalTbl[
7213: VideoController.vcnMix2 (
7214: q,
7215: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
7216: (p & 1) != 0 ?
7217: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
7218: VideoController.vcnPal32G8[p] :
7219: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
7220: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7221: VideoController.vcnPalTbl[
7222: VideoController.vcnMix2 (
7223: q,
7224: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])] :
7225: VideoController.vcnPal32G8[p] :
7226: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
7227: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7228: VideoController.vcnPalTbl[
7229: VideoController.vcnMix2 (
7230: q,
7231: VideoController.vcnPal16G8[1])] :
7232: (p & 1) != 0 ?
7233: VideoController.vcnPal32G8[1] :
7234: VideoController.vcnPal32G8[p] :
7235: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]) & -2]) & 1) != 0 ?
7236: VideoController.vcnPalTbl[
7237: VideoController.vcnMix2 (
7238: p,
7239: VideoController.vcnPal16G8[1])] :
7240: (q & 1) != 0 ?
7241: VideoController.vcnPal32G8[1] :
7242: VideoController.vcnPal32G8[q]);
7243: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
7244: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7245: VideoController.vcnPalTbl[
7246: VideoController.vcnMix2 (
7247: q,
7248: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
7249: (p & 1) != 0 ?
7250: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
7251: VideoController.vcnPal32G8[p] :
7252: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
7253: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7254: VideoController.vcnPalTbl[
7255: VideoController.vcnMix2 (
7256: q,
7257: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])] :
7258: VideoController.vcnPal32G8[p] :
7259: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
7260: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7261: VideoController.vcnPalTbl[
7262: VideoController.vcnMix2 (
7263: q,
7264: VideoController.vcnPal16G8[1])] :
7265: (p & 1) != 0 ?
7266: VideoController.vcnPal32G8[1] :
7267: VideoController.vcnPal32G8[p] :
7268: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]) & -2]) & 1) != 0 ?
7269: VideoController.vcnPalTbl[
7270: VideoController.vcnMix2 (
7271: p,
7272: VideoController.vcnPal16G8[1])] :
7273: (q & 1) != 0 ?
7274: VideoController.vcnPal32G8[1] :
7275: VideoController.vcnPal32G8[q]);
7276: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
7277: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7278: VideoController.vcnPalTbl[
7279: VideoController.vcnMix2 (
7280: q,
7281: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
7282: (p & 1) != 0 ?
7283: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
7284: VideoController.vcnPal32G8[p] :
7285: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
7286: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7287: VideoController.vcnPalTbl[
7288: VideoController.vcnMix2 (
7289: q,
7290: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])] :
7291: VideoController.vcnPal32G8[p] :
7292: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
7293: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7294: VideoController.vcnPalTbl[
7295: VideoController.vcnMix2 (
7296: q,
7297: VideoController.vcnPal16G8[1])] :
7298: (p & 1) != 0 ?
7299: VideoController.vcnPal32G8[1] :
7300: VideoController.vcnPal32G8[p] :
7301: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]) & -2]) & 1) != 0 ?
7302: VideoController.vcnPalTbl[
7303: VideoController.vcnMix2 (
7304: p,
7305: VideoController.vcnPal16G8[1])] :
7306: (q & 1) != 0 ?
7307: VideoController.vcnPal32G8[1] :
7308: VideoController.vcnPal32G8[q]);
7309: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
7310: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7311: VideoController.vcnPalTbl[
7312: VideoController.vcnMix2 (
7313: q,
7314: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
7315: (p & 1) != 0 ?
7316: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
7317: VideoController.vcnPal32G8[p] :
7318: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
7319: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7320: VideoController.vcnPalTbl[
7321: VideoController.vcnMix2 (
7322: q,
7323: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])] :
7324: VideoController.vcnPal32G8[p] :
7325: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
7326: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7327: VideoController.vcnPalTbl[
7328: VideoController.vcnMix2 (
7329: q,
7330: VideoController.vcnPal16G8[1])] :
7331: (p & 1) != 0 ?
7332: VideoController.vcnPal32G8[1] :
7333: VideoController.vcnPal32G8[p] :
7334: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]) & -2]) & 1) != 0 ?
7335: VideoController.vcnPalTbl[
7336: VideoController.vcnMix2 (
7337: p,
7338: VideoController.vcnPal16G8[1])] :
7339: (q & 1) != 0 ?
7340: VideoController.vcnPal32G8[1] :
7341: VideoController.vcnPal32G8[q]);
7342: gx1st += 16;
7343: gx2nd += 16;
7344: gx3rd += 16;
7345: gx4th += 16;
7346: da += 8;
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:
7398:
7399:
7400: E4_XHCGT {
7401: @Override public void drawRaster (int src, int dst, boolean rh) {
7402: int pn = VideoController.vcnReg2Curr & 3;
7403: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
7404: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7405: pn = VideoController.vcnReg2Curr >> 2 & 3;
7406: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
7407: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7408: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7409: pn = VideoController.vcnReg2Curr >> 4 & 3;
7410: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
7411: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7412: pn = VideoController.vcnReg2Curr >> 6 & 3;
7413: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
7414: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7415: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
7416: int db = da + XEiJ.pnlScreenWidth;
7417: if (rh) {
7418: int half = XEiJ.pnlScreenWidth >> 4 << 3;
7419: gx1st += half << 1;
7420: gx2nd += half << 1;
7421: gx3rd += half << 1;
7422: gx4th += half << 1;
7423: da += half;
7424: }
7425: while (da < db) {
7426: int p, q;
7427: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
7428: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7429: VideoController.vcnPalTbl[
7430: VideoController.vcnMix2 (
7431: VideoController.vcnMix2 (
7432: q,
7433: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
7434: 0)] :
7435: (p & 1) != 0 ?
7436: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1] :
7437: VideoController.vcnPal32G8[p] :
7438: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
7439: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7440: VideoController.vcnPalTbl[
7441: VideoController.vcnMix2 (
7442: VideoController.vcnMix2 (
7443: q,
7444: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
7445: 0)] :
7446: VideoController.vcnPal32G8[p] :
7447: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
7448: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7449: VideoController.vcnPalTbl[
7450: VideoController.vcnMix2 (
7451: VideoController.vcnMix2 (
7452: q,
7453: VideoController.vcnPal16G8[1]),
7454: 0)] :
7455: (p & 1) != 0 ?
7456: VideoController.vcnPal32G8[1] :
7457: VideoController.vcnPal32G8[p] :
7458: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th & 1023]) & -2]) & 1) != 0 ?
7459: VideoController.vcnPalTbl[
7460: VideoController.vcnMix2 (
7461: VideoController.vcnMix2 (
7462: p,
7463: VideoController.vcnPal16G8[1]),
7464: 0)] :
7465: (q & 1) != 0 ?
7466: VideoController.vcnPal32G8[1] :
7467: VideoController.vcnPal32G8[q]);
7468: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
7469: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7470: VideoController.vcnPalTbl[
7471: VideoController.vcnMix2 (
7472: VideoController.vcnMix2 (
7473: q,
7474: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
7475: 0)] :
7476: (p & 1) != 0 ?
7477: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1] :
7478: VideoController.vcnPal32G8[p] :
7479: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
7480: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7481: VideoController.vcnPalTbl[
7482: VideoController.vcnMix2 (
7483: VideoController.vcnMix2 (
7484: q,
7485: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
7486: 0)] :
7487: VideoController.vcnPal32G8[p] :
7488: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
7489: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7490: VideoController.vcnPalTbl[
7491: VideoController.vcnMix2 (
7492: VideoController.vcnMix2 (
7493: q,
7494: VideoController.vcnPal16G8[1]),
7495: 0)] :
7496: (p & 1) != 0 ?
7497: VideoController.vcnPal32G8[1] :
7498: VideoController.vcnPal32G8[p] :
7499: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]) & -2]) & 1) != 0 ?
7500: VideoController.vcnPalTbl[
7501: VideoController.vcnMix2 (
7502: VideoController.vcnMix2 (
7503: p,
7504: VideoController.vcnPal16G8[1]),
7505: 0)] :
7506: (q & 1) != 0 ?
7507: VideoController.vcnPal32G8[1] :
7508: VideoController.vcnPal32G8[q]);
7509: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
7510: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7511: VideoController.vcnPalTbl[
7512: VideoController.vcnMix2 (
7513: VideoController.vcnMix2 (
7514: q,
7515: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
7516: 0)] :
7517: (p & 1) != 0 ?
7518: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1] :
7519: VideoController.vcnPal32G8[p] :
7520: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
7521: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7522: VideoController.vcnPalTbl[
7523: VideoController.vcnMix2 (
7524: VideoController.vcnMix2 (
7525: q,
7526: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
7527: 0)] :
7528: VideoController.vcnPal32G8[p] :
7529: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
7530: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7531: VideoController.vcnPalTbl[
7532: VideoController.vcnMix2 (
7533: VideoController.vcnMix2 (
7534: q,
7535: VideoController.vcnPal16G8[1]),
7536: 0)] :
7537: (p & 1) != 0 ?
7538: VideoController.vcnPal32G8[1] :
7539: VideoController.vcnPal32G8[p] :
7540: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]) & -2]) & 1) != 0 ?
7541: VideoController.vcnPalTbl[
7542: VideoController.vcnMix2 (
7543: VideoController.vcnMix2 (
7544: p,
7545: VideoController.vcnPal16G8[1]),
7546: 0)] :
7547: (q & 1) != 0 ?
7548: VideoController.vcnPal32G8[1] :
7549: VideoController.vcnPal32G8[q]);
7550: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
7551: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7552: VideoController.vcnPalTbl[
7553: VideoController.vcnMix2 (
7554: VideoController.vcnMix2 (
7555: q,
7556: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
7557: 0)] :
7558: (p & 1) != 0 ?
7559: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1] :
7560: VideoController.vcnPal32G8[p] :
7561: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
7562: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7563: VideoController.vcnPalTbl[
7564: VideoController.vcnMix2 (
7565: VideoController.vcnMix2 (
7566: q,
7567: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
7568: 0)] :
7569: VideoController.vcnPal32G8[p] :
7570: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
7571: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7572: VideoController.vcnPalTbl[
7573: VideoController.vcnMix2 (
7574: VideoController.vcnMix2 (
7575: q,
7576: VideoController.vcnPal16G8[1]),
7577: 0)] :
7578: (p & 1) != 0 ?
7579: VideoController.vcnPal32G8[1] :
7580: VideoController.vcnPal32G8[p] :
7581: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]) & -2]) & 1) != 0 ?
7582: VideoController.vcnPalTbl[
7583: VideoController.vcnMix2 (
7584: VideoController.vcnMix2 (
7585: p,
7586: VideoController.vcnPal16G8[1]),
7587: 0)] :
7588: (q & 1) != 0 ?
7589: VideoController.vcnPal32G8[1] :
7590: VideoController.vcnPal32G8[q]);
7591: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
7592: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7593: VideoController.vcnPalTbl[
7594: VideoController.vcnMix2 (
7595: VideoController.vcnMix2 (
7596: q,
7597: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
7598: 0)] :
7599: (p & 1) != 0 ?
7600: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1] :
7601: VideoController.vcnPal32G8[p] :
7602: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
7603: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7604: VideoController.vcnPalTbl[
7605: VideoController.vcnMix2 (
7606: VideoController.vcnMix2 (
7607: q,
7608: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
7609: 0)] :
7610: VideoController.vcnPal32G8[p] :
7611: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
7612: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7613: VideoController.vcnPalTbl[
7614: VideoController.vcnMix2 (
7615: VideoController.vcnMix2 (
7616: q,
7617: VideoController.vcnPal16G8[1]),
7618: 0)] :
7619: (p & 1) != 0 ?
7620: VideoController.vcnPal32G8[1] :
7621: VideoController.vcnPal32G8[p] :
7622: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]) & -2]) & 1) != 0 ?
7623: VideoController.vcnPalTbl[
7624: VideoController.vcnMix2 (
7625: VideoController.vcnMix2 (
7626: p,
7627: VideoController.vcnPal16G8[1]),
7628: 0)] :
7629: (q & 1) != 0 ?
7630: VideoController.vcnPal32G8[1] :
7631: VideoController.vcnPal32G8[q]);
7632: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
7633: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7634: VideoController.vcnPalTbl[
7635: VideoController.vcnMix2 (
7636: VideoController.vcnMix2 (
7637: q,
7638: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
7639: 0)] :
7640: (p & 1) != 0 ?
7641: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1] :
7642: VideoController.vcnPal32G8[p] :
7643: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
7644: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7645: VideoController.vcnPalTbl[
7646: VideoController.vcnMix2 (
7647: VideoController.vcnMix2 (
7648: q,
7649: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
7650: 0)] :
7651: VideoController.vcnPal32G8[p] :
7652: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
7653: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7654: VideoController.vcnPalTbl[
7655: VideoController.vcnMix2 (
7656: VideoController.vcnMix2 (
7657: q,
7658: VideoController.vcnPal16G8[1]),
7659: 0)] :
7660: (p & 1) != 0 ?
7661: VideoController.vcnPal32G8[1] :
7662: VideoController.vcnPal32G8[p] :
7663: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]) & -2]) & 1) != 0 ?
7664: VideoController.vcnPalTbl[
7665: VideoController.vcnMix2 (
7666: VideoController.vcnMix2 (
7667: p,
7668: VideoController.vcnPal16G8[1]),
7669: 0)] :
7670: (q & 1) != 0 ?
7671: VideoController.vcnPal32G8[1] :
7672: VideoController.vcnPal32G8[q]);
7673: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
7674: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7675: VideoController.vcnPalTbl[
7676: VideoController.vcnMix2 (
7677: VideoController.vcnMix2 (
7678: q,
7679: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
7680: 0)] :
7681: (p & 1) != 0 ?
7682: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1] :
7683: VideoController.vcnPal32G8[p] :
7684: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
7685: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7686: VideoController.vcnPalTbl[
7687: VideoController.vcnMix2 (
7688: VideoController.vcnMix2 (
7689: q,
7690: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
7691: 0)] :
7692: VideoController.vcnPal32G8[p] :
7693: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
7694: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7695: VideoController.vcnPalTbl[
7696: VideoController.vcnMix2 (
7697: VideoController.vcnMix2 (
7698: q,
7699: VideoController.vcnPal16G8[1]),
7700: 0)] :
7701: (p & 1) != 0 ?
7702: VideoController.vcnPal32G8[1] :
7703: VideoController.vcnPal32G8[p] :
7704: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]) & -2]) & 1) != 0 ?
7705: VideoController.vcnPalTbl[
7706: VideoController.vcnMix2 (
7707: VideoController.vcnMix2 (
7708: p,
7709: VideoController.vcnPal16G8[1]),
7710: 0)] :
7711: (q & 1) != 0 ?
7712: VideoController.vcnPal32G8[1] :
7713: VideoController.vcnPal32G8[q]);
7714: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
7715: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7716: VideoController.vcnPalTbl[
7717: VideoController.vcnMix2 (
7718: VideoController.vcnMix2 (
7719: q,
7720: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
7721: 0)] :
7722: (p & 1) != 0 ?
7723: VideoController.vcnPal32G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1] :
7724: VideoController.vcnPal32G8[p] :
7725: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
7726: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7727: VideoController.vcnPalTbl[
7728: VideoController.vcnMix2 (
7729: VideoController.vcnMix2 (
7730: q,
7731: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
7732: 0)] :
7733: VideoController.vcnPal32G8[p] :
7734: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
7735: ((q = VideoController.vcnPal16G8[p & -2]) & 1) != 0 ?
7736: VideoController.vcnPalTbl[
7737: VideoController.vcnMix2 (
7738: VideoController.vcnMix2 (
7739: q,
7740: VideoController.vcnPal16G8[1]),
7741: 0)] :
7742: (p & 1) != 0 ?
7743: VideoController.vcnPal32G8[1] :
7744: VideoController.vcnPal32G8[p] :
7745: ((p = VideoController.vcnPal16G8[(q = MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]) & -2]) & 1) != 0 ?
7746: VideoController.vcnPalTbl[
7747: VideoController.vcnMix2 (
7748: VideoController.vcnMix2 (
7749: p,
7750: VideoController.vcnPal16G8[1]),
7751: 0)] :
7752: (q & 1) != 0 ?
7753: VideoController.vcnPal32G8[1] :
7754: VideoController.vcnPal32G8[q]);
7755: gx1st += 16;
7756: gx2nd += 16;
7757: gx3rd += 16;
7758: gx4th += 16;
7759: da += 8;
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:
7794:
7795:
7796: E4_XHPT {
7797: @Override public void drawRaster (int src, int dst, boolean rh) {
7798: int pn = VideoController.vcnReg2Curr & 3;
7799: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
7800: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7801: pn = VideoController.vcnReg2Curr >> 2 & 3;
7802: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
7803: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7804: pn = VideoController.vcnReg2Curr >> 4 & 3;
7805: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
7806: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7807: pn = VideoController.vcnReg2Curr >> 6 & 3;
7808: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
7809: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7810: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
7811: int db = da + XEiJ.pnlScreenWidth;
7812: if (rh) {
7813: int half = XEiJ.pnlScreenWidth >> 4 << 3;
7814: gx1st += half << 1;
7815: gx2nd += half << 1;
7816: gx3rd += half << 1;
7817: gx4th += half << 1;
7818: da += half;
7819: }
7820: while (da < db) {
7821: int p;
7822: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
7823: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
7824: VideoController.vcnPal32G8[p] :
7825: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2) != 0 ?
7826: VideoController.vcnPal32G8[p] :
7827: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023] & -2] :
7828: p == 1 ?
7829: VideoController.vcnPal32G8[0] :
7830: (p & 1) == 0 ?
7831: VideoController.vcnPal32G8[p] :
7832: VideoController.vcnPalTbl[
7833: VideoController.vcnMix2 (
7834: VideoController.vcnPal16G8[p & -2],
7835: 0)]);
7836: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
7837: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
7838: VideoController.vcnPal32G8[p] :
7839: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2) != 0 ?
7840: VideoController.vcnPal32G8[p] :
7841: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] & -2] :
7842: p == 1 ?
7843: VideoController.vcnPal32G8[0] :
7844: (p & 1) == 0 ?
7845: VideoController.vcnPal32G8[p] :
7846: VideoController.vcnPalTbl[
7847: VideoController.vcnMix2 (
7848: VideoController.vcnPal16G8[p & -2],
7849: 0)]);
7850: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
7851: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
7852: VideoController.vcnPal32G8[p] :
7853: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2) != 0 ?
7854: VideoController.vcnPal32G8[p] :
7855: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] & -2] :
7856: p == 1 ?
7857: VideoController.vcnPal32G8[0] :
7858: (p & 1) == 0 ?
7859: VideoController.vcnPal32G8[p] :
7860: VideoController.vcnPalTbl[
7861: VideoController.vcnMix2 (
7862: VideoController.vcnPal16G8[p & -2],
7863: 0)]);
7864: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
7865: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
7866: VideoController.vcnPal32G8[p] :
7867: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2) != 0 ?
7868: VideoController.vcnPal32G8[p] :
7869: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] & -2] :
7870: p == 1 ?
7871: VideoController.vcnPal32G8[0] :
7872: (p & 1) == 0 ?
7873: VideoController.vcnPal32G8[p] :
7874: VideoController.vcnPalTbl[
7875: VideoController.vcnMix2 (
7876: VideoController.vcnPal16G8[p & -2],
7877: 0)]);
7878: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
7879: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
7880: VideoController.vcnPal32G8[p] :
7881: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2) != 0 ?
7882: VideoController.vcnPal32G8[p] :
7883: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] & -2] :
7884: p == 1 ?
7885: VideoController.vcnPal32G8[0] :
7886: (p & 1) == 0 ?
7887: VideoController.vcnPal32G8[p] :
7888: VideoController.vcnPalTbl[
7889: VideoController.vcnMix2 (
7890: VideoController.vcnPal16G8[p & -2],
7891: 0)]);
7892: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
7893: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
7894: VideoController.vcnPal32G8[p] :
7895: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2) != 0 ?
7896: VideoController.vcnPal32G8[p] :
7897: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] & -2] :
7898: p == 1 ?
7899: VideoController.vcnPal32G8[0] :
7900: (p & 1) == 0 ?
7901: VideoController.vcnPal32G8[p] :
7902: VideoController.vcnPalTbl[
7903: VideoController.vcnMix2 (
7904: VideoController.vcnPal16G8[p & -2],
7905: 0)]);
7906: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
7907: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
7908: VideoController.vcnPal32G8[p] :
7909: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2) != 0 ?
7910: VideoController.vcnPal32G8[p] :
7911: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] & -2] :
7912: p == 1 ?
7913: VideoController.vcnPal32G8[0] :
7914: (p & 1) == 0 ?
7915: VideoController.vcnPal32G8[p] :
7916: VideoController.vcnPalTbl[
7917: VideoController.vcnMix2 (
7918: VideoController.vcnPal16G8[p & -2],
7919: 0)]);
7920: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
7921: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
7922: VideoController.vcnPal32G8[p] :
7923: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2) != 0 ?
7924: VideoController.vcnPal32G8[p] :
7925: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] & -2] :
7926: p == 1 ?
7927: VideoController.vcnPal32G8[0] :
7928: (p & 1) == 0 ?
7929: VideoController.vcnPal32G8[p] :
7930: VideoController.vcnPalTbl[
7931: VideoController.vcnMix2 (
7932: VideoController.vcnPal16G8[p & -2],
7933: 0)]);
7934: gx1st += 16;
7935: gx2nd += 16;
7936: gx3rd += 16;
7937: gx4th += 16;
7938: da += 8;
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:
7973:
7974:
7975: E4_XHPG {
7976: @Override public void drawRaster (int src, int dst, boolean rh) {
7977: int pn = VideoController.vcnReg2Curr & 3;
7978: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
7979: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7980: pn = VideoController.vcnReg2Curr >> 2 & 3;
7981: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
7982: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7983: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7984: pn = VideoController.vcnReg2Curr >> 4 & 3;
7985: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
7986: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7987: pn = VideoController.vcnReg2Curr >> 6 & 3;
7988: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
7989: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
7990: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
7991: int db = da + XEiJ.pnlScreenWidth;
7992: if (rh) {
7993: int half = XEiJ.pnlScreenWidth >> 4 << 3;
7994: gx1st += half << 1;
7995: gx2nd += half << 1;
7996: gx3rd += half << 1;
7997: gx4th += half << 1;
7998: da += half;
7999: }
8000: while (da < db) {
8001: int p;
8002: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
8003: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
8004: VideoController.vcnPal32G8[p] :
8005: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2) != 0 ?
8006: VideoController.vcnPal32G8[p] :
8007: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023] & -2] :
8008: p == 1 ?
8009: VideoController.vcnPal32G8[0] :
8010: (p & 1) == 0 ?
8011: VideoController.vcnPal32G8[p] :
8012: VideoController.vcnPalTbl[
8013: VideoController.vcnMix2 (
8014: VideoController.vcnPal16G8[p & -2],
8015: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1])]);
8016: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
8017: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
8018: VideoController.vcnPal32G8[p] :
8019: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2) != 0 ?
8020: VideoController.vcnPal32G8[p] :
8021: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] & -2] :
8022: p == 1 ?
8023: VideoController.vcnPal32G8[0] :
8024: (p & 1) == 0 ?
8025: VideoController.vcnPal32G8[p] :
8026: VideoController.vcnPalTbl[
8027: VideoController.vcnMix2 (
8028: VideoController.vcnPal16G8[p & -2],
8029: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1])]);
8030: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
8031: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
8032: VideoController.vcnPal32G8[p] :
8033: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2) != 0 ?
8034: VideoController.vcnPal32G8[p] :
8035: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] & -2] :
8036: p == 1 ?
8037: VideoController.vcnPal32G8[0] :
8038: (p & 1) == 0 ?
8039: VideoController.vcnPal32G8[p] :
8040: VideoController.vcnPalTbl[
8041: VideoController.vcnMix2 (
8042: VideoController.vcnPal16G8[p & -2],
8043: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1])]);
8044: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
8045: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
8046: VideoController.vcnPal32G8[p] :
8047: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2) != 0 ?
8048: VideoController.vcnPal32G8[p] :
8049: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] & -2] :
8050: p == 1 ?
8051: VideoController.vcnPal32G8[0] :
8052: (p & 1) == 0 ?
8053: VideoController.vcnPal32G8[p] :
8054: VideoController.vcnPalTbl[
8055: VideoController.vcnMix2 (
8056: VideoController.vcnPal16G8[p & -2],
8057: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1])]);
8058: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
8059: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
8060: VideoController.vcnPal32G8[p] :
8061: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2) != 0 ?
8062: VideoController.vcnPal32G8[p] :
8063: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] & -2] :
8064: p == 1 ?
8065: VideoController.vcnPal32G8[0] :
8066: (p & 1) == 0 ?
8067: VideoController.vcnPal32G8[p] :
8068: VideoController.vcnPalTbl[
8069: VideoController.vcnMix2 (
8070: VideoController.vcnPal16G8[p & -2],
8071: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1])]);
8072: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
8073: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
8074: VideoController.vcnPal32G8[p] :
8075: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2) != 0 ?
8076: VideoController.vcnPal32G8[p] :
8077: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] & -2] :
8078: p == 1 ?
8079: VideoController.vcnPal32G8[0] :
8080: (p & 1) == 0 ?
8081: VideoController.vcnPal32G8[p] :
8082: VideoController.vcnPalTbl[
8083: VideoController.vcnMix2 (
8084: VideoController.vcnPal16G8[p & -2],
8085: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1])]);
8086: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
8087: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
8088: VideoController.vcnPal32G8[p] :
8089: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2) != 0 ?
8090: VideoController.vcnPal32G8[p] :
8091: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] & -2] :
8092: p == 1 ?
8093: VideoController.vcnPal32G8[0] :
8094: (p & 1) == 0 ?
8095: VideoController.vcnPal32G8[p] :
8096: VideoController.vcnPalTbl[
8097: VideoController.vcnMix2 (
8098: VideoController.vcnPal16G8[p & -2],
8099: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1])]);
8100: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
8101: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
8102: VideoController.vcnPal32G8[p] :
8103: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2) != 0 ?
8104: VideoController.vcnPal32G8[p] :
8105: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] & -2] :
8106: p == 1 ?
8107: VideoController.vcnPal32G8[0] :
8108: (p & 1) == 0 ?
8109: VideoController.vcnPal32G8[p] :
8110: VideoController.vcnPalTbl[
8111: VideoController.vcnMix2 (
8112: VideoController.vcnPal16G8[p & -2],
8113: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1])]);
8114: gx1st += 16;
8115: gx2nd += 16;
8116: gx3rd += 16;
8117: gx4th += 16;
8118: da += 8;
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:
8153:
8154:
8155: E4_XHPGT {
8156: @Override public void drawRaster (int src, int dst, boolean rh) {
8157: int pn = VideoController.vcnReg2Curr & 3;
8158: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8159: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8160: pn = VideoController.vcnReg2Curr >> 2 & 3;
8161: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8162: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8163: int gz2nd = VideoController.vcnHidden2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8164: pn = VideoController.vcnReg2Curr >> 4 & 3;
8165: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
8166: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8167: pn = VideoController.vcnReg2Curr >> 6 & 3;
8168: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
8169: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8170: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8171: int db = da + XEiJ.pnlScreenWidth;
8172: if (rh) {
8173: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8174: gx1st += half << 1;
8175: gx2nd += half << 1;
8176: gx3rd += half << 1;
8177: gx4th += half << 1;
8178: da += half;
8179: }
8180: while (da < db) {
8181: int p;
8182: XEiJ.pnlBM[da] = ((p = MainMemory.mmrM8[gy1st | gx1st & 1023]) == 0 ?
8183: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023] & -2) != 0 ?
8184: VideoController.vcnPal32G8[p] :
8185: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023] & -2) != 0 ?
8186: VideoController.vcnPal32G8[p] :
8187: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th & 1023] & -2] :
8188: p == 1 ?
8189: VideoController.vcnPal32G8[0] :
8190: (p & 1) == 0 ?
8191: VideoController.vcnPal32G8[p] :
8192: VideoController.vcnPalTbl[
8193: VideoController.vcnMix2 (
8194: VideoController.vcnMix2 (
8195: VideoController.vcnPal16G8[p & -2],
8196: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd & 1023] | 1]),
8197: 0)]);
8198: XEiJ.pnlBM[da + 1] = ((p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) == 0 ?
8199: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] & -2) != 0 ?
8200: VideoController.vcnPal32G8[p] :
8201: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023] & -2) != 0 ?
8202: VideoController.vcnPal32G8[p] :
8203: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] & -2] :
8204: p == 1 ?
8205: VideoController.vcnPal32G8[0] :
8206: (p & 1) == 0 ?
8207: VideoController.vcnPal32G8[p] :
8208: VideoController.vcnPalTbl[
8209: VideoController.vcnMix2 (
8210: VideoController.vcnMix2 (
8211: VideoController.vcnPal16G8[p & -2],
8212: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 2 & 1023] | 1]),
8213: 0)]);
8214: XEiJ.pnlBM[da + 2] = ((p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) == 0 ?
8215: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] & -2) != 0 ?
8216: VideoController.vcnPal32G8[p] :
8217: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023] & -2) != 0 ?
8218: VideoController.vcnPal32G8[p] :
8219: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] & -2] :
8220: p == 1 ?
8221: VideoController.vcnPal32G8[0] :
8222: (p & 1) == 0 ?
8223: VideoController.vcnPal32G8[p] :
8224: VideoController.vcnPalTbl[
8225: VideoController.vcnMix2 (
8226: VideoController.vcnMix2 (
8227: VideoController.vcnPal16G8[p & -2],
8228: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 4 & 1023] | 1]),
8229: 0)]);
8230: XEiJ.pnlBM[da + 3] = ((p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) == 0 ?
8231: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] & -2) != 0 ?
8232: VideoController.vcnPal32G8[p] :
8233: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023] & -2) != 0 ?
8234: VideoController.vcnPal32G8[p] :
8235: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] & -2] :
8236: p == 1 ?
8237: VideoController.vcnPal32G8[0] :
8238: (p & 1) == 0 ?
8239: VideoController.vcnPal32G8[p] :
8240: VideoController.vcnPalTbl[
8241: VideoController.vcnMix2 (
8242: VideoController.vcnMix2 (
8243: VideoController.vcnPal16G8[p & -2],
8244: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 6 & 1023] | 1]),
8245: 0)]);
8246: XEiJ.pnlBM[da + 4] = ((p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) == 0 ?
8247: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] & -2) != 0 ?
8248: VideoController.vcnPal32G8[p] :
8249: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023] & -2) != 0 ?
8250: VideoController.vcnPal32G8[p] :
8251: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] & -2] :
8252: p == 1 ?
8253: VideoController.vcnPal32G8[0] :
8254: (p & 1) == 0 ?
8255: VideoController.vcnPal32G8[p] :
8256: VideoController.vcnPalTbl[
8257: VideoController.vcnMix2 (
8258: VideoController.vcnMix2 (
8259: VideoController.vcnPal16G8[p & -2],
8260: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 8 & 1023] | 1]),
8261: 0)]);
8262: XEiJ.pnlBM[da + 5] = ((p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) == 0 ?
8263: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] & -2) != 0 ?
8264: VideoController.vcnPal32G8[p] :
8265: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023] & -2) != 0 ?
8266: VideoController.vcnPal32G8[p] :
8267: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] & -2] :
8268: p == 1 ?
8269: VideoController.vcnPal32G8[0] :
8270: (p & 1) == 0 ?
8271: VideoController.vcnPal32G8[p] :
8272: VideoController.vcnPalTbl[
8273: VideoController.vcnMix2 (
8274: VideoController.vcnMix2 (
8275: VideoController.vcnPal16G8[p & -2],
8276: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 10 & 1023] | 1]),
8277: 0)]);
8278: XEiJ.pnlBM[da + 6] = ((p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) == 0 ?
8279: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] & -2) != 0 ?
8280: VideoController.vcnPal32G8[p] :
8281: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023] & -2) != 0 ?
8282: VideoController.vcnPal32G8[p] :
8283: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] & -2] :
8284: p == 1 ?
8285: VideoController.vcnPal32G8[0] :
8286: (p & 1) == 0 ?
8287: VideoController.vcnPal32G8[p] :
8288: VideoController.vcnPalTbl[
8289: VideoController.vcnMix2 (
8290: VideoController.vcnMix2 (
8291: VideoController.vcnPal16G8[p & -2],
8292: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 12 & 1023] | 1]),
8293: 0)]);
8294: XEiJ.pnlBM[da + 7] = ((p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) == 0 ?
8295: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] & -2) != 0 ?
8296: VideoController.vcnPal32G8[p] :
8297: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023] & -2) != 0 ?
8298: VideoController.vcnPal32G8[p] :
8299: VideoController.vcnPal32G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] & -2] :
8300: p == 1 ?
8301: VideoController.vcnPal32G8[0] :
8302: (p & 1) == 0 ?
8303: VideoController.vcnPal32G8[p] :
8304: VideoController.vcnPalTbl[
8305: VideoController.vcnMix2 (
8306: VideoController.vcnMix2 (
8307: VideoController.vcnPal16G8[p & -2],
8308: VideoController.vcnPal16G8[MainMemory.mmrM8[gz2nd | gx2nd + 14 & 1023] | 1]),
8309: 0)]);
8310: gx1st += 16;
8311: gx2nd += 16;
8312: gx3rd += 16;
8313: gx4th += 16;
8314: da += 8;
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:
8345:
8346:
8347: E4_A {
8348: @Override public void drawRaster (int src, int dst, boolean rh) {
8349: int pn = VideoController.vcnReg2Curr & 3;
8350: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8351: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8352: pn = VideoController.vcnReg2Curr >> 2 & 3;
8353: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8354: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8355: pn = VideoController.vcnReg2Curr >> 4 & 3;
8356: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
8357: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8358: pn = VideoController.vcnReg2Curr >> 6 & 3;
8359: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
8360: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8361: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8362: int db = da + XEiJ.pnlScreenWidth;
8363: if (rh) {
8364: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8365: gx1st += half << 1;
8366: gx2nd += half << 1;
8367: gx3rd += half << 1;
8368: gx4th += half << 1;
8369: da += half;
8370: }
8371: while (da < db) {
8372: int p;
8373: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
8374: (p = MainMemory.mmrM8[gy1st | gx1st & 1023]) != 0 ?
8375: VideoController.vcnMix2 (
8376: VideoController.vcnPal16G8[p],
8377: VideoController.vcnPal16TS[0]) :
8378: (p = MainMemory.mmrM8[gy2nd | gx2nd & 1023]) != 0 ?
8379: VideoController.vcnMix2 (
8380: VideoController.vcnPal16G8[p],
8381: VideoController.vcnPal16TS[0]) :
8382: (p = MainMemory.mmrM8[gy3rd | gx3rd & 1023]) != 0 ?
8383: VideoController.vcnMix2 (
8384: VideoController.vcnPal16G8[p],
8385: VideoController.vcnPal16TS[0]) :
8386: VideoController.vcnMix2 (
8387: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th & 1023]],
8388: VideoController.vcnPal16TS[0])]);
8389: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
8390: (p = MainMemory.mmrM8[gy1st | gx1st + 2 & 1023]) != 0 ?
8391: VideoController.vcnMix2 (
8392: VideoController.vcnPal16G8[p],
8393: VideoController.vcnPal16TS[0]) :
8394: (p = MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023]) != 0 ?
8395: VideoController.vcnMix2 (
8396: VideoController.vcnPal16G8[p],
8397: VideoController.vcnPal16TS[0]) :
8398: (p = MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023]) != 0 ?
8399: VideoController.vcnMix2 (
8400: VideoController.vcnPal16G8[p],
8401: VideoController.vcnPal16TS[0]) :
8402: VideoController.vcnMix2 (
8403: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 2 & 1023]],
8404: VideoController.vcnPal16TS[0])]);
8405: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
8406: (p = MainMemory.mmrM8[gy1st | gx1st + 4 & 1023]) != 0 ?
8407: VideoController.vcnMix2 (
8408: VideoController.vcnPal16G8[p],
8409: VideoController.vcnPal16TS[0]) :
8410: (p = MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023]) != 0 ?
8411: VideoController.vcnMix2 (
8412: VideoController.vcnPal16G8[p],
8413: VideoController.vcnPal16TS[0]) :
8414: (p = MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023]) != 0 ?
8415: VideoController.vcnMix2 (
8416: VideoController.vcnPal16G8[p],
8417: VideoController.vcnPal16TS[0]) :
8418: VideoController.vcnMix2 (
8419: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 4 & 1023]],
8420: VideoController.vcnPal16TS[0])]);
8421: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
8422: (p = MainMemory.mmrM8[gy1st | gx1st + 6 & 1023]) != 0 ?
8423: VideoController.vcnMix2 (
8424: VideoController.vcnPal16G8[p],
8425: VideoController.vcnPal16TS[0]) :
8426: (p = MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023]) != 0 ?
8427: VideoController.vcnMix2 (
8428: VideoController.vcnPal16G8[p],
8429: VideoController.vcnPal16TS[0]) :
8430: (p = MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023]) != 0 ?
8431: VideoController.vcnMix2 (
8432: VideoController.vcnPal16G8[p],
8433: VideoController.vcnPal16TS[0]) :
8434: VideoController.vcnMix2 (
8435: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 6 & 1023]],
8436: VideoController.vcnPal16TS[0])]);
8437: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
8438: (p = MainMemory.mmrM8[gy1st | gx1st + 8 & 1023]) != 0 ?
8439: VideoController.vcnMix2 (
8440: VideoController.vcnPal16G8[p],
8441: VideoController.vcnPal16TS[0]) :
8442: (p = MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023]) != 0 ?
8443: VideoController.vcnMix2 (
8444: VideoController.vcnPal16G8[p],
8445: VideoController.vcnPal16TS[0]) :
8446: (p = MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023]) != 0 ?
8447: VideoController.vcnMix2 (
8448: VideoController.vcnPal16G8[p],
8449: VideoController.vcnPal16TS[0]) :
8450: VideoController.vcnMix2 (
8451: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 8 & 1023]],
8452: VideoController.vcnPal16TS[0])]);
8453: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
8454: (p = MainMemory.mmrM8[gy1st | gx1st + 10 & 1023]) != 0 ?
8455: VideoController.vcnMix2 (
8456: VideoController.vcnPal16G8[p],
8457: VideoController.vcnPal16TS[0]) :
8458: (p = MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023]) != 0 ?
8459: VideoController.vcnMix2 (
8460: VideoController.vcnPal16G8[p],
8461: VideoController.vcnPal16TS[0]) :
8462: (p = MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023]) != 0 ?
8463: VideoController.vcnMix2 (
8464: VideoController.vcnPal16G8[p],
8465: VideoController.vcnPal16TS[0]) :
8466: VideoController.vcnMix2 (
8467: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 10 & 1023]],
8468: VideoController.vcnPal16TS[0])]);
8469: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
8470: (p = MainMemory.mmrM8[gy1st | gx1st + 12 & 1023]) != 0 ?
8471: VideoController.vcnMix2 (
8472: VideoController.vcnPal16G8[p],
8473: VideoController.vcnPal16TS[0]) :
8474: (p = MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023]) != 0 ?
8475: VideoController.vcnMix2 (
8476: VideoController.vcnPal16G8[p],
8477: VideoController.vcnPal16TS[0]) :
8478: (p = MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023]) != 0 ?
8479: VideoController.vcnMix2 (
8480: VideoController.vcnPal16G8[p],
8481: VideoController.vcnPal16TS[0]) :
8482: VideoController.vcnMix2 (
8483: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 12 & 1023]],
8484: VideoController.vcnPal16TS[0])]);
8485: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
8486: (p = MainMemory.mmrM8[gy1st | gx1st + 14 & 1023]) != 0 ?
8487: VideoController.vcnMix2 (
8488: VideoController.vcnPal16G8[p],
8489: VideoController.vcnPal16TS[0]) :
8490: (p = MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023]) != 0 ?
8491: VideoController.vcnMix2 (
8492: VideoController.vcnPal16G8[p],
8493: VideoController.vcnPal16TS[0]) :
8494: (p = MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023]) != 0 ?
8495: VideoController.vcnMix2 (
8496: VideoController.vcnPal16G8[p],
8497: VideoController.vcnPal16TS[0]) :
8498: VideoController.vcnMix2 (
8499: VideoController.vcnPal16G8[MainMemory.mmrM8[gy4th | gx4th + 14 & 1023]],
8500: VideoController.vcnPal16TS[0])]);
8501: gx1st += 16;
8502: gx2nd += 16;
8503: gx3rd += 16;
8504: gx4th += 16;
8505: da += 8;
8506: }
8507: }
8508: },
8509:
8510:
8511:
8512:
8513:
8514:
8515:
8516:
8517:
8518:
8519:
8520:
8521:
8522:
8523:
8524:
8525:
8526:
8527:
8528:
8529: F1 {
8530: @Override public void drawRaster (int src, int dst, boolean rh) {
8531: int pn = VideoController.vcnReg2Curr & 3;
8532: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8533: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8534: pn = VideoController.vcnReg2Curr >> 2 & 3;
8535: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8536: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8537: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8538: int db = da + XEiJ.pnlScreenWidth;
8539: if (rh) {
8540: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8541: gx1st += half << 1;
8542: gx2nd += half << 1;
8543: da += half;
8544: }
8545: while (da < db) {
8546: XEiJ.pnlBM[da] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
8547: MainMemory.mmrM8[gy1st | gx1st & 1023])]);
8548: XEiJ.pnlBM[da + 1] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
8549: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])]);
8550: XEiJ.pnlBM[da + 2] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
8551: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])]);
8552: XEiJ.pnlBM[da + 3] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
8553: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])]);
8554: XEiJ.pnlBM[da + 4] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
8555: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])]);
8556: XEiJ.pnlBM[da + 5] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
8557: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])]);
8558: XEiJ.pnlBM[da + 6] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
8559: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])]);
8560: XEiJ.pnlBM[da + 7] = (VideoController.vcnPal32G8[(MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
8561: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])]);
8562: gx1st += 16;
8563: gx2nd += 16;
8564: da += 8;
8565: }
8566: }
8567: },
8568:
8569:
8570:
8571:
8572:
8573:
8574: XF1 {
8575: @Override public void drawRaster (int src, int dst, boolean rh) {
8576: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
8577:
8578: case 0b00010000:
8579: case 0b00010001:
8580: case 0b00010010:
8581: case 0b00010011:
8582: F1.drawRaster (src, dst, rh);
8583: break;
8584:
8585: case 0b00010100:
8586: case 0b00010101:
8587: case 0b00010110:
8588: case 0b00010111:
8589: F1_XWP.drawRaster (src, dst, rh);
8590: break;
8591:
8592: case 0b00011000:
8593: F1.drawRaster (src, dst, rh);
8594: break;
8595:
8596: case 0b00011001:
8597: F1_XHCT.drawRaster (src, dst, rh);
8598: break;
8599:
8600: case 0b00011010:
8601: F1_XHCG.drawRaster (src, dst, rh);
8602: break;
8603:
8604: case 0b00011011:
8605: F1_XHCGT.drawRaster (src, dst, rh);
8606: break;
8607:
8608: case 0b00011101:
8609: F1_XHPT.drawRaster (src, dst, rh);
8610: break;
8611:
8612: case 0b00011110:
8613: F1_XHPG.drawRaster (src, dst, rh);
8614: break;
8615:
8616: case 0b00011111:
8617: F1_XHPGT.drawRaster (src, dst, rh);
8618: break;
8619:
8620: case 0b01000000:
8621: case 0b01000001:
8622: case 0b01000010:
8623: case 0b01000011:
8624: case 0b01000100:
8625: case 0b01000101:
8626: case 0b01000110:
8627: case 0b01000111:
8628: case 0b01001000:
8629: case 0b01001001:
8630: case 0b01001010:
8631: case 0b01001011:
8632: case 0b01001100:
8633: case 0b01001101:
8634: case 0b01001110:
8635: case 0b01001111:
8636: case 0b01010000:
8637: case 0b01010001:
8638: case 0b01010010:
8639: case 0b01010011:
8640: case 0b01010100:
8641: case 0b01010101:
8642: case 0b01010110:
8643: case 0b01010111:
8644: case 0b01011000:
8645: case 0b01011001:
8646: case 0b01011010:
8647: case 0b01011011:
8648: case 0b01011100:
8649: case 0b01011101:
8650: case 0b01011110:
8651: case 0b01011111:
8652: F1_A.drawRaster (src, dst, rh);
8653: break;
8654: default:
8655: F1.drawRaster (src, dst, rh);
8656: VideoController.vcnReportUnimplemented (XF1);
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:
8683:
8684:
8685: F1_XWP {
8686: @Override public void drawRaster (int src, int dst, boolean rh) {
8687: int pn = VideoController.vcnReg2Curr & 3;
8688: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8689: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8690: pn = VideoController.vcnReg2Curr >> 2 & 3;
8691: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8692: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8693: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8694: int db = da + XEiJ.pnlScreenWidth;
8695: if (rh) {
8696: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8697: gx1st += half << 1;
8698: gx2nd += half << 1;
8699: da += half;
8700: }
8701: while (da < db) {
8702: int p;
8703: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
8704: MainMemory.mmrM8[gy1st | gx1st & 1023])) <= 1 ?
8705: VideoController.vcnPal32G8[0] :
8706: (p & 1) == 0 ?
8707: VideoController.vcnPal32G8[p] :
8708: VideoController.vcnPal32G8[p & -2]);
8709: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
8710: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) <= 1 ?
8711: VideoController.vcnPal32G8[0] :
8712: (p & 1) == 0 ?
8713: VideoController.vcnPal32G8[p] :
8714: VideoController.vcnPal32G8[p & -2]);
8715: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
8716: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) <= 1 ?
8717: VideoController.vcnPal32G8[0] :
8718: (p & 1) == 0 ?
8719: VideoController.vcnPal32G8[p] :
8720: VideoController.vcnPal32G8[p & -2]);
8721: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
8722: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) <= 1 ?
8723: VideoController.vcnPal32G8[0] :
8724: (p & 1) == 0 ?
8725: VideoController.vcnPal32G8[p] :
8726: VideoController.vcnPal32G8[p & -2]);
8727: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
8728: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) <= 1 ?
8729: VideoController.vcnPal32G8[0] :
8730: (p & 1) == 0 ?
8731: VideoController.vcnPal32G8[p] :
8732: VideoController.vcnPal32G8[p & -2]);
8733: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
8734: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) <= 1 ?
8735: VideoController.vcnPal32G8[0] :
8736: (p & 1) == 0 ?
8737: VideoController.vcnPal32G8[p] :
8738: VideoController.vcnPal32G8[p & -2]);
8739: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
8740: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) <= 1 ?
8741: VideoController.vcnPal32G8[0] :
8742: (p & 1) == 0 ?
8743: VideoController.vcnPal32G8[p] :
8744: VideoController.vcnPal32G8[p & -2]);
8745: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
8746: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) <= 1 ?
8747: VideoController.vcnPal32G8[0] :
8748: (p & 1) == 0 ?
8749: VideoController.vcnPal32G8[p] :
8750: VideoController.vcnPal32G8[p & -2]);
8751: gx1st += 16;
8752: gx2nd += 16;
8753: da += 8;
8754: }
8755: }
8756: },
8757:
8758:
8759:
8760:
8761:
8762:
8763:
8764:
8765:
8766:
8767:
8768:
8769:
8770:
8771:
8772:
8773:
8774:
8775:
8776:
8777:
8778:
8779:
8780: F1_XHCT {
8781: @Override public void drawRaster (int src, int dst, boolean rh) {
8782: int pn = VideoController.vcnReg2Curr & 3;
8783: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8784: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8785: pn = VideoController.vcnReg2Curr >> 2 & 3;
8786: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8787: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8788: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8789: int db = da + XEiJ.pnlScreenWidth;
8790: if (rh) {
8791: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8792: gx1st += half << 1;
8793: gx2nd += half << 1;
8794: da += half;
8795: }
8796: while (da < db) {
8797: int p;
8798: XEiJ.pnlBM[da] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
8799: MainMemory.mmrM8[gy1st | gx1st & 1023])) & -2] & 1) != 0 ?
8800: VideoController.vcnPalTbl[
8801: VideoController.vcnMix2 (
8802: VideoController.vcnPal16G8[p],
8803: 0)] :
8804: VideoController.vcnPal32G8[p]);
8805: XEiJ.pnlBM[da + 1] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
8806: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) & -2] & 1) != 0 ?
8807: VideoController.vcnPalTbl[
8808: VideoController.vcnMix2 (
8809: VideoController.vcnPal16G8[p],
8810: 0)] :
8811: VideoController.vcnPal32G8[p]);
8812: XEiJ.pnlBM[da + 2] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
8813: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) & -2] & 1) != 0 ?
8814: VideoController.vcnPalTbl[
8815: VideoController.vcnMix2 (
8816: VideoController.vcnPal16G8[p],
8817: 0)] :
8818: VideoController.vcnPal32G8[p]);
8819: XEiJ.pnlBM[da + 3] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
8820: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) & -2] & 1) != 0 ?
8821: VideoController.vcnPalTbl[
8822: VideoController.vcnMix2 (
8823: VideoController.vcnPal16G8[p],
8824: 0)] :
8825: VideoController.vcnPal32G8[p]);
8826: XEiJ.pnlBM[da + 4] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
8827: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) & -2] & 1) != 0 ?
8828: VideoController.vcnPalTbl[
8829: VideoController.vcnMix2 (
8830: VideoController.vcnPal16G8[p],
8831: 0)] :
8832: VideoController.vcnPal32G8[p]);
8833: XEiJ.pnlBM[da + 5] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
8834: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) & -2] & 1) != 0 ?
8835: VideoController.vcnPalTbl[
8836: VideoController.vcnMix2 (
8837: VideoController.vcnPal16G8[p],
8838: 0)] :
8839: VideoController.vcnPal32G8[p]);
8840: XEiJ.pnlBM[da + 6] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
8841: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) & -2] & 1) != 0 ?
8842: VideoController.vcnPalTbl[
8843: VideoController.vcnMix2 (
8844: VideoController.vcnPal16G8[p],
8845: 0)] :
8846: VideoController.vcnPal32G8[p]);
8847: XEiJ.pnlBM[da + 7] = ((VideoController.vcnPal16G8[(p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
8848: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) & -2] & 1) != 0 ?
8849: VideoController.vcnPalTbl[
8850: VideoController.vcnMix2 (
8851: VideoController.vcnPal16G8[p],
8852: 0)] :
8853: VideoController.vcnPal32G8[p]);
8854: gx1st += 16;
8855: gx2nd += 16;
8856: da += 8;
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:
8884:
8885:
8886: F1_XHCG {
8887: @Override public void drawRaster (int src, int dst, boolean rh) {
8888: int pn = VideoController.vcnReg2Curr & 3;
8889: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
8890: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8891: pn = VideoController.vcnReg2Curr >> 2 & 3;
8892: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
8893: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8894: pn = VideoController.vcnReg2Curr >> 4 & 3;
8895: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
8896: int gz3rd = VideoController.vcnHidden3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8897: pn = VideoController.vcnReg2Curr >> 6 & 3;
8898: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
8899: int gz4th = VideoController.vcnHidden4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
8900: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
8901: int db = da + XEiJ.pnlScreenWidth;
8902: if (rh) {
8903: int half = XEiJ.pnlScreenWidth >> 4 << 3;
8904: gx1st += half << 1;
8905: gx2nd += half << 1;
8906: gx3rd += half << 1;
8907: gx4th += half << 1;
8908: da += half;
8909: }
8910: while (da < db) {
8911: int p, q;
8912: XEiJ.pnlBM[da] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
8913: MainMemory.mmrM8[gy1st | gx1st & 1023])) & -2]) & 1) != 0 ?
8914: VideoController.vcnPalTbl[
8915: VideoController.vcnMix2 (
8916: p,
8917: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
8918: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1])] :
8919: (q & 1) != 0 ?
8920: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
8921: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1] :
8922: VideoController.vcnPal32G8[q]);
8923: XEiJ.pnlBM[da + 1] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
8924: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) & -2]) & 1) != 0 ?
8925: VideoController.vcnPalTbl[
8926: VideoController.vcnMix2 (
8927: p,
8928: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
8929: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1])] :
8930: (q & 1) != 0 ?
8931: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
8932: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1] :
8933: VideoController.vcnPal32G8[q]);
8934: XEiJ.pnlBM[da + 2] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
8935: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) & -2]) & 1) != 0 ?
8936: VideoController.vcnPalTbl[
8937: VideoController.vcnMix2 (
8938: p,
8939: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
8940: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1])] :
8941: (q & 1) != 0 ?
8942: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
8943: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1] :
8944: VideoController.vcnPal32G8[q]);
8945: XEiJ.pnlBM[da + 3] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
8946: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) & -2]) & 1) != 0 ?
8947: VideoController.vcnPalTbl[
8948: VideoController.vcnMix2 (
8949: p,
8950: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
8951: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1])] :
8952: (q & 1) != 0 ?
8953: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
8954: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1] :
8955: VideoController.vcnPal32G8[q]);
8956: XEiJ.pnlBM[da + 4] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
8957: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) & -2]) & 1) != 0 ?
8958: VideoController.vcnPalTbl[
8959: VideoController.vcnMix2 (
8960: p,
8961: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
8962: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1])] :
8963: (q & 1) != 0 ?
8964: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
8965: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1] :
8966: VideoController.vcnPal32G8[q]);
8967: XEiJ.pnlBM[da + 5] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
8968: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) & -2]) & 1) != 0 ?
8969: VideoController.vcnPalTbl[
8970: VideoController.vcnMix2 (
8971: p,
8972: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
8973: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1])] :
8974: (q & 1) != 0 ?
8975: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
8976: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1] :
8977: VideoController.vcnPal32G8[q]);
8978: XEiJ.pnlBM[da + 6] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
8979: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) & -2]) & 1) != 0 ?
8980: VideoController.vcnPalTbl[
8981: VideoController.vcnMix2 (
8982: p,
8983: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
8984: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1])] :
8985: (q & 1) != 0 ?
8986: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
8987: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1] :
8988: VideoController.vcnPal32G8[q]);
8989: XEiJ.pnlBM[da + 7] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
8990: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) & -2]) & 1) != 0 ?
8991: VideoController.vcnPalTbl[
8992: VideoController.vcnMix2 (
8993: p,
8994: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
8995: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1])] :
8996: (q & 1) != 0 ?
8997: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
8998: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1] :
8999: VideoController.vcnPal32G8[q]);
9000: gx1st += 16;
9001: gx2nd += 16;
9002: gx3rd += 16;
9003: gx4th += 16;
9004: da += 8;
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:
9032:
9033:
9034: F1_XHCGT {
9035: @Override public void drawRaster (int src, int dst, boolean rh) {
9036: int pn = VideoController.vcnReg2Curr & 3;
9037: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9038: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9039: pn = VideoController.vcnReg2Curr >> 2 & 3;
9040: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9041: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9042: pn = VideoController.vcnReg2Curr >> 4 & 3;
9043: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
9044: int gz3rd = VideoController.vcnHidden3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9045: pn = VideoController.vcnReg2Curr >> 6 & 3;
9046: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
9047: int gz4th = VideoController.vcnHidden4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9048: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9049: int db = da + XEiJ.pnlScreenWidth;
9050: if (rh) {
9051: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9052: gx1st += half << 1;
9053: gx2nd += half << 1;
9054: gx3rd += half << 1;
9055: gx4th += half << 1;
9056: da += half;
9057: }
9058: while (da < db) {
9059: int p, q;
9060: XEiJ.pnlBM[da] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9061: MainMemory.mmrM8[gy1st | gx1st & 1023])) & -2]) & 1) != 0 ?
9062: VideoController.vcnPalTbl[
9063: VideoController.vcnMix2 (
9064: VideoController.vcnMix2 (
9065: p,
9066: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
9067: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1]),
9068: 0)] :
9069: (q & 1) != 0 ?
9070: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
9071: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1] :
9072: VideoController.vcnPal32G8[q]);
9073: XEiJ.pnlBM[da + 1] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9074: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) & -2]) & 1) != 0 ?
9075: VideoController.vcnPalTbl[
9076: VideoController.vcnMix2 (
9077: VideoController.vcnMix2 (
9078: p,
9079: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
9080: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1]),
9081: 0)] :
9082: (q & 1) != 0 ?
9083: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
9084: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1] :
9085: VideoController.vcnPal32G8[q]);
9086: XEiJ.pnlBM[da + 2] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9087: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) & -2]) & 1) != 0 ?
9088: VideoController.vcnPalTbl[
9089: VideoController.vcnMix2 (
9090: VideoController.vcnMix2 (
9091: p,
9092: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
9093: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1]),
9094: 0)] :
9095: (q & 1) != 0 ?
9096: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
9097: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1] :
9098: VideoController.vcnPal32G8[q]);
9099: XEiJ.pnlBM[da + 3] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9100: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) & -2]) & 1) != 0 ?
9101: VideoController.vcnPalTbl[
9102: VideoController.vcnMix2 (
9103: VideoController.vcnMix2 (
9104: p,
9105: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
9106: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1]),
9107: 0)] :
9108: (q & 1) != 0 ?
9109: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
9110: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1] :
9111: VideoController.vcnPal32G8[q]);
9112: XEiJ.pnlBM[da + 4] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9113: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) & -2]) & 1) != 0 ?
9114: VideoController.vcnPalTbl[
9115: VideoController.vcnMix2 (
9116: VideoController.vcnMix2 (
9117: p,
9118: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
9119: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1]),
9120: 0)] :
9121: (q & 1) != 0 ?
9122: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
9123: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1] :
9124: VideoController.vcnPal32G8[q]);
9125: XEiJ.pnlBM[da + 5] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9126: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) & -2]) & 1) != 0 ?
9127: VideoController.vcnPalTbl[
9128: VideoController.vcnMix2 (
9129: VideoController.vcnMix2 (
9130: p,
9131: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
9132: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1]),
9133: 0)] :
9134: (q & 1) != 0 ?
9135: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
9136: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1] :
9137: VideoController.vcnPal32G8[q]);
9138: XEiJ.pnlBM[da + 6] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9139: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) & -2]) & 1) != 0 ?
9140: VideoController.vcnPalTbl[
9141: VideoController.vcnMix2 (
9142: VideoController.vcnMix2 (
9143: p,
9144: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
9145: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1]),
9146: 0)] :
9147: (q & 1) != 0 ?
9148: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
9149: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1] :
9150: VideoController.vcnPal32G8[q]);
9151: XEiJ.pnlBM[da + 7] = (((p = VideoController.vcnPal16G8[(q = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9152: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) & -2]) & 1) != 0 ?
9153: VideoController.vcnPalTbl[
9154: VideoController.vcnMix2 (
9155: VideoController.vcnMix2 (
9156: p,
9157: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
9158: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1]),
9159: 0)] :
9160: (q & 1) != 0 ?
9161: VideoController.vcnPal32G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
9162: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1] :
9163: VideoController.vcnPal32G8[q]);
9164: gx1st += 16;
9165: gx2nd += 16;
9166: gx3rd += 16;
9167: gx4th += 16;
9168: da += 8;
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:
9195:
9196:
9197: F1_XHPT {
9198: @Override public void drawRaster (int src, int dst, boolean rh) {
9199: int pn = VideoController.vcnReg2Curr & 3;
9200: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9201: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9202: pn = VideoController.vcnReg2Curr >> 2 & 3;
9203: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9204: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9205: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9206: int db = da + XEiJ.pnlScreenWidth;
9207: if (rh) {
9208: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9209: gx1st += half << 1;
9210: gx2nd += half << 1;
9211: da += half;
9212: }
9213: while (da < db) {
9214: int p;
9215: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9216: MainMemory.mmrM8[gy1st | gx1st & 1023])) <= 1 ?
9217: VideoController.vcnPal32G8[0] :
9218: (p & 1) == 0 ?
9219: VideoController.vcnPal32G8[p] :
9220: VideoController.vcnPalTbl[
9221: VideoController.vcnMix2 (
9222: VideoController.vcnPal16G8[p & -2],
9223: 0)]);
9224: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9225: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) <= 1 ?
9226: VideoController.vcnPal32G8[0] :
9227: (p & 1) == 0 ?
9228: VideoController.vcnPal32G8[p] :
9229: VideoController.vcnPalTbl[
9230: VideoController.vcnMix2 (
9231: VideoController.vcnPal16G8[p & -2],
9232: 0)]);
9233: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9234: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) <= 1 ?
9235: VideoController.vcnPal32G8[0] :
9236: (p & 1) == 0 ?
9237: VideoController.vcnPal32G8[p] :
9238: VideoController.vcnPalTbl[
9239: VideoController.vcnMix2 (
9240: VideoController.vcnPal16G8[p & -2],
9241: 0)]);
9242: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9243: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) <= 1 ?
9244: VideoController.vcnPal32G8[0] :
9245: (p & 1) == 0 ?
9246: VideoController.vcnPal32G8[p] :
9247: VideoController.vcnPalTbl[
9248: VideoController.vcnMix2 (
9249: VideoController.vcnPal16G8[p & -2],
9250: 0)]);
9251: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9252: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) <= 1 ?
9253: VideoController.vcnPal32G8[0] :
9254: (p & 1) == 0 ?
9255: VideoController.vcnPal32G8[p] :
9256: VideoController.vcnPalTbl[
9257: VideoController.vcnMix2 (
9258: VideoController.vcnPal16G8[p & -2],
9259: 0)]);
9260: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9261: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) <= 1 ?
9262: VideoController.vcnPal32G8[0] :
9263: (p & 1) == 0 ?
9264: VideoController.vcnPal32G8[p] :
9265: VideoController.vcnPalTbl[
9266: VideoController.vcnMix2 (
9267: VideoController.vcnPal16G8[p & -2],
9268: 0)]);
9269: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9270: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) <= 1 ?
9271: VideoController.vcnPal32G8[0] :
9272: (p & 1) == 0 ?
9273: VideoController.vcnPal32G8[p] :
9274: VideoController.vcnPalTbl[
9275: VideoController.vcnMix2 (
9276: VideoController.vcnPal16G8[p & -2],
9277: 0)]);
9278: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9279: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) <= 1 ?
9280: VideoController.vcnPal32G8[0] :
9281: (p & 1) == 0 ?
9282: VideoController.vcnPal32G8[p] :
9283: VideoController.vcnPalTbl[
9284: VideoController.vcnMix2 (
9285: VideoController.vcnPal16G8[p & -2],
9286: 0)]);
9287: gx1st += 16;
9288: gx2nd += 16;
9289: da += 8;
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:
9316:
9317:
9318: F1_XHPG {
9319: @Override public void drawRaster (int src, int dst, boolean rh) {
9320: int pn = VideoController.vcnReg2Curr & 3;
9321: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9322: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9323: pn = VideoController.vcnReg2Curr >> 2 & 3;
9324: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9325: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9326: pn = VideoController.vcnReg2Curr >> 4 & 3;
9327: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
9328: int gz3rd = VideoController.vcnHidden3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9329: pn = VideoController.vcnReg2Curr >> 6 & 3;
9330: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
9331: int gz4th = VideoController.vcnHidden4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9332: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9333: int db = da + XEiJ.pnlScreenWidth;
9334: if (rh) {
9335: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9336: gx1st += half << 1;
9337: gx2nd += half << 1;
9338: gx3rd += half << 1;
9339: gx4th += half << 1;
9340: da += half;
9341: }
9342: while (da < db) {
9343: int p;
9344: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9345: MainMemory.mmrM8[gy1st | gx1st & 1023])) <= 1 ?
9346: VideoController.vcnPal32G8[0] :
9347: (p & 1) == 0 ?
9348: VideoController.vcnPal32G8[p] :
9349: VideoController.vcnPalTbl[
9350: VideoController.vcnMix2 (
9351: VideoController.vcnPal16G8[p & -2],
9352: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
9353: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1])]);
9354: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9355: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) <= 1 ?
9356: VideoController.vcnPal32G8[0] :
9357: (p & 1) == 0 ?
9358: VideoController.vcnPal32G8[p] :
9359: VideoController.vcnPalTbl[
9360: VideoController.vcnMix2 (
9361: VideoController.vcnPal16G8[p & -2],
9362: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
9363: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1])]);
9364: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9365: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) <= 1 ?
9366: VideoController.vcnPal32G8[0] :
9367: (p & 1) == 0 ?
9368: VideoController.vcnPal32G8[p] :
9369: VideoController.vcnPalTbl[
9370: VideoController.vcnMix2 (
9371: VideoController.vcnPal16G8[p & -2],
9372: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
9373: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1])]);
9374: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9375: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) <= 1 ?
9376: VideoController.vcnPal32G8[0] :
9377: (p & 1) == 0 ?
9378: VideoController.vcnPal32G8[p] :
9379: VideoController.vcnPalTbl[
9380: VideoController.vcnMix2 (
9381: VideoController.vcnPal16G8[p & -2],
9382: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
9383: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1])]);
9384: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9385: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) <= 1 ?
9386: VideoController.vcnPal32G8[0] :
9387: (p & 1) == 0 ?
9388: VideoController.vcnPal32G8[p] :
9389: VideoController.vcnPalTbl[
9390: VideoController.vcnMix2 (
9391: VideoController.vcnPal16G8[p & -2],
9392: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
9393: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1])]);
9394: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9395: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) <= 1 ?
9396: VideoController.vcnPal32G8[0] :
9397: (p & 1) == 0 ?
9398: VideoController.vcnPal32G8[p] :
9399: VideoController.vcnPalTbl[
9400: VideoController.vcnMix2 (
9401: VideoController.vcnPal16G8[p & -2],
9402: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
9403: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1])]);
9404: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9405: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) <= 1 ?
9406: VideoController.vcnPal32G8[0] :
9407: (p & 1) == 0 ?
9408: VideoController.vcnPal32G8[p] :
9409: VideoController.vcnPalTbl[
9410: VideoController.vcnMix2 (
9411: VideoController.vcnPal16G8[p & -2],
9412: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
9413: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1])]);
9414: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9415: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) <= 1 ?
9416: VideoController.vcnPal32G8[0] :
9417: (p & 1) == 0 ?
9418: VideoController.vcnPal32G8[p] :
9419: VideoController.vcnPalTbl[
9420: VideoController.vcnMix2 (
9421: VideoController.vcnPal16G8[p & -2],
9422: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
9423: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1])]);
9424: gx1st += 16;
9425: gx2nd += 16;
9426: gx3rd += 16;
9427: gx4th += 16;
9428: da += 8;
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:
9455:
9456:
9457: F1_XHPGT {
9458: @Override public void drawRaster (int src, int dst, boolean rh) {
9459: int pn = VideoController.vcnReg2Curr & 3;
9460: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9461: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9462: pn = VideoController.vcnReg2Curr >> 2 & 3;
9463: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9464: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9465: pn = VideoController.vcnReg2Curr >> 4 & 3;
9466: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
9467: int gz3rd = VideoController.vcnHidden3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9468: pn = VideoController.vcnReg2Curr >> 6 & 3;
9469: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
9470: int gz4th = VideoController.vcnHidden4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9471: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9472: int db = da + XEiJ.pnlScreenWidth;
9473: if (rh) {
9474: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9475: gx1st += half << 1;
9476: gx2nd += half << 1;
9477: gx3rd += half << 1;
9478: gx4th += half << 1;
9479: da += half;
9480: }
9481: while (da < db) {
9482: int p;
9483: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9484: MainMemory.mmrM8[gy1st | gx1st & 1023])) <= 1 ?
9485: VideoController.vcnPal32G8[0] :
9486: (p & 1) == 0 ?
9487: VideoController.vcnPal32G8[p] :
9488: VideoController.vcnPalTbl[
9489: VideoController.vcnMix2 (
9490: VideoController.vcnMix2 (
9491: VideoController.vcnPal16G8[p & -2],
9492: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th & 1023] << 4 |
9493: MainMemory.mmrM8[gz3rd | gx3rd & 1023]) | 1]),
9494: 0)]);
9495: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9496: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) <= 1 ?
9497: VideoController.vcnPal32G8[0] :
9498: (p & 1) == 0 ?
9499: VideoController.vcnPal32G8[p] :
9500: VideoController.vcnPalTbl[
9501: VideoController.vcnMix2 (
9502: VideoController.vcnMix2 (
9503: VideoController.vcnPal16G8[p & -2],
9504: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 2 & 1023] << 4 |
9505: MainMemory.mmrM8[gz3rd | gx3rd + 2 & 1023]) | 1]),
9506: 0)]);
9507: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9508: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) <= 1 ?
9509: VideoController.vcnPal32G8[0] :
9510: (p & 1) == 0 ?
9511: VideoController.vcnPal32G8[p] :
9512: VideoController.vcnPalTbl[
9513: VideoController.vcnMix2 (
9514: VideoController.vcnMix2 (
9515: VideoController.vcnPal16G8[p & -2],
9516: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 4 & 1023] << 4 |
9517: MainMemory.mmrM8[gz3rd | gx3rd + 4 & 1023]) | 1]),
9518: 0)]);
9519: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9520: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) <= 1 ?
9521: VideoController.vcnPal32G8[0] :
9522: (p & 1) == 0 ?
9523: VideoController.vcnPal32G8[p] :
9524: VideoController.vcnPalTbl[
9525: VideoController.vcnMix2 (
9526: VideoController.vcnMix2 (
9527: VideoController.vcnPal16G8[p & -2],
9528: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 6 & 1023] << 4 |
9529: MainMemory.mmrM8[gz3rd | gx3rd + 6 & 1023]) | 1]),
9530: 0)]);
9531: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9532: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) <= 1 ?
9533: VideoController.vcnPal32G8[0] :
9534: (p & 1) == 0 ?
9535: VideoController.vcnPal32G8[p] :
9536: VideoController.vcnPalTbl[
9537: VideoController.vcnMix2 (
9538: VideoController.vcnMix2 (
9539: VideoController.vcnPal16G8[p & -2],
9540: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 8 & 1023] << 4 |
9541: MainMemory.mmrM8[gz3rd | gx3rd + 8 & 1023]) | 1]),
9542: 0)]);
9543: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9544: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) <= 1 ?
9545: VideoController.vcnPal32G8[0] :
9546: (p & 1) == 0 ?
9547: VideoController.vcnPal32G8[p] :
9548: VideoController.vcnPalTbl[
9549: VideoController.vcnMix2 (
9550: VideoController.vcnMix2 (
9551: VideoController.vcnPal16G8[p & -2],
9552: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 10 & 1023] << 4 |
9553: MainMemory.mmrM8[gz3rd | gx3rd + 10 & 1023]) | 1]),
9554: 0)]);
9555: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9556: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) <= 1 ?
9557: VideoController.vcnPal32G8[0] :
9558: (p & 1) == 0 ?
9559: VideoController.vcnPal32G8[p] :
9560: VideoController.vcnPalTbl[
9561: VideoController.vcnMix2 (
9562: VideoController.vcnMix2 (
9563: VideoController.vcnPal16G8[p & -2],
9564: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 12 & 1023] << 4 |
9565: MainMemory.mmrM8[gz3rd | gx3rd + 12 & 1023]) | 1]),
9566: 0)]);
9567: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9568: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) <= 1 ?
9569: VideoController.vcnPal32G8[0] :
9570: (p & 1) == 0 ?
9571: VideoController.vcnPal32G8[p] :
9572: VideoController.vcnPalTbl[
9573: VideoController.vcnMix2 (
9574: VideoController.vcnMix2 (
9575: VideoController.vcnPal16G8[p & -2],
9576: VideoController.vcnPal16G8[(MainMemory.mmrM8[gz4th | gx4th + 14 & 1023] << 4 |
9577: MainMemory.mmrM8[gz3rd | gx3rd + 14 & 1023]) | 1]),
9578: 0)]);
9579: gx1st += 16;
9580: gx2nd += 16;
9581: gx3rd += 16;
9582: gx4th += 16;
9583: da += 8;
9584: }
9585: }
9586: },
9587:
9588:
9589:
9590:
9591:
9592:
9593:
9594:
9595:
9596:
9597:
9598:
9599:
9600:
9601:
9602:
9603:
9604:
9605:
9606:
9607: F1_A {
9608: @Override public void drawRaster (int src, int dst, boolean rh) {
9609: int pn = VideoController.vcnReg2Curr & 3;
9610: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9611: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9612: pn = VideoController.vcnReg2Curr >> 2 & 3;
9613: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9614: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9615: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9616: int db = da + XEiJ.pnlScreenWidth;
9617: if (rh) {
9618: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9619: gx1st += half << 1;
9620: gx2nd += half << 1;
9621: da += half;
9622: }
9623: while (da < db) {
9624: XEiJ.pnlBM[da] = (VideoController.vcnPalTbl[
9625: VideoController.vcnMix2 (
9626: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9627: MainMemory.mmrM8[gy1st | gx1st & 1023])],
9628: VideoController.vcnPal16TS[0])]);
9629: XEiJ.pnlBM[da + 1] = (VideoController.vcnPalTbl[
9630: VideoController.vcnMix2 (
9631: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9632: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])],
9633: VideoController.vcnPal16TS[0])]);
9634: XEiJ.pnlBM[da + 2] = (VideoController.vcnPalTbl[
9635: VideoController.vcnMix2 (
9636: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9637: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])],
9638: VideoController.vcnPal16TS[0])]);
9639: XEiJ.pnlBM[da + 3] = (VideoController.vcnPalTbl[
9640: VideoController.vcnMix2 (
9641: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9642: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])],
9643: VideoController.vcnPal16TS[0])]);
9644: XEiJ.pnlBM[da + 4] = (VideoController.vcnPalTbl[
9645: VideoController.vcnMix2 (
9646: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9647: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])],
9648: VideoController.vcnPal16TS[0])]);
9649: XEiJ.pnlBM[da + 5] = (VideoController.vcnPalTbl[
9650: VideoController.vcnMix2 (
9651: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9652: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])],
9653: VideoController.vcnPal16TS[0])]);
9654: XEiJ.pnlBM[da + 6] = (VideoController.vcnPalTbl[
9655: VideoController.vcnMix2 (
9656: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9657: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])],
9658: VideoController.vcnPal16TS[0])]);
9659: XEiJ.pnlBM[da + 7] = (VideoController.vcnPalTbl[
9660: VideoController.vcnMix2 (
9661: VideoController.vcnPal16G8[(MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9662: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])],
9663: VideoController.vcnPal16TS[0])]);
9664: gx1st += 16;
9665: gx2nd += 16;
9666: da += 8;
9667: }
9668: }
9669: },
9670:
9671:
9672:
9673:
9674:
9675:
9676:
9677:
9678:
9679:
9680:
9681:
9682:
9683:
9684:
9685:
9686:
9687:
9688:
9689:
9690:
9691:
9692:
9693: F2 {
9694: @Override public void drawRaster (int src, int dst, boolean rh) {
9695: int pn = VideoController.vcnReg2Curr & 3;
9696: int gx1st = CRTC.crtR12GrXCurr[pn] << 1;
9697: int gy1st = VideoController.vcnVisible1st + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9698: pn = VideoController.vcnReg2Curr >> 2 & 3;
9699: int gx2nd = CRTC.crtR12GrXCurr[pn] << 1;
9700: int gy2nd = VideoController.vcnVisible2nd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9701: pn = VideoController.vcnReg2Curr >> 4 & 3;
9702: int gx3rd = CRTC.crtR12GrXCurr[pn] << 1;
9703: int gy3rd = VideoController.vcnVisible3rd + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9704: pn = VideoController.vcnReg2Curr >> 6 & 3;
9705: int gx4th = CRTC.crtR12GrXCurr[pn] << 1;
9706: int gy4th = VideoController.vcnVisible4th + ((CRTC.crtR13GrYZero[pn] + src & 511) << 10);
9707: int da = dst << XEiJ.PNL_BM_OFFSET_BITS;
9708: int db = da + XEiJ.pnlScreenWidth;
9709: if (rh) {
9710: int half = XEiJ.pnlScreenWidth >> 4 << 3;
9711: gx1st += half << 1;
9712: gx2nd += half << 1;
9713: gx3rd += half << 1;
9714: gx4th += half << 1;
9715: da += half;
9716: }
9717: while (da < db) {
9718: int p;
9719: XEiJ.pnlBM[da] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd & 1023] << 4 |
9720: MainMemory.mmrM8[gy1st | gx1st & 1023])) != 0 ?
9721: VideoController.vcnPal32G8[p] :
9722: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th & 1023] << 4 |
9723: MainMemory.mmrM8[gy3rd | gx3rd & 1023])]);
9724: XEiJ.pnlBM[da + 1] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 2 & 1023] << 4 |
9725: MainMemory.mmrM8[gy1st | gx1st + 2 & 1023])) != 0 ?
9726: VideoController.vcnPal32G8[p] :
9727: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 2 & 1023] << 4 |
9728: MainMemory.mmrM8[gy3rd | gx3rd + 2 & 1023])]);
9729: XEiJ.pnlBM[da + 2] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 4 & 1023] << 4 |
9730: MainMemory.mmrM8[gy1st | gx1st + 4 & 1023])) != 0 ?
9731: VideoController.vcnPal32G8[p] :
9732: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 4 & 1023] << 4 |
9733: MainMemory.mmrM8[gy3rd | gx3rd + 4 & 1023])]);
9734: XEiJ.pnlBM[da + 3] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 6 & 1023] << 4 |
9735: MainMemory.mmrM8[gy1st | gx1st + 6 & 1023])) != 0 ?
9736: VideoController.vcnPal32G8[p] :
9737: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 6 & 1023] << 4 |
9738: MainMemory.mmrM8[gy3rd | gx3rd + 6 & 1023])]);
9739: XEiJ.pnlBM[da + 4] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 8 & 1023] << 4 |
9740: MainMemory.mmrM8[gy1st | gx1st + 8 & 1023])) != 0 ?
9741: VideoController.vcnPal32G8[p] :
9742: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 8 & 1023] << 4 |
9743: MainMemory.mmrM8[gy3rd | gx3rd + 8 & 1023])]);
9744: XEiJ.pnlBM[da + 5] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 10 & 1023] << 4 |
9745: MainMemory.mmrM8[gy1st | gx1st + 10 & 1023])) != 0 ?
9746: VideoController.vcnPal32G8[p] :
9747: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 10 & 1023] << 4 |
9748: MainMemory.mmrM8[gy3rd | gx3rd + 10 & 1023])]);
9749: XEiJ.pnlBM[da + 6] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 12 & 1023] << 4 |
9750: MainMemory.mmrM8[gy1st | gx1st + 12 & 1023])) != 0 ?
9751: VideoController.vcnPal32G8[p] :
9752: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 12 & 1023] << 4 |
9753: MainMemory.mmrM8[gy3rd | gx3rd + 12 & 1023])]);
9754: XEiJ.pnlBM[da + 7] = ((p = (MainMemory.mmrM8[gy2nd | gx2nd + 14 & 1023] << 4 |
9755: MainMemory.mmrM8[gy1st | gx1st + 14 & 1023])) != 0 ?
9756: VideoController.vcnPal32G8[p] :
9757: VideoController.vcnPal32G8[(MainMemory.mmrM8[gy4th | gx4th + 14 & 1023] << 4 |
9758: MainMemory.mmrM8[gy3rd | gx3rd + 14 & 1023])]);
9759: gx1st += 16;
9760: gx2nd += 16;
9761: gx3rd += 16;
9762: gx4th += 16;
9763: da += 8;
9764: }
9765: }
9766: },
9767:
9768:
9769:
9770:
9771:
9772:
9773: XF2 {
9774: @Override public void drawRaster (int src, int dst, boolean rh) {
9775: switch (VideoController.vcnReg3Curr >>> 8 & 0b01011111) {
9776:
9777: case 0b00010000:
9778: case 0b00010001:
9779: case 0b00010010:
9