1 /*
2 * gtia.c - GTIA chip emulation
3 *
4 * Copyright (C) 1995-1998 David Firth
5 * Copyright (C) 1998-2005 Atari800 development team (see DOC/CREDITS)
6 *
7 * This file is part of the Atari800 emulator project which emulates
8 * the Atari 400, 800, 800XL, 130XE, and 5200 8-bit computers.
9 *
10 * Atari800 is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * Atari800 is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with Atari800; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 #include "config.h"
26 #include <string.h>
27
28 #include "antic.h"
29 #include "binload.h"
30 #include "cassette.h"
31 #include "cpu.h"
32 #include "gtia.h"
33 #ifndef BASIC
34 #include "input.h"
35 #include "statesav.h"
36 #endif
37 #include "pokeysnd.h"
38 #include "screen.h"
39
40 /* GTIA Registers ---------------------------------------------------------- */
41
42 UBYTE GTIA_M0PL;
43 UBYTE GTIA_M1PL;
44 UBYTE GTIA_M2PL;
45 UBYTE GTIA_M3PL;
46 UBYTE GTIA_P0PL;
47 UBYTE GTIA_P1PL;
48 UBYTE GTIA_P2PL;
49 UBYTE GTIA_P3PL;
50 UBYTE GTIA_HPOSP0;
51 UBYTE GTIA_HPOSP1;
52 UBYTE GTIA_HPOSP2;
53 UBYTE GTIA_HPOSP3;
54 UBYTE GTIA_HPOSM0;
55 UBYTE GTIA_HPOSM1;
56 UBYTE GTIA_HPOSM2;
57 UBYTE GTIA_HPOSM3;
58 UBYTE GTIA_SIZEP0;
59 UBYTE GTIA_SIZEP1;
60 UBYTE GTIA_SIZEP2;
61 UBYTE GTIA_SIZEP3;
62 UBYTE GTIA_SIZEM;
63 UBYTE GTIA_GRAFP0;
64 UBYTE GTIA_GRAFP1;
65 UBYTE GTIA_GRAFP2;
66 UBYTE GTIA_GRAFP3;
67 UBYTE GTIA_GRAFM;
68 UBYTE GTIA_COLPM0;
69 UBYTE GTIA_COLPM1;
70 UBYTE GTIA_COLPM2;
71 UBYTE GTIA_COLPM3;
72 UBYTE GTIA_COLPF0;
73 UBYTE GTIA_COLPF1;
74 UBYTE GTIA_COLPF2;
75 UBYTE GTIA_COLPF3;
76 UBYTE GTIA_COLBK;
77 UBYTE GTIA_PRIOR;
78 UBYTE GTIA_VDELAY;
79 UBYTE GTIA_GRACTL;
80
81 /* Internal GTIA state ----------------------------------------------------- */
82
83 int GTIA_speaker;
84 int GTIA_consol_override = 0;
85 static UBYTE consol;
86 UBYTE consol_mask;
87 UBYTE GTIA_TRIG[4];
88 UBYTE GTIA_TRIG_latch[4];
89
90 #if defined(BASIC) || defined(CURSES_BASIC)
91
92 static UBYTE PF0PM = 0;
93 static UBYTE PF1PM = 0;
94 static UBYTE PF2PM = 0;
95 static UBYTE PF3PM = 0;
96 #define GTIA_collisions_mask_missile_playfield 0
97 #define GTIA_collisions_mask_player_playfield 0
98 #define GTIA_collisions_mask_missile_player 0
99 #define GTIA_collisions_mask_player_player 0
100
101 #else /* defined(BASIC) || defined(CURSES_BASIC) */
102
103 void set_prior(UBYTE byte); /* in antic.c */
104
105 /* Player/Missile stuff ---------------------------------------------------- */
106
107 /* change to 0x00 to disable collisions */
108 UBYTE GTIA_collisions_mask_missile_playfield = 0x0f;
109 UBYTE GTIA_collisions_mask_player_playfield = 0x0f;
110 UBYTE GTIA_collisions_mask_missile_player = 0x0f;
111 UBYTE GTIA_collisions_mask_player_player = 0x0f;
112
113 #ifdef NEW_CYCLE_EXACT
114 /* temporary collision registers for the current scanline only */
115 UBYTE P1PL_T;
116 UBYTE P2PL_T;
117 UBYTE P3PL_T;
118 UBYTE M0PL_T;
119 UBYTE M1PL_T;
120 UBYTE M2PL_T;
121 UBYTE M3PL_T;
122 /* If partial collisions have been generated during a scanline, this
123 * is the position of the up-to-date collision point , otherwise it is 0
124 */
125 int collision_curpos;
126 /* if hitclr has been written to during a scanline, this is the position
127 * within pm_scaline at which it was written to, and collisions should
128 * only be generated from this point on, otherwise it is 0
129 */
130 int hitclr_pos;
131 #else
132 #define P1PL_T GTIA_P1PL
133 #define P2PL_T GTIA_P2PL
134 #define P3PL_T GTIA_P3PL
135 #define M0PL_T GTIA_M0PL
136 #define M1PL_T GTIA_M1PL
137 #define M2PL_T GTIA_M2PL
138 #define M3PL_T GTIA_M3PL
139 #endif /* NEW_CYCLE_EXACT */
140
141 static UBYTE *hposp_ptr[4];
142 static UBYTE *hposm_ptr[4];
143 static ULONG hposp_mask[4];
144
145 static ULONG grafp_lookup[4][256];
146 static ULONG *grafp_ptr[4];
147 static int global_sizem[4];
148
149 static const int PM_Width[4] = {1, 2, 1, 4};
150
151 /* Meaning of bits in GTIA_pm_scanline:
152 bit 0 - Player 0
153 bit 1 - Player 1
154 bit 2 - Player 2
155 bit 3 - Player 3
156 bit 4 - Missile 0
157 bit 5 - Missile 1
158 bit 6 - Missile 2
159 bit 7 - Missile 3
160 */
161
162 UBYTE GTIA_pm_scanline[Screen_WIDTH / 2 + 8]; /* there's a byte for every *pair* of pixels */
163 int GTIA_pm_dirty = TRUE;
164
165 #define C_PM0 0x01
166 #define C_PM1 0x02
167 #define C_PM01 0x03
168 #define C_PM2 0x04
169 #define C_PM3 0x05
170 #define C_PM23 0x06
171 #define C_PM023 0x07
172 #define C_PM123 0x08
173 #define C_PM0123 0x09
174 #define C_PM25 0x0a
175 #define C_PM35 0x0b
176 #define C_PM235 0x0c
177 #define C_COLLS 0x0d
178 #define C_BAK 0x00
179 #define C_HI2 0x20
180 #define C_HI3 0x30
181 #define C_PF0 0x40
182 #define C_PF1 0x50
183 #define C_PF2 0x60
184 #define C_PF3 0x70
185
186 #define PF0PM (*(UBYTE *) &ANTIC_cl[C_PF0 | C_COLLS])
187 #define PF1PM (*(UBYTE *) &ANTIC_cl[C_PF1 | C_COLLS])
188 #define PF2PM (*(UBYTE *) &ANTIC_cl[C_PF2 | C_COLLS])
189 #define PF3PM (*(UBYTE *) &ANTIC_cl[C_PF3 | C_COLLS])
190
191 /* Colours ----------------------------------------------------------------- */
192
193 #ifdef USE_COLOUR_TRANSLATION_TABLE
194 UWORD colour_translation_table[256];
195 #endif /* USE_COLOUR_TRANSLATION_TABLE */
196
setup_gtia9_11(void)197 static void setup_gtia9_11(void) {
198 int i;
199 #ifdef USE_COLOUR_TRANSLATION_TABLE
200 UWORD temp;
201 temp = colour_translation_table[GTIA_COLBK & 0xf0];
202 ANTIC_lookup_gtia11[0] = ((ULONG) temp << 16) + temp;
203 for (i = 1; i < 16; i++) {
204 temp = colour_translation_table[GTIA_COLBK | i];
205 ANTIC_lookup_gtia9[i] = ((ULONG) temp << 16) + temp;
206 temp = colour_translation_table[GTIA_COLBK | (i << 4)];
207 ANTIC_lookup_gtia11[i] = ((ULONG) temp << 16) + temp;
208 }
209 #else
210 ULONG count9 = 0;
211 ULONG count11 = 0;
212 ANTIC_lookup_gtia11[0] = ANTIC_lookup_gtia9[0] & 0xf0f0f0f0;
213 for (i = 1; i < 16; i++) {
214 ANTIC_lookup_gtia9[i] = ANTIC_lookup_gtia9[0] | (count9 += 0x01010101);
215 ANTIC_lookup_gtia11[i] = ANTIC_lookup_gtia9[0] | (count11 += 0x10101010);
216 }
217 #endif
218 }
219
220 #endif /* defined(BASIC) || defined(CURSES_BASIC) */
221
222 /* Initialization ---------------------------------------------------------- */
223
GTIA_Initialise(int * argc,char * argv[])224 int GTIA_Initialise(int *argc, char *argv[])
225 {
226 #if !defined(BASIC) && !defined(CURSES_BASIC)
227 int i;
228 for (i = 0; i < 256; i++) {
229 int tmp = i + 0x100;
230 ULONG grafp1 = 0;
231 ULONG grafp2 = 0;
232 ULONG grafp4 = 0;
233 do {
234 grafp1 <<= 1;
235 grafp2 <<= 2;
236 grafp4 <<= 4;
237 if (tmp & 1) {
238 grafp1++;
239 grafp2 += 3;
240 grafp4 += 15;
241 }
242 tmp >>= 1;
243 } while (tmp != 1);
244 grafp_lookup[2][i] = grafp_lookup[0][i] = grafp1;
245 grafp_lookup[1][i] = grafp2;
246 grafp_lookup[3][i] = grafp4;
247 }
248 memset(ANTIC_cl, GTIA_COLOUR_BLACK, sizeof(ANTIC_cl));
249 for (i = 0; i < 32; i++)
250 GTIA_PutByte((UWORD) i, 0);
251 #endif /* !defined(BASIC) && !defined(CURSES_BASIC) */
252
253 return TRUE;
254 }
255
256 #ifdef NEW_CYCLE_EXACT
257
258 /* generate updated PxPL and MxPL for part of a scanline */
259 /* slow, but should be called rarely */
generate_partial_pmpl_colls(int l,int r)260 static void generate_partial_pmpl_colls(int l, int r)
261 {
262 int i;
263 if (r < 0 || l >= (int) sizeof(GTIA_pm_scanline) / (int) sizeof(GTIA_pm_scanline[0]))
264 return;
265 if (r >= (int) sizeof(GTIA_pm_scanline) / (int) sizeof(GTIA_pm_scanline[0])) {
266 r = (int) sizeof(GTIA_pm_scanline) / (int) sizeof(GTIA_pm_scanline[0]);
267 }
268 if (l < 0)
269 l = 0;
270
271 for (i = l; i <= r; i++) {
272 UBYTE p = GTIA_pm_scanline[i];
273 /* It is possible that some bits are set in PxPL/MxPL here, which would
274 * not otherwise be set ever in GTIA_NewPmScanline. This is because the
275 * player collisions are always generated in order in GTIA_NewPmScanline.
276 * However this does not cause any problem because we never use those bits
277 * of PxPL/MxPL in the collision reading code.
278 */
279 GTIA_P1PL |= (p & (1 << 1)) ? p : 0;
280 GTIA_P2PL |= (p & (1 << 2)) ? p : 0;
281 GTIA_P3PL |= (p & (1 << 3)) ? p : 0;
282 GTIA_M0PL |= (p & (0x10 << 0)) ? p : 0;
283 GTIA_M1PL |= (p & (0x10 << 1)) ? p : 0;
284 GTIA_M2PL |= (p & (0x10 << 2)) ? p : 0;
285 GTIA_M3PL |= (p & (0x10 << 3)) ? p : 0;
286 }
287
288 }
289
290 /* update pm->pl collisions for a partial scanline */
update_partial_pmpl_colls(void)291 static void update_partial_pmpl_colls(void)
292 {
293 int l = collision_curpos;
294 int r = ANTIC_XPOS * 2 - 37;
295 generate_partial_pmpl_colls(l, r);
296 collision_curpos = r;
297 }
298
299 /* update pm-> pl collisions at the end of a scanline */
GTIA_UpdatePmplColls(void)300 void GTIA_UpdatePmplColls(void)
301 {
302 if (hitclr_pos != 0){
303 generate_partial_pmpl_colls(hitclr_pos,
304 sizeof(GTIA_pm_scanline) / sizeof(GTIA_pm_scanline[0]) - 1);
305 /* If hitclr was written to, then only part of GTIA_pm_scanline should be used
306 * for collisions */
307
308 }
309 else {
310 /* otherwise the whole of pm_scaline can be used for collisions. This will
311 * update the collision registers based on the generated collisions for the
312 * current line */
313 GTIA_P1PL |= P1PL_T;
314 GTIA_P2PL |= P2PL_T;
315 GTIA_P3PL |= P3PL_T;
316 GTIA_M0PL |= M0PL_T;
317 GTIA_M1PL |= M1PL_T;
318 GTIA_M2PL |= M2PL_T;
319 GTIA_M3PL |= M3PL_T;
320 }
321 collision_curpos = 0;
322 hitclr_pos = 0;
323 }
324
325 #else
326 #define update_partial_pmpl_colls()
327 #endif /* NEW_CYCLE_EXACT */
328
329 /* Prepare PMG scanline ---------------------------------------------------- */
330
331 #if !defined(BASIC) && !defined(CURSES_BASIC)
332
GTIA_NewPmScanline(void)333 void GTIA_NewPmScanline(void)
334 {
335 #ifdef NEW_CYCLE_EXACT
336 /* reset temporary pm->pl collisions */
337 P1PL_T = P2PL_T = P3PL_T = 0;
338 M0PL_T = M1PL_T = M2PL_T = M3PL_T = 0;
339 #endif /* NEW_CYCLE_EXACT */
340 /* Clear if necessary */
341 if (GTIA_pm_dirty) {
342 memset(GTIA_pm_scanline, 0, Screen_WIDTH / 2);
343 GTIA_pm_dirty = FALSE;
344 }
345
346 /* Draw Players */
347
348 #define DO_PLAYER(n) if (GTIA_GRAFP##n) { \
349 ULONG grafp = grafp_ptr[n][GTIA_GRAFP##n] & hposp_mask[n]; \
350 if (grafp) { \
351 UBYTE *ptr = hposp_ptr[n]; \
352 GTIA_pm_dirty = TRUE; \
353 do { \
354 if (grafp & 1) \
355 P##n##PL_T |= *ptr |= 1 << n; \
356 ptr++; \
357 grafp >>= 1; \
358 } while (grafp); \
359 } \
360 }
361
362 /* optimized DO_PLAYER(0): GTIA_pm_scanline is clear and P0PL is unused */
363 if (GTIA_GRAFP0) {
364 ULONG grafp = grafp_ptr[0][GTIA_GRAFP0] & hposp_mask[0];
365 if (grafp) {
366 UBYTE *ptr = hposp_ptr[0];
367 GTIA_pm_dirty = TRUE;
368 do {
369 if (grafp & 1)
370 *ptr = 1;
371 ptr++;
372 grafp >>= 1;
373 } while (grafp);
374 }
375 }
376
377 DO_PLAYER(1)
378 DO_PLAYER(2)
379 DO_PLAYER(3)
380
381 /* Draw Missiles */
382
383 #define DO_MISSILE(n,p,m,r,l) if (GTIA_GRAFM & m) { \
384 int j = global_sizem[n]; \
385 UBYTE *ptr = hposm_ptr[n]; \
386 if (GTIA_GRAFM & r) { \
387 if (GTIA_GRAFM & l) \
388 j <<= 1; \
389 } \
390 else \
391 ptr += j; \
392 if (ptr < GTIA_pm_scanline + 2) { \
393 j += ptr - GTIA_pm_scanline - 2; \
394 ptr = GTIA_pm_scanline + 2; \
395 } \
396 else if (ptr + j > GTIA_pm_scanline + Screen_WIDTH / 2 - 2) \
397 j = GTIA_pm_scanline + Screen_WIDTH / 2 - 2 - ptr; \
398 if (j > 0) \
399 do \
400 M##n##PL_T |= *ptr++ |= p; \
401 while (--j); \
402 }
403
404 if (GTIA_GRAFM) {
405 GTIA_pm_dirty = TRUE;
406 DO_MISSILE(3, 0x80, 0xc0, 0x80, 0x40)
407 DO_MISSILE(2, 0x40, 0x30, 0x20, 0x10)
408 DO_MISSILE(1, 0x20, 0x0c, 0x08, 0x04)
409 DO_MISSILE(0, 0x10, 0x03, 0x02, 0x01)
410 }
411 }
412
413 #endif /* !defined(BASIC) && !defined(CURSES_BASIC) */
414
415 /* GTIA registers ---------------------------------------------------------- */
416
GTIA_Frame(void)417 void GTIA_Frame(void)
418 {
419 #ifdef BASIC
420 consol = 0xf;
421 #else
422 consol = INPUT_key_consol | 0x08;
423 #endif
424
425 if (GTIA_GRACTL & 4) {
426 GTIA_TRIG_latch[0] &= GTIA_TRIG[0];
427 GTIA_TRIG_latch[1] &= GTIA_TRIG[1];
428 GTIA_TRIG_latch[2] &= GTIA_TRIG[2];
429 GTIA_TRIG_latch[3] &= GTIA_TRIG[3];
430 }
431 }
432
GTIA_GetByte(UWORD addr,int no_side_effects)433 UBYTE GTIA_GetByte(UWORD addr, int no_side_effects)
434 {
435 switch (addr & 0x1f) {
436 case GTIA_OFFSET_M0PF:
437 return (((PF0PM & 0x10) >> 4)
438 + ((PF1PM & 0x10) >> 3)
439 + ((PF2PM & 0x10) >> 2)
440 + ((PF3PM & 0x10) >> 1)) & GTIA_collisions_mask_missile_playfield;
441 case GTIA_OFFSET_M1PF:
442 return (((PF0PM & 0x20) >> 5)
443 + ((PF1PM & 0x20) >> 4)
444 + ((PF2PM & 0x20) >> 3)
445 + ((PF3PM & 0x20) >> 2)) & GTIA_collisions_mask_missile_playfield;
446 case GTIA_OFFSET_M2PF:
447 return (((PF0PM & 0x40) >> 6)
448 + ((PF1PM & 0x40) >> 5)
449 + ((PF2PM & 0x40) >> 4)
450 + ((PF3PM & 0x40) >> 3)) & GTIA_collisions_mask_missile_playfield;
451 case GTIA_OFFSET_M3PF:
452 return (((PF0PM & 0x80) >> 7)
453 + ((PF1PM & 0x80) >> 6)
454 + ((PF2PM & 0x80) >> 5)
455 + ((PF3PM & 0x80) >> 4)) & GTIA_collisions_mask_missile_playfield;
456 case GTIA_OFFSET_P0PF:
457 return ((PF0PM & 0x01)
458 + ((PF1PM & 0x01) << 1)
459 + ((PF2PM & 0x01) << 2)
460 + ((PF3PM & 0x01) << 3)) & GTIA_collisions_mask_player_playfield;
461 case GTIA_OFFSET_P1PF:
462 return (((PF0PM & 0x02) >> 1)
463 + (PF1PM & 0x02)
464 + ((PF2PM & 0x02) << 1)
465 + ((PF3PM & 0x02) << 2)) & GTIA_collisions_mask_player_playfield;
466 case GTIA_OFFSET_P2PF:
467 return (((PF0PM & 0x04) >> 2)
468 + ((PF1PM & 0x04) >> 1)
469 + (PF2PM & 0x04)
470 + ((PF3PM & 0x04) << 1)) & GTIA_collisions_mask_player_playfield;
471 case GTIA_OFFSET_P3PF:
472 return (((PF0PM & 0x08) >> 3)
473 + ((PF1PM & 0x08) >> 2)
474 + ((PF2PM & 0x08) >> 1)
475 + (PF3PM & 0x08)) & GTIA_collisions_mask_player_playfield;
476 case GTIA_OFFSET_M0PL:
477 update_partial_pmpl_colls();
478 return GTIA_M0PL & GTIA_collisions_mask_missile_player;
479 case GTIA_OFFSET_M1PL:
480 update_partial_pmpl_colls();
481 return GTIA_M1PL & GTIA_collisions_mask_missile_player;
482 case GTIA_OFFSET_M2PL:
483 update_partial_pmpl_colls();
484 return GTIA_M2PL & GTIA_collisions_mask_missile_player;
485 case GTIA_OFFSET_M3PL:
486 update_partial_pmpl_colls();
487 return GTIA_M3PL & GTIA_collisions_mask_missile_player;
488 case GTIA_OFFSET_P0PL:
489 update_partial_pmpl_colls();
490 return (((GTIA_P1PL & 0x01) << 1) /* mask in player 1 */
491 + ((GTIA_P2PL & 0x01) << 2) /* mask in player 2 */
492 + ((GTIA_P3PL & 0x01) << 3)) /* mask in player 3 */
493 & GTIA_collisions_mask_player_player;
494 case GTIA_OFFSET_P1PL:
495 update_partial_pmpl_colls();
496 return ((GTIA_P1PL & 0x01) /* mask in player 0 */
497 + ((GTIA_P2PL & 0x02) << 1) /* mask in player 2 */
498 + ((GTIA_P3PL & 0x02) << 2)) /* mask in player 3 */
499 & GTIA_collisions_mask_player_player;
500 case GTIA_OFFSET_P2PL:
501 update_partial_pmpl_colls();
502 return ((GTIA_P2PL & 0x03) /* mask in player 0 and 1 */
503 + ((GTIA_P3PL & 0x04) << 1)) /* mask in player 3 */
504 & GTIA_collisions_mask_player_player;
505 case GTIA_OFFSET_P3PL:
506 update_partial_pmpl_colls();
507 return (GTIA_P3PL & 0x07) /* mask in player 0,1, and 2 */
508 & GTIA_collisions_mask_player_player;
509 case GTIA_OFFSET_TRIG0:
510 return GTIA_TRIG[0] & GTIA_TRIG_latch[0];
511 case GTIA_OFFSET_TRIG1:
512 return GTIA_TRIG[1] & GTIA_TRIG_latch[1];
513 case GTIA_OFFSET_TRIG2:
514 return GTIA_TRIG[2] & GTIA_TRIG_latch[2];
515 case GTIA_OFFSET_TRIG3:
516 return GTIA_TRIG[3] & GTIA_TRIG_latch[3];
517 case GTIA_OFFSET_PAL:
518 return (Atari800_tv_mode == Atari800_TV_PAL) ? 0x01 : 0x0f;
519 case GTIA_OFFSET_CONSOL:
520 {
521 UBYTE byte = consol & consol_mask;
522 if (!no_side_effects && GTIA_consol_override > 0) {
523 /* Check if we're called from outside OS. This avoids sending
524 console keystrokes to diagnostic cartridges. */
525 if (CPU_regPC < 0xc000)
526 /* Not from OS. Disable console override. */
527 GTIA_consol_override = 0;
528 else {
529 --GTIA_consol_override;
530 if (Atari800_builtin_basic && Atari800_disable_basic && !BINLOAD_loading_basic)
531 /* Only for XL/XE - hold Option during reboot. */
532 byte &= ~INPUT_CONSOL_OPTION;
533 if (CASSETTE_hold_start && Atari800_machine_type != Atari800_MACHINE_5200) {
534 /* Only for the computers - hold Start during reboot. */
535 byte &= ~INPUT_CONSOL_START;
536 if (GTIA_consol_override == 0) {
537 /* press Space after Start to start cassette boot. */
538 CASSETTE_press_space = 1;
539 CASSETTE_hold_start = CASSETTE_hold_start_on_reboot;
540 }
541 }
542 }
543 }
544 return byte;
545 }
546 default:
547 break;
548 }
549
550 return 0xf;
551 }
552
GTIA_PutByte(UWORD addr,UBYTE byte)553 void GTIA_PutByte(UWORD addr, UBYTE byte)
554 {
555 #if !defined(BASIC) && !defined(CURSES_BASIC)
556 UWORD cword;
557 UWORD cword2;
558
559 #ifdef NEW_CYCLE_EXACT
560 int x; /* the cycle-exact update position in GTIA_pm_scanline */
561 if (ANTIC_DRAWING_SCREEN) {
562 if ((addr & 0x1f) != GTIA_PRIOR) {
563 ANTIC_UpdateScanline();
564 } else {
565 ANTIC_UpdateScanlinePrior(byte);
566 }
567 }
568 #define UPDATE_PM_CYCLE_EXACT if(ANTIC_DRAWING_SCREEN) GTIA_NewPmScanline();
569 #else
570 #define UPDATE_PM_CYCLE_EXACT
571 #endif
572
573 #endif /* !defined(BASIC) && !defined(CURSES_BASIC) */
574
575 switch (addr & 0x1f) {
576 case GTIA_OFFSET_CONSOL:
577 GTIA_speaker = !(byte & 0x08);
578 #ifdef CONSOLE_SOUND
579 POKEYSND_UpdateConsol(1);
580 #endif
581 consol_mask = (~byte) & 0x0f;
582 break;
583
584 #if defined(BASIC) || defined(CURSES_BASIC)
585
586 /* We use these for Antic modes 6, 7 on Curses */
587 case GTIA_OFFSET_COLPF0:
588 GTIA_COLPF0 = byte;
589 break;
590 case GTIA_OFFSET_COLPF1:
591 GTIA_COLPF1 = byte;
592 break;
593 case GTIA_OFFSET_COLPF2:
594 GTIA_COLPF2 = byte;
595 break;
596 case GTIA_OFFSET_COLPF3:
597 GTIA_COLPF3 = byte;
598 break;
599
600 #else
601
602 #ifdef USE_COLOUR_TRANSLATION_TABLE
603 case GTIA_OFFSET_COLBK:
604 GTIA_COLBK = byte &= 0xfe;
605 ANTIC_cl[C_BAK] = cword = colour_translation_table[byte];
606 if (cword != (UWORD) (ANTIC_lookup_gtia9[0]) ) {
607 ANTIC_lookup_gtia9[0] = cword + (cword << 16);
608 if (GTIA_PRIOR & 0x40)
609 setup_gtia9_11();
610 }
611 break;
612 case GTIA_OFFSET_COLPF0:
613 GTIA_COLPF0 = byte &= 0xfe;
614 ANTIC_cl[C_PF0] = cword = GTIA_colour_translation_table[byte];
615 if ((GTIA_PRIOR & 1) == 0) {
616 ANTIC_cl[C_PF0 | C_PM23] = ANTIC_cl[C_PF0 | C_PM3] = ANTIC_cl[C_PF0 | C_PM2] = cword;
617 if ((GTIA_PRIOR & 3) == 0) {
618 if (GTIA_PRIOR & 0xf) {
619 ANTIC_cl[C_PF0 | C_PM01] = ANTIC_cl[C_PF0 | C_PM1] = ANTIC_cl[C_PF0 | C_PM0] = cword;
620 if ((GTIA_PRIOR & 0xf) == 0xc)
621 ANTIC_cl[C_PF0 | C_PM0123] = ANTIC_cl[C_PF0 | C_PM123] = ANTIC_cl[C_PF0 | C_PM023] = cword;
622 }
623 else {
624 ANTIC_cl[C_PF0 | C_PM0] = colour_translation_table[byte | GTIA_COLPM0];
625 ANTIC_cl[C_PF0 | C_PM1] = colour_translation_table[byte | GTIA_COLPM1];
626 ANTIC_cl[C_PF0 | C_PM01] = colour_translation_table[byte | GTIA_COLPM0 | GTIA_COLPM1];
627 }
628 }
629 if ((GTIA_PRIOR & 0xf) >= 0xa)
630 ANTIC_cl[C_PF0 | C_PM25] = cword;
631 }
632 break;
633 case GTIA_OFFSET_COLPF1:
634 GTIA_COLPF1 = byte &= 0xfe;
635 ANTIC_cl[C_PF1] = cword = GTIA_colour_translation_table[byte];
636 if ((GTIA_PRIOR & 1) == 0) {
637 ANTIC_cl[C_PF1 | C_PM23] = ANTIC_cl[C_PF1 | C_PM3] = ANTIC_cl[C_PF1 | C_PM2] = cword;
638 if ((GTIA_PRIOR & 3) == 0) {
639 if (GTIA_PRIOR & 0xf) {
640 ANTIC_cl[C_PF1 | C_PM01] = ANTIC_cl[C_PF1 | C_PM1] = ANTIC_cl[C_PF1 | C_PM0] = cword;
641 if ((GTIA_PRIOR & 0xf) == 0xc)
642 ANTIC_cl[C_PF1 | C_PM0123] = ANTIC_cl[C_PF1 | C_PM123] = ANTIC_cl[C_PF1 | C_PM023] = cword;
643 }
644 else {
645 ANTIC_cl[C_PF1 | C_PM0] = colour_translation_table[byte | GTIA_COLPM0];
646 ANTIC_cl[C_PF1 | C_PM1] = colour_translation_table[byte | GTIA_COLPM1];
647 ANTIC_cl[C_PF1 | C_PM01] = colour_translation_table[byte | GTIA_COLPM0 | GTIA_COLPM1];
648 }
649 }
650 }
651 {
652 UBYTE byte2 = (GTIA_COLPF2 & 0xf0) + (byte & 0xf);
653 ANTIC_cl[C_HI2] = cword = colour_translation_table[byte2];
654 ANTIC_cl[C_HI3] = colour_translation_table[(GTIA_COLPF3 & 0xf0) | (byte & 0xf)];
655 if (GTIA_PRIOR & 4)
656 ANTIC_cl[C_HI2 | C_PM01] = ANTIC_cl[C_HI2 | C_PM1] = ANTIC_cl[C_HI2 | C_PM0] = cword;
657 if ((GTIA_PRIOR & 9) == 0) {
658 if (GTIA_PRIOR & 0xf)
659 ANTIC_cl[C_HI2 | C_PM23] = ANTIC_cl[C_HI2 | C_PM3] = ANTIC_cl[C_HI2 | C_PM2] = cword;
660 else {
661 ANTIC_cl[C_HI2 | C_PM2] = colour_translation_table[byte2 | (GTIA_COLPM2 & 0xf0)];
662 ANTIC_cl[C_HI2 | C_PM3] = colour_translation_table[byte2 | (GTIA_COLPM3 & 0xf0)];
663 ANTIC_cl[C_HI2 | C_PM23] = colour_translation_table[byte2 | ((GTIA_COLPM2 | GTIA_COLPM3) & 0xf0)];
664 }
665 }
666 }
667 break;
668 case GTIA_OFFSET_COLPF2:
669 GTIA_COLPF2 = byte &= 0xfe;
670 ANTIC_cl[C_PF2] = cword = GTIA_colour_translation_table[byte];
671 {
672 UBYTE byte2 = (byte & 0xf0) + (GTIA_COLPF1 & 0xf);
673 ANTIC_cl[C_HI2] = cword2 = colour_translation_table[byte2];
674 if (GTIA_PRIOR & 4) {
675 ANTIC_cl[C_PF2 | C_PM01] = ANTIC_cl[C_PF2 | C_PM1] = ANTIC_cl[C_PF2 | C_PM0] = cword;
676 ANTIC_cl[C_HI2 | C_PM01] = ANTIC_cl[C_HI2 | C_PM1] = ANTIC_cl[C_HI2 | C_PM0] = cword2;
677 }
678 if ((GTIA_PRIOR & 9) == 0) {
679 if (GTIA_PRIOR & 0xf) {
680 ANTIC_cl[C_PF2 | C_PM23] = ANTIC_cl[C_PF2 | C_PM3] = ANTIC_cl[C_PF2 | C_PM2] = cword;
681 ANTIC_cl[C_HI2 | C_PM23] = ANTIC_cl[C_HI2 | C_PM3] = ANTIC_cl[C_HI2 | C_PM2] = cword2;
682 }
683 else {
684 ANTIC_cl[C_PF2 | C_PM2] = colour_translation_table[byte | GTIA_COLPM2];
685 ANTIC_cl[C_PF2 | C_PM3] = colour_translation_table[byte | GTIA_COLPM3];
686 ANTIC_cl[C_PF2 | C_PM23] = colour_translation_table[byte | GTIA_COLPM2 | GTIA_COLPM3];
687 ANTIC_cl[C_HI2 | C_PM2] = colour_translation_table[byte2 | (GTIA_COLPM2 & 0xf0)];
688 ANTIC_cl[C_HI2 | C_PM3] = colour_translation_table[byte2 | (GTIA_COLPM3 & 0xf0)];
689 ANTIC_cl[C_HI2 | C_PM23] = colour_translation_table[byte2 | ((GTIA_COLPM2 | GTIA_COLPM3) & 0xf0)];
690 }
691 }
692 }
693 break;
694 case GTIA_OFFSET_COLPF3:
695 GTIA_COLPF3 = byte &= 0xfe;
696 ANTIC_cl[C_PF3] = cword = colour_translation_table[byte];
697 ANTIC_cl[C_HI3] = cword2 = colour_translation_table[(byte & 0xf0) | (GTIA_COLPF1 & 0xf)];
698 if (GTIA_PRIOR & 4)
699 ANTIC_cl[C_PF3 | C_PM01] = ANTIC_cl[C_PF3 | C_PM1] = ANTIC_cl[C_PF3 | C_PM0] = cword;
700 if ((GTIA_PRIOR & 9) == 0) {
701 if (GTIA_PRIOR & 0xf)
702 ANTIC_cl[C_PF3 | C_PM23] = ANTIC_cl[C_PF3 | C_PM3] = ANTIC_cl[C_PF3 | C_PM2] = cword;
703 else {
704 ANTIC_cl[C_PF3 | C_PM25] = ANTIC_cl[C_PF2 | C_PM25] = ANTIC_cl[C_PM25] = ANTIC_cl[C_PF3 | C_PM2] = colour_translation_table[byte | GTIA_COLPM2];
705 ANTIC_cl[C_PF3 | C_PM35] = ANTIC_cl[C_PF2 | C_PM35] = ANTIC_cl[C_PM35] = ANTIC_cl[C_PF3 | C_PM3] = colour_translation_table[byte | GTIA_COLPM3];
706 ANTIC_cl[C_PF3 | C_PM235] = ANTIC_cl[C_PF2 | C_PM235] = ANTIC_cl[C_PM235] = ANTIC_cl[C_PF3 | C_PM23] = colour_translation_table[byte | GTIA_COLPM2 | GTIA_COLPM3];
707 ANTIC_cl[C_PF0 | C_PM235] = ANTIC_cl[C_PF0 | C_PM35] = ANTIC_cl[C_PF0 | C_PM25] =
708 ANTIC_cl[C_PF1 | C_PM235] = ANTIC_cl[C_PF1 | C_PM35] = ANTIC_cl[C_PF1 | C_PM25] = cword;
709 }
710 }
711 break;
712 case GTIA_OFFSET_COLPM0:
713 GTIA_COLPM0 = byte &= 0xfe;
714 ANTIC_cl[C_PM023] = ANTIC_cl[C_PM0] = cword = colour_translation_table[byte];
715 {
716 UBYTE byte2 = byte | GTIA_COLPM1;
717 ANTIC_cl[C_PM0123] = ANTIC_cl[C_PM01] = cword2 = colour_translation_table[byte2];
718 if ((GTIA_PRIOR & 4) == 0) {
719 ANTIC_cl[C_PF2 | C_PM0] = ANTIC_cl[C_PF3 | C_PM0] = cword;
720 ANTIC_cl[C_PF2 | C_PM01] = ANTIC_cl[C_PF3 | C_PM01] = cword2;
721 ANTIC_cl[C_HI2 | C_PM0] = colour_translation_table[(byte & 0xf0) | (GTIA_COLPF1 & 0xf)];
722 ANTIC_cl[C_HI2 | C_PM01] = colour_translation_table[(byte2 & 0xf0) | (GTIA_COLPF1 & 0xf)];
723 if ((GTIA_PRIOR & 0xc) == 0) {
724 if (GTIA_PRIOR & 3) {
725 ANTIC_cl[C_PF0 | C_PM0] = ANTIC_cl[C_PF1 | C_PM0] = cword;
726 ANTIC_cl[C_PF0 | C_PM01] = ANTIC_cl[C_PF1 | C_PM01] = cword2;
727 }
728 else {
729 ANTIC_cl[C_PF0 | C_PM0] = colour_translation_table[byte | GTIA_COLPF0];
730 ANTIC_cl[C_PF1 | C_PM0] = colour_translation_table[byte | GTIA_COLPF1];
731 ANTIC_cl[C_PF0 | C_PM01] = colour_translation_table[byte2 | GTIA_COLPF0];
732 ANTIC_cl[C_PF1 | C_PM01] = colour_translation_table[byte2 | GTIA_COLPF1];
733 }
734 }
735 }
736 }
737 break;
738 case GTIA_OFFSET_COLPM1:
739 GTIA_COLPM1 = byte &= 0xfe;
740 ANTIC_cl[C_PM123] = ANTIC_cl[C_PM1] = cword = colour_translation_table[byte];
741 {
742 UBYTE byte2 = byte | GTIA_COLPM0;
743 ANTIC_cl[C_PM0123] = ANTIC_cl[C_PM01] = cword2 = colour_translation_table[byte2];
744 if ((GTIA_PRIOR & 4) == 0) {
745 ANTIC_cl[C_PF2 | C_PM1] = ANTIC_cl[C_PF3 | C_PM1] = cword;
746 ANTIC_cl[C_PF2 | C_PM01] = ANTIC_cl[C_PF3 | C_PM01] = cword2;
747 ANTIC_cl[C_HI2 | C_PM1] = colour_translation_table[(byte & 0xf0) | (GTIA_COLPF1 & 0xf)];
748 ANTIC_cl[C_HI2 | C_PM01] = colour_translation_table[(byte2 & 0xf0) | (GTIA_COLPF1 & 0xf)];
749 if ((GTIA_PRIOR & 0xc) == 0) {
750 if (GTIA_PRIOR & 3) {
751 ANTIC_cl[C_PF0 | C_PM1] = ANTIC_cl[C_PF1 | C_PM1] = cword;
752 ANTIC_cl[C_PF0 | C_PM01] = ANTIC_cl[C_PF1 | C_PM01] = cword2;
753 }
754 else {
755 ANTIC_cl[C_PF0 | C_PM1] = colour_translation_table[byte | GTIA_COLPF0];
756 ANTIC_cl[C_PF1 | C_PM1] = colour_translation_table[byte | GTIA_COLPF1];
757 ANTIC_cl[C_PF0 | C_PM01] = colour_translation_table[byte2 | GTIA_COLPF0];
758 ANTIC_cl[C_PF1 | C_PM01] = colour_translation_table[byte2 | GTIA_COLPF1];
759 }
760 }
761 }
762 }
763 break;
764 case GTIA_OFFSET_COLPM2:
765 GTIA_COLPM2 = byte &= 0xfe;
766 ANTIC_cl[C_PM2] = cword = colour_translation_table[byte];
767 {
768 UBYTE byte2 = byte | GTIA_COLPM3;
769 ANTIC_cl[C_PM23] = cword2 = colour_translation_table[byte2];
770 if (GTIA_PRIOR & 1) {
771 ANTIC_cl[C_PF0 | C_PM2] = ANTIC_cl[C_PF1 | C_PM2] = cword;
772 ANTIC_cl[C_PF0 | C_PM23] = ANTIC_cl[C_PF1 | C_PM23] = cword2;
773 }
774 if ((GTIA_PRIOR & 6) == 0) {
775 if (GTIA_PRIOR & 9) {
776 ANTIC_cl[C_PF2 | C_PM2] = ANTIC_cl[C_PF3 | C_PM2] = cword;
777 ANTIC_cl[C_PF2 | C_PM23] = ANTIC_cl[C_PF3 | C_PM23] = cword2;
778 ANTIC_cl[C_HI2 | C_PM2] = colour_translation_table[(byte & 0xf0) | (GTIA_COLPF1 & 0xf)];
779 ANTIC_cl[C_HI2 | C_PM23] = colour_translation_table[(byte2 & 0xf0) | (GTIA_COLPF1 & 0xf)];
780 }
781 else {
782 ANTIC_cl[C_PF2 | C_PM2] = colour_translation_table[byte | GTIA_COLPF2];
783 ANTIC_cl[C_PF3 | C_PM25] = ANTIC_cl[C_PF2 | C_PM25] = ANTIC_cl[C_PM25] = ANTIC_cl[C_PF3 | C_PM2] = colour_translation_table[byte | GTIA_COLPF3];
784 ANTIC_cl[C_PF2 | C_PM23] = colour_translation_table[byte2 | GTIA_COLPF2];
785 ANTIC_cl[C_PF3 | C_PM235] = ANTIC_cl[C_PF2 | C_PM235] = ANTIC_cl[C_PM235] = ANTIC_cl[C_PF3 | C_PM23] = colour_translation_table[byte2 | GTIA_COLPF3];
786 ANTIC_cl[C_HI2 | C_PM2] = colour_translation_table[((byte | GTIA_COLPF2) & 0xf0) | (GTIA_COLPF1 & 0xf)];
787 ANTIC_cl[C_HI2 | C_PM25] = colour_translation_table[((byte | GTIA_COLPF3) & 0xf0) | (GTIA_COLPF1 & 0xf)];
788 ANTIC_cl[C_HI2 | C_PM23] = colour_translation_table[((byte2 | GTIA_COLPF2) & 0xf0) | (GTIA_COLPF1 & 0xf)];
789 ANTIC_cl[C_HI2 | C_PM235] = colour_translation_table[((byte2 | GTIA_COLPF3) & 0xf0) | (GTIA_COLPF1 & 0xf)];
790 }
791 }
792 }
793 break;
794 case GTIA_OFFSET_COLPM3:
795 GTIA_COLPM3 = byte &= 0xfe;
796 ANTIC_cl[C_PM3] = cword = colour_translation_table[byte];
797 {
798 UBYTE byte2 = byte | GTIA_COLPM2;
799 ANTIC_cl[C_PM23] = cword2 = colour_translation_table[byte2];
800 if (GTIA_PRIOR & 1) {
801 ANTIC_cl[C_PF0 | C_PM3] = ANTIC_cl[C_PF1 | C_PM3] = cword;
802 ANTIC_cl[C_PF0 | C_PM23] = ANTIC_cl[C_PF1 | C_PM23] = cword2;
803 }
804 if ((GTIA_PRIOR & 6) == 0) {
805 if (GTIA_PRIOR & 9) {
806 ANTIC_cl[C_PF2 | C_PM3] = ANTIC_cl[C_PF3 | C_PM3] = cword;
807 ANTIC_cl[C_PF2 | C_PM23] = ANTIC_cl[C_PF3 | C_PM23] = cword2;
808 }
809 else {
810 ANTIC_cl[C_PF2 | C_PM3] = colour_translation_table[byte | GTIA_COLPF2];
811 ANTIC_cl[C_PF3 | C_PM35] = ANTIC_cl[C_PF2 | C_PM35] = ANTIC_cl[C_PM35] = ANTIC_cl[C_PF3 | C_PM3] = colour_translation_table[byte | GTIA_COLPF3];
812 ANTIC_cl[C_PF2 | C_PM23] = colour_translation_table[byte2 | GTIA_COLPF2];
813 ANTIC_cl[C_PF3 | C_PM235] = ANTIC_cl[C_PF2 | C_PM235] = ANTIC_cl[C_PM235] = ANTIC_cl[C_PF3 | C_PM23] = colour_translation_table[byte2 | GTIA_COLPF3];
814 ANTIC_cl[C_HI2 | C_PM3] = colour_translation_table[((byte | GTIA_COLPF2) & 0xf0) | (GTIA_COLPF1 & 0xf)];
815 ANTIC_cl[C_HI2 | C_PM23] = colour_translation_table[((byte2 | GTIA_COLPF2) & 0xf0) | (GTIA_COLPF1 & 0xf)];
816 }
817 }
818 }
819 break;
820 #else /* USE_COLOUR_TRANSLATION_TABLE */
821 case GTIA_OFFSET_COLBK:
822 GTIA_COLBK = byte &= 0xfe;
823 GTIA_COLOUR_TO_WORD(cword,byte);
824 ANTIC_cl[C_BAK] = cword;
825 if (cword != (UWORD) (ANTIC_lookup_gtia9[0]) ) {
826 ANTIC_lookup_gtia9[0] = cword + (cword << 16);
827 if (GTIA_PRIOR & 0x40)
828 setup_gtia9_11();
829 }
830 break;
831 case GTIA_OFFSET_COLPF0:
832 GTIA_COLPF0 = byte &= 0xfe;
833 GTIA_COLOUR_TO_WORD(cword,byte);
834 ANTIC_cl[C_PF0] = cword;
835 if ((GTIA_PRIOR & 1) == 0) {
836 ANTIC_cl[C_PF0 | C_PM23] = ANTIC_cl[C_PF0 | C_PM3] = ANTIC_cl[C_PF0 | C_PM2] = cword;
837 if ((GTIA_PRIOR & 3) == 0) {
838 if (GTIA_PRIOR & 0xf) {
839 ANTIC_cl[C_PF0 | C_PM01] = ANTIC_cl[C_PF0 | C_PM1] = ANTIC_cl[C_PF0 | C_PM0] = cword;
840 if ((GTIA_PRIOR & 0xf) == 0xc)
841 ANTIC_cl[C_PF0 | C_PM0123] = ANTIC_cl[C_PF0 | C_PM123] = ANTIC_cl[C_PF0 | C_PM023] = cword;
842 }
843 else
844 ANTIC_cl[C_PF0 | C_PM01] = (ANTIC_cl[C_PF0 | C_PM0] = cword | ANTIC_cl[C_PM0]) | (ANTIC_cl[C_PF0 | C_PM1] = cword | ANTIC_cl[C_PM1]);
845 }
846 if ((GTIA_PRIOR & 0xf) >= 0xa)
847 ANTIC_cl[C_PF0 | C_PM25] = cword;
848 }
849 break;
850 case GTIA_OFFSET_COLPF1:
851 GTIA_COLPF1 = byte &= 0xfe;
852 GTIA_COLOUR_TO_WORD(cword,byte);
853 ANTIC_cl[C_PF1] = cword;
854 if ((GTIA_PRIOR & 1) == 0) {
855 ANTIC_cl[C_PF1 | C_PM23] = ANTIC_cl[C_PF1 | C_PM3] = ANTIC_cl[C_PF1 | C_PM2] = cword;
856 if ((GTIA_PRIOR & 3) == 0) {
857 if (GTIA_PRIOR & 0xf) {
858 ANTIC_cl[C_PF1 | C_PM01] = ANTIC_cl[C_PF1 | C_PM1] = ANTIC_cl[C_PF1 | C_PM0] = cword;
859 if ((GTIA_PRIOR & 0xf) == 0xc)
860 ANTIC_cl[C_PF1 | C_PM0123] = ANTIC_cl[C_PF1 | C_PM123] = ANTIC_cl[C_PF1 | C_PM023] = cword;
861 }
862 else
863 ANTIC_cl[C_PF1 | C_PM01] = (ANTIC_cl[C_PF1 | C_PM0] = cword | ANTIC_cl[C_PM0]) | (ANTIC_cl[C_PF1 | C_PM1] = cword | ANTIC_cl[C_PM1]);
864 }
865 }
866 ((UBYTE *)ANTIC_hires_lookup_l)[0x80] = ((UBYTE *)ANTIC_hires_lookup_l)[0x41] = (UBYTE)
867 (ANTIC_hires_lookup_l[0x60] = cword & 0xf0f);
868 break;
869 case GTIA_OFFSET_COLPF2:
870 GTIA_COLPF2 = byte &= 0xfe;
871 GTIA_COLOUR_TO_WORD(cword,byte);
872 ANTIC_cl[C_PF2] = cword;
873 if (GTIA_PRIOR & 4)
874 ANTIC_cl[C_PF2 | C_PM01] = ANTIC_cl[C_PF2 | C_PM1] = ANTIC_cl[C_PF2 | C_PM0] = cword;
875 if ((GTIA_PRIOR & 9) == 0) {
876 if (GTIA_PRIOR & 0xf)
877 ANTIC_cl[C_PF2 | C_PM23] = ANTIC_cl[C_PF2 | C_PM3] = ANTIC_cl[C_PF2 | C_PM2] = cword;
878 else
879 ANTIC_cl[C_PF2 | C_PM23] = (ANTIC_cl[C_PF2 | C_PM2] = cword | ANTIC_cl[C_PM2]) | (ANTIC_cl[C_PF2 | C_PM3] = cword | ANTIC_cl[C_PM3]);
880 }
881 break;
882 case GTIA_OFFSET_COLPF3:
883 GTIA_COLPF3 = byte &= 0xfe;
884 GTIA_COLOUR_TO_WORD(cword,byte);
885 ANTIC_cl[C_PF3] = cword;
886 if (GTIA_PRIOR & 4)
887 ANTIC_cl[C_PF3 | C_PM01] = ANTIC_cl[C_PF3 | C_PM1] = ANTIC_cl[C_PF3 | C_PM0] = cword;
888 if ((GTIA_PRIOR & 9) == 0) {
889 if (GTIA_PRIOR & 0xf)
890 ANTIC_cl[C_PF3 | C_PM23] = ANTIC_cl[C_PF3 | C_PM3] = ANTIC_cl[C_PF3 | C_PM2] = cword;
891 else {
892 ANTIC_cl[C_PF3 | C_PM25] = ANTIC_cl[C_PF2 | C_PM25] = ANTIC_cl[C_PM25] = ANTIC_cl[C_PF3 | C_PM2] = cword | ANTIC_cl[C_PM2];
893 ANTIC_cl[C_PF3 | C_PM35] = ANTIC_cl[C_PF2 | C_PM35] = ANTIC_cl[C_PM35] = ANTIC_cl[C_PF3 | C_PM3] = cword | ANTIC_cl[C_PM3];
894 ANTIC_cl[C_PF3 | C_PM235] = ANTIC_cl[C_PF2 | C_PM235] = ANTIC_cl[C_PM235] = ANTIC_cl[C_PF3 | C_PM23] = ANTIC_cl[C_PF3 | C_PM2] | ANTIC_cl[C_PF3 | C_PM3];
895 ANTIC_cl[C_PF0 | C_PM235] = ANTIC_cl[C_PF0 | C_PM35] = ANTIC_cl[C_PF0 | C_PM25] =
896 ANTIC_cl[C_PF1 | C_PM235] = ANTIC_cl[C_PF1 | C_PM35] = ANTIC_cl[C_PF1 | C_PM25] = cword;
897 }
898 }
899 break;
900 case GTIA_OFFSET_COLPM0:
901 GTIA_COLPM0 = byte &= 0xfe;
902 GTIA_COLOUR_TO_WORD(cword,byte);
903 ANTIC_cl[C_PM023] = ANTIC_cl[C_PM0] = cword;
904 ANTIC_cl[C_PM0123] = ANTIC_cl[C_PM01] = cword2 = cword | ANTIC_cl[C_PM1];
905 if ((GTIA_PRIOR & 4) == 0) {
906 ANTIC_cl[C_PF2 | C_PM0] = ANTIC_cl[C_PF3 | C_PM0] = cword;
907 ANTIC_cl[C_PF2 | C_PM01] = ANTIC_cl[C_PF3 | C_PM01] = cword2;
908 if ((GTIA_PRIOR & 0xc) == 0) {
909 if (GTIA_PRIOR & 3) {
910 ANTIC_cl[C_PF0 | C_PM0] = ANTIC_cl[C_PF1 | C_PM0] = cword;
911 ANTIC_cl[C_PF0 | C_PM01] = ANTIC_cl[C_PF1 | C_PM01] = cword2;
912 }
913 else {
914 ANTIC_cl[C_PF0 | C_PM0] = cword | ANTIC_cl[C_PF0];
915 ANTIC_cl[C_PF1 | C_PM0] = cword | ANTIC_cl[C_PF1];
916 ANTIC_cl[C_PF0 | C_PM01] = cword2 | ANTIC_cl[C_PF0];
917 ANTIC_cl[C_PF1 | C_PM01] = cword2 | ANTIC_cl[C_PF1];
918 }
919 }
920 }
921 break;
922 case GTIA_OFFSET_COLPM1:
923 GTIA_COLPM1 = byte &= 0xfe;
924 GTIA_COLOUR_TO_WORD(cword,byte);
925 ANTIC_cl[C_PM123] = ANTIC_cl[C_PM1] = cword;
926 ANTIC_cl[C_PM0123] = ANTIC_cl[C_PM01] = cword2 = cword | ANTIC_cl[C_PM0];
927 if ((GTIA_PRIOR & 4) == 0) {
928 ANTIC_cl[C_PF2 | C_PM1] = ANTIC_cl[C_PF3 | C_PM1] = cword;
929 ANTIC_cl[C_PF2 | C_PM01] = ANTIC_cl[C_PF3 | C_PM01] = cword2;
930 if ((GTIA_PRIOR & 0xc) == 0) {
931 if (GTIA_PRIOR & 3) {
932 ANTIC_cl[C_PF0 | C_PM1] = ANTIC_cl[C_PF1 | C_PM1] = cword;
933 ANTIC_cl[C_PF0 | C_PM01] = ANTIC_cl[C_PF1 | C_PM01] = cword2;
934 }
935 else {
936 ANTIC_cl[C_PF0 | C_PM1] = cword | ANTIC_cl[C_PF0];
937 ANTIC_cl[C_PF1 | C_PM1] = cword | ANTIC_cl[C_PF1];
938 ANTIC_cl[C_PF0 | C_PM01] = cword2 | ANTIC_cl[C_PF0];
939 ANTIC_cl[C_PF1 | C_PM01] = cword2 | ANTIC_cl[C_PF1];
940 }
941 }
942 }
943 break;
944 case GTIA_OFFSET_COLPM2:
945 GTIA_COLPM2 = byte &= 0xfe;
946 GTIA_COLOUR_TO_WORD(cword,byte);
947 ANTIC_cl[C_PM2] = cword;
948 ANTIC_cl[C_PM23] = cword2 = cword | ANTIC_cl[C_PM3];
949 if (GTIA_PRIOR & 1) {
950 ANTIC_cl[C_PF0 | C_PM2] = ANTIC_cl[C_PF1 | C_PM2] = cword;
951 ANTIC_cl[C_PF0 | C_PM23] = ANTIC_cl[C_PF1 | C_PM23] = cword2;
952 }
953 if ((GTIA_PRIOR & 6) == 0) {
954 if (GTIA_PRIOR & 9) {
955 ANTIC_cl[C_PF2 | C_PM2] = ANTIC_cl[C_PF3 | C_PM2] = cword;
956 ANTIC_cl[C_PF2 | C_PM23] = ANTIC_cl[C_PF3 | C_PM23] = cword2;
957 }
958 else {
959 ANTIC_cl[C_PF2 | C_PM2] = cword | ANTIC_cl[C_PF2];
960 ANTIC_cl[C_PF3 | C_PM25] = ANTIC_cl[C_PF2 | C_PM25] = ANTIC_cl[C_PM25] = ANTIC_cl[C_PF3 | C_PM2] = cword | ANTIC_cl[C_PF3];
961 ANTIC_cl[C_PF2 | C_PM23] = cword2 | ANTIC_cl[C_PF2];
962 ANTIC_cl[C_PF3 | C_PM235] = ANTIC_cl[C_PF2 | C_PM235] = ANTIC_cl[C_PM235] = ANTIC_cl[C_PF3 | C_PM23] = cword2 | ANTIC_cl[C_PF3];
963 }
964 }
965 break;
966 case GTIA_OFFSET_COLPM3:
967 GTIA_COLPM3 = byte &= 0xfe;
968 GTIA_COLOUR_TO_WORD(cword,byte);
969 ANTIC_cl[C_PM3] = cword;
970 ANTIC_cl[C_PM23] = cword2 = cword | ANTIC_cl[C_PM2];
971 if (GTIA_PRIOR & 1) {
972 ANTIC_cl[C_PF0 | C_PM3] = ANTIC_cl[C_PF1 | C_PM3] = cword;
973 ANTIC_cl[C_PF0 | C_PM23] = ANTIC_cl[C_PF1 | C_PM23] = cword2;
974 }
975 if ((GTIA_PRIOR & 6) == 0) {
976 if (GTIA_PRIOR & 9) {
977 ANTIC_cl[C_PF2 | C_PM3] = ANTIC_cl[C_PF3 | C_PM3] = cword;
978 ANTIC_cl[C_PF2 | C_PM23] = ANTIC_cl[C_PF3 | C_PM23] = cword2;
979 }
980 else {
981 ANTIC_cl[C_PF2 | C_PM3] = cword | ANTIC_cl[C_PF2];
982 ANTIC_cl[C_PF3 | C_PM35] = ANTIC_cl[C_PF2 | C_PM35] = ANTIC_cl[C_PM35] = ANTIC_cl[C_PF3 | C_PM3] = cword | ANTIC_cl[C_PF3];
983 ANTIC_cl[C_PF2 | C_PM23] = cword2 | ANTIC_cl[C_PF2];
984 ANTIC_cl[C_PF3 | C_PM235] = ANTIC_cl[C_PF2 | C_PM235] = ANTIC_cl[C_PM235] = ANTIC_cl[C_PF3 | C_PM23] = cword2 | ANTIC_cl[C_PF3];
985 }
986 }
987 break;
988 #endif /* USE_COLOUR_TRANSLATION_TABLE */
989 case GTIA_OFFSET_GRAFM:
990 GTIA_GRAFM = byte;
991 UPDATE_PM_CYCLE_EXACT
992 break;
993
994 #ifdef NEW_CYCLE_EXACT
995 #define CYCLE_EXACT_GRAFP(n) x = ANTIC_XPOS * 2 - 3;\
996 if (GTIA_HPOSP##n >= x) {\
997 /* hpos right of x */\
998 /* redraw */ \
999 UPDATE_PM_CYCLE_EXACT\
1000 }
1001 #else
1002 #define CYCLE_EXACT_GRAFP(n)
1003 #endif /* NEW_CYCLE_EXACT */
1004
1005 #define DO_GRAFP(n) case GTIA_OFFSET_GRAFP##n:\
1006 GTIA_GRAFP##n = byte;\
1007 CYCLE_EXACT_GRAFP(n);\
1008 break;
1009
1010 DO_GRAFP(0)
1011 DO_GRAFP(1)
1012 DO_GRAFP(2)
1013 DO_GRAFP(3)
1014
1015 case GTIA_OFFSET_HITCLR:
1016 GTIA_M0PL = GTIA_M1PL = GTIA_M2PL = GTIA_M3PL = 0;
1017 GTIA_P0PL = GTIA_P1PL = GTIA_P2PL = GTIA_P3PL = 0;
1018 PF0PM = PF1PM = PF2PM = PF3PM = 0;
1019 #ifdef NEW_CYCLE_EXACT
1020 hitclr_pos = ANTIC_XPOS * 2 - 37;
1021 collision_curpos = hitclr_pos;
1022 #endif
1023 break;
1024 /* TODO: cycle-exact missile HPOS, GRAF, SIZE */
1025 /* this is only an approximation */
1026 case GTIA_OFFSET_HPOSM0:
1027 GTIA_HPOSM0 = byte;
1028 hposm_ptr[0] = GTIA_pm_scanline + byte - 0x20;
1029 UPDATE_PM_CYCLE_EXACT
1030 break;
1031 case GTIA_OFFSET_HPOSM1:
1032 GTIA_HPOSM1 = byte;
1033 hposm_ptr[1] = GTIA_pm_scanline + byte - 0x20;
1034 UPDATE_PM_CYCLE_EXACT
1035 break;
1036 case GTIA_OFFSET_HPOSM2:
1037 GTIA_HPOSM2 = byte;
1038 hposm_ptr[2] = GTIA_pm_scanline + byte - 0x20;
1039 UPDATE_PM_CYCLE_EXACT
1040 break;
1041 case GTIA_OFFSET_HPOSM3:
1042 GTIA_HPOSM3 = byte;
1043 hposm_ptr[3] = GTIA_pm_scanline + byte - 0x20;
1044 UPDATE_PM_CYCLE_EXACT
1045 break;
1046
1047 #ifdef NEW_CYCLE_EXACT
1048 #define CYCLE_EXACT_HPOSP(n) x = ANTIC_XPOS * 2 - 1;\
1049 if (GTIA_HPOSP##n < x && byte < x) {\
1050 /* case 1: both left of x */\
1051 /* do nothing */\
1052 }\
1053 else if (GTIA_HPOSP##n >= x && byte >= x ) {\
1054 /* case 2: both right of x */\
1055 /* redraw, clearing first */\
1056 UPDATE_PM_CYCLE_EXACT\
1057 }\
1058 else if (GTIA_HPOSP##n <x && byte >= x) {\
1059 /* case 3: new value is right, old value is left */\
1060 /* redraw without clearing first */\
1061 /* note: a hack, we can get away with it unless another change occurs */\
1062 /* before the original copy that wasn't erased due to changing */\
1063 /* GTIA_pm_dirty is drawn */\
1064 GTIA_pm_dirty = FALSE;\
1065 UPDATE_PM_CYCLE_EXACT\
1066 GTIA_pm_dirty = TRUE; /* can't trust that it was reset correctly */\
1067 }\
1068 else {\
1069 /* case 4: new value is left, old value is right */\
1070 /* remove old player and don't draw the new one */\
1071 UBYTE save_graf = GTIA_GRAFP##n;\
1072 GTIA_GRAFP##n = 0;\
1073 UPDATE_PM_CYCLE_EXACT\
1074 GTIA_GRAFP##n = save_graf;\
1075 }
1076 #else
1077 #define CYCLE_EXACT_HPOSP(n)
1078 #endif /* NEW_CYCLE_EXACT */
1079 #define DO_HPOSP(n) case GTIA_OFFSET_HPOSP##n: \
1080 hposp_ptr[n] = GTIA_pm_scanline + byte - 0x20; \
1081 if (byte >= 0x22) { \
1082 if (byte > 0xbe) { \
1083 if (byte >= 0xde) \
1084 hposp_mask[n] = 0; \
1085 else \
1086 hposp_mask[n] = 0xffffffff >> (byte - 0xbe); \
1087 } \
1088 else \
1089 hposp_mask[n] = 0xffffffff; \
1090 } \
1091 else if (byte > 2) \
1092 hposp_mask[n] = 0xffffffff << (0x22 - byte); \
1093 else \
1094 hposp_mask[n] = 0; \
1095 CYCLE_EXACT_HPOSP(n)\
1096 GTIA_HPOSP##n = byte; \
1097 break;
1098
1099 DO_HPOSP(0)
1100 DO_HPOSP(1)
1101 DO_HPOSP(2)
1102 DO_HPOSP(3)
1103
1104 /* TODO: cycle-exact size changes */
1105 /* this is only an approximation */
1106 case GTIA_OFFSET_SIZEM:
1107 GTIA_SIZEM = byte;
1108 global_sizem[0] = PM_Width[byte & 0x03];
1109 global_sizem[1] = PM_Width[(byte & 0x0c) >> 2];
1110 global_sizem[2] = PM_Width[(byte & 0x30) >> 4];
1111 global_sizem[3] = PM_Width[(byte & 0xc0) >> 6];
1112 UPDATE_PM_CYCLE_EXACT
1113 break;
1114 case GTIA_OFFSET_SIZEP0:
1115 GTIA_SIZEP0 = byte;
1116 grafp_ptr[0] = grafp_lookup[byte & 3];
1117 UPDATE_PM_CYCLE_EXACT
1118 break;
1119 case GTIA_OFFSET_SIZEP1:
1120 GTIA_SIZEP1 = byte;
1121 grafp_ptr[1] = grafp_lookup[byte & 3];
1122 UPDATE_PM_CYCLE_EXACT
1123 break;
1124 case GTIA_OFFSET_SIZEP2:
1125 GTIA_SIZEP2 = byte;
1126 grafp_ptr[2] = grafp_lookup[byte & 3];
1127 UPDATE_PM_CYCLE_EXACT
1128 break;
1129 case GTIA_OFFSET_SIZEP3:
1130 GTIA_SIZEP3 = byte;
1131 grafp_ptr[3] = grafp_lookup[byte & 3];
1132 UPDATE_PM_CYCLE_EXACT
1133 break;
1134 case GTIA_OFFSET_PRIOR:
1135 ANTIC_SetPrior(byte);
1136 GTIA_PRIOR = byte;
1137 if (byte & 0x40)
1138 setup_gtia9_11();
1139 break;
1140 case GTIA_OFFSET_VDELAY:
1141 GTIA_VDELAY = byte;
1142 break;
1143 case GTIA_OFFSET_GRACTL:
1144 GTIA_GRACTL = byte;
1145 ANTIC_missile_gra_enabled = (byte & 0x01);
1146 ANTIC_player_gra_enabled = (byte & 0x02);
1147 ANTIC_player_flickering = ((ANTIC_player_dma_enabled | ANTIC_player_gra_enabled) == 0x02);
1148 ANTIC_missile_flickering = ((ANTIC_missile_dma_enabled | ANTIC_missile_gra_enabled) == 0x01);
1149 if ((byte & 4) == 0)
1150 GTIA_TRIG_latch[0] = GTIA_TRIG_latch[1] = GTIA_TRIG_latch[2] = GTIA_TRIG_latch[3] = 1;
1151 break;
1152
1153 #endif /* defined(BASIC) || defined(CURSES_BASIC) */
1154 }
1155 }
1156
1157 /* State ------------------------------------------------------------------- */
1158
1159 #ifndef BASIC
1160
GTIA_StateSave(void)1161 void GTIA_StateSave(void)
1162 {
1163 int next_console_value = 7;
1164
1165 StateSav_SaveUBYTE(>IA_HPOSP0, 1);
1166 StateSav_SaveUBYTE(>IA_HPOSP1, 1);
1167 StateSav_SaveUBYTE(>IA_HPOSP2, 1);
1168 StateSav_SaveUBYTE(>IA_HPOSP3, 1);
1169 StateSav_SaveUBYTE(>IA_HPOSM0, 1);
1170 StateSav_SaveUBYTE(>IA_HPOSM1, 1);
1171 StateSav_SaveUBYTE(>IA_HPOSM2, 1);
1172 StateSav_SaveUBYTE(>IA_HPOSM3, 1);
1173 StateSav_SaveUBYTE(&PF0PM, 1);
1174 StateSav_SaveUBYTE(&PF1PM, 1);
1175 StateSav_SaveUBYTE(&PF2PM, 1);
1176 StateSav_SaveUBYTE(&PF3PM, 1);
1177 StateSav_SaveUBYTE(>IA_M0PL, 1);
1178 StateSav_SaveUBYTE(>IA_M1PL, 1);
1179 StateSav_SaveUBYTE(>IA_M2PL, 1);
1180 StateSav_SaveUBYTE(>IA_M3PL, 1);
1181 StateSav_SaveUBYTE(>IA_P0PL, 1);
1182 StateSav_SaveUBYTE(>IA_P1PL, 1);
1183 StateSav_SaveUBYTE(>IA_P2PL, 1);
1184 StateSav_SaveUBYTE(>IA_P3PL, 1);
1185 StateSav_SaveUBYTE(>IA_SIZEP0, 1);
1186 StateSav_SaveUBYTE(>IA_SIZEP1, 1);
1187 StateSav_SaveUBYTE(>IA_SIZEP2, 1);
1188 StateSav_SaveUBYTE(>IA_SIZEP3, 1);
1189 StateSav_SaveUBYTE(>IA_SIZEM, 1);
1190 StateSav_SaveUBYTE(>IA_GRAFP0, 1);
1191 StateSav_SaveUBYTE(>IA_GRAFP1, 1);
1192 StateSav_SaveUBYTE(>IA_GRAFP2, 1);
1193 StateSav_SaveUBYTE(>IA_GRAFP3, 1);
1194 StateSav_SaveUBYTE(>IA_GRAFM, 1);
1195 StateSav_SaveUBYTE(>IA_COLPM0, 1);
1196 StateSav_SaveUBYTE(>IA_COLPM1, 1);
1197 StateSav_SaveUBYTE(>IA_COLPM2, 1);
1198 StateSav_SaveUBYTE(>IA_COLPM3, 1);
1199 StateSav_SaveUBYTE(>IA_COLPF0, 1);
1200 StateSav_SaveUBYTE(>IA_COLPF1, 1);
1201 StateSav_SaveUBYTE(>IA_COLPF2, 1);
1202 StateSav_SaveUBYTE(>IA_COLPF3, 1);
1203 StateSav_SaveUBYTE(>IA_COLBK, 1);
1204 StateSav_SaveUBYTE(>IA_PRIOR, 1);
1205 StateSav_SaveUBYTE(>IA_VDELAY, 1);
1206 StateSav_SaveUBYTE(>IA_GRACTL, 1);
1207
1208 StateSav_SaveUBYTE(&consol_mask, 1);
1209 StateSav_SaveINT(>IA_speaker, 1);
1210 StateSav_SaveINT(&next_console_value, 1);
1211 StateSav_SaveUBYTE(GTIA_TRIG_latch, 4);
1212 }
1213
GTIA_StateRead(UBYTE version)1214 void GTIA_StateRead(UBYTE version)
1215 {
1216 int next_console_value; /* ignored */
1217
1218 StateSav_ReadUBYTE(>IA_HPOSP0, 1);
1219 StateSav_ReadUBYTE(>IA_HPOSP1, 1);
1220 StateSav_ReadUBYTE(>IA_HPOSP2, 1);
1221 StateSav_ReadUBYTE(>IA_HPOSP3, 1);
1222 StateSav_ReadUBYTE(>IA_HPOSM0, 1);
1223 StateSav_ReadUBYTE(>IA_HPOSM1, 1);
1224 StateSav_ReadUBYTE(>IA_HPOSM2, 1);
1225 StateSav_ReadUBYTE(>IA_HPOSM3, 1);
1226 StateSav_ReadUBYTE(&PF0PM, 1);
1227 StateSav_ReadUBYTE(&PF1PM, 1);
1228 StateSav_ReadUBYTE(&PF2PM, 1);
1229 StateSav_ReadUBYTE(&PF3PM, 1);
1230 StateSav_ReadUBYTE(>IA_M0PL, 1);
1231 StateSav_ReadUBYTE(>IA_M1PL, 1);
1232 StateSav_ReadUBYTE(>IA_M2PL, 1);
1233 StateSav_ReadUBYTE(>IA_M3PL, 1);
1234 StateSav_ReadUBYTE(>IA_P0PL, 1);
1235 StateSav_ReadUBYTE(>IA_P1PL, 1);
1236 StateSav_ReadUBYTE(>IA_P2PL, 1);
1237 StateSav_ReadUBYTE(>IA_P3PL, 1);
1238 StateSav_ReadUBYTE(>IA_SIZEP0, 1);
1239 StateSav_ReadUBYTE(>IA_SIZEP1, 1);
1240 StateSav_ReadUBYTE(>IA_SIZEP2, 1);
1241 StateSav_ReadUBYTE(>IA_SIZEP3, 1);
1242 StateSav_ReadUBYTE(>IA_SIZEM, 1);
1243 StateSav_ReadUBYTE(>IA_GRAFP0, 1);
1244 StateSav_ReadUBYTE(>IA_GRAFP1, 1);
1245 StateSav_ReadUBYTE(>IA_GRAFP2, 1);
1246 StateSav_ReadUBYTE(>IA_GRAFP3, 1);
1247 StateSav_ReadUBYTE(>IA_GRAFM, 1);
1248 StateSav_ReadUBYTE(>IA_COLPM0, 1);
1249 StateSav_ReadUBYTE(>IA_COLPM1, 1);
1250 StateSav_ReadUBYTE(>IA_COLPM2, 1);
1251 StateSav_ReadUBYTE(>IA_COLPM3, 1);
1252 StateSav_ReadUBYTE(>IA_COLPF0, 1);
1253 StateSav_ReadUBYTE(>IA_COLPF1, 1);
1254 StateSav_ReadUBYTE(>IA_COLPF2, 1);
1255 StateSav_ReadUBYTE(>IA_COLPF3, 1);
1256 StateSav_ReadUBYTE(>IA_COLBK, 1);
1257 StateSav_ReadUBYTE(>IA_PRIOR, 1);
1258 StateSav_ReadUBYTE(>IA_VDELAY, 1);
1259 StateSav_ReadUBYTE(>IA_GRACTL, 1);
1260
1261 StateSav_ReadUBYTE(&consol_mask, 1);
1262 StateSav_ReadINT(>IA_speaker, 1);
1263 StateSav_ReadINT(&next_console_value, 1);
1264 if (version >= 7)
1265 StateSav_ReadUBYTE(GTIA_TRIG_latch, 4);
1266
1267 GTIA_PutByte(GTIA_OFFSET_HPOSP0, GTIA_HPOSP0);
1268 GTIA_PutByte(GTIA_OFFSET_HPOSP1, GTIA_HPOSP1);
1269 GTIA_PutByte(GTIA_OFFSET_HPOSP2, GTIA_HPOSP2);
1270 GTIA_PutByte(GTIA_OFFSET_HPOSP3, GTIA_HPOSP3);
1271 GTIA_PutByte(GTIA_OFFSET_HPOSM0, GTIA_HPOSM0);
1272 GTIA_PutByte(GTIA_OFFSET_HPOSM1, GTIA_HPOSM1);
1273 GTIA_PutByte(GTIA_OFFSET_HPOSM2, GTIA_HPOSM2);
1274 GTIA_PutByte(GTIA_OFFSET_HPOSM3, GTIA_HPOSM3);
1275 GTIA_PutByte(GTIA_OFFSET_SIZEP0, GTIA_SIZEP0);
1276 GTIA_PutByte(GTIA_OFFSET_SIZEP1, GTIA_SIZEP1);
1277 GTIA_PutByte(GTIA_OFFSET_SIZEP2, GTIA_SIZEP2);
1278 GTIA_PutByte(GTIA_OFFSET_SIZEP3, GTIA_SIZEP3);
1279 GTIA_PutByte(GTIA_OFFSET_SIZEM, GTIA_SIZEM);
1280 GTIA_PutByte(GTIA_OFFSET_GRAFP0, GTIA_GRAFP0);
1281 GTIA_PutByte(GTIA_OFFSET_GRAFP1, GTIA_GRAFP1);
1282 GTIA_PutByte(GTIA_OFFSET_GRAFP2, GTIA_GRAFP2);
1283 GTIA_PutByte(GTIA_OFFSET_GRAFP3, GTIA_GRAFP3);
1284 GTIA_PutByte(GTIA_OFFSET_GRAFM, GTIA_GRAFM);
1285 GTIA_PutByte(GTIA_OFFSET_COLPM0, GTIA_COLPM0);
1286 GTIA_PutByte(GTIA_OFFSET_COLPM1, GTIA_COLPM1);
1287 GTIA_PutByte(GTIA_OFFSET_COLPM2, GTIA_COLPM2);
1288 GTIA_PutByte(GTIA_OFFSET_COLPM3, GTIA_COLPM3);
1289 GTIA_PutByte(GTIA_OFFSET_COLPF0, GTIA_COLPF0);
1290 GTIA_PutByte(GTIA_OFFSET_COLPF1, GTIA_COLPF1);
1291 GTIA_PutByte(GTIA_OFFSET_COLPF2, GTIA_COLPF2);
1292 GTIA_PutByte(GTIA_OFFSET_COLPF3, GTIA_COLPF3);
1293 GTIA_PutByte(GTIA_OFFSET_COLBK, GTIA_COLBK);
1294 GTIA_PutByte(GTIA_OFFSET_PRIOR, GTIA_PRIOR);
1295 GTIA_PutByte(GTIA_OFFSET_GRACTL, GTIA_GRACTL);
1296 }
1297
1298 #endif /* BASIC */
1299