6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2025-04-03 08:30:49 +00:00
Code Issues Projects Releases Wiki Activity

Updated to C types.

Browse Source
This commit is contained in:
jespergravgaard 2020-02-01 10:38:53 +01:00
parent 46096f63cd
commit bb3be5655c
3 changed files with 43 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/test/kc/multiplexer-irq/multiplexer-irq.kc
View File

@ -15,42 +15,42 @@
import "c64"
// The number of sprites in the multiplexer
const byte PLEX_COUNT = 32;
const char PLEX_COUNT = 32;
// The x-positions of the multiplexer sprites ($000-$1ff)
word[PLEX_COUNT] PLEX_XPOS;
unsigned int[PLEX_COUNT] PLEX_XPOS;
// The y-positions of the multiplexer sprites.
byte[PLEX_COUNT] PLEX_YPOS;
char[PLEX_COUNT] PLEX_YPOS;
// The sprite pointers for the multiplexed sprites
byte[PLEX_COUNT] PLEX_PTR;
char[PLEX_COUNT] PLEX_PTR;
// The address of the sprite pointers on the current screen (screen+$3f8).
byte* PLEX_SCREEN_PTR = $400+$3f8;
char* PLEX_SCREEN_PTR = $400+$3f8;
// Indexes of the plex-sprites sorted by sprite y-position. Each call to plexSort() will fix the sorting if changes to the Y-positions have ruined it.
byte[PLEX_COUNT] PLEX_SORTED_IDX;
char[PLEX_COUNT] PLEX_SORTED_IDX;
// Variables controlling the showing of sprites
// The index in the PLEX tables of the next sprite to show
volatile byte plex_show_idx=0;
volatile char plex_show_idx=0;
// The index the next sprite to use for showing (sprites are used round-robin)
volatile byte plex_sprite_idx=0;
volatile char plex_sprite_idx=0;
// The MSB bit of the next sprite to use for showing
volatile byte plex_sprite_msb=1;
volatile char plex_sprite_msb=1;
// Initialize the multiplexer data structures
void plexInit(byte* screen) {
void plexInit(char* screen) {
plexSetScreen(screen);
for(byte i: 0..PLEX_COUNT-1) {
for(char i: 0..PLEX_COUNT-1) {
PLEX_SORTED_IDX[i] = i;
}
}
// Set the address of the current screen used for setting sprite pointers (at screen+$3f8)
inline void plexSetScreen(byte* screen) {
inline void plexSetScreen(char* screen) {
PLEX_SCREEN_PTR = screen+$3f8;
}
@ -64,12 +64,12 @@ inline void plexSetScreen(byte* screen) {
// elements before the marker are shifted right one at a time until encountering one smaller than the current one.
// It is then inserted at the spot. Now the marker can move forward.
void plexSort() {
for(byte m: 0..PLEX_COUNT-2) {
byte nxt_idx = PLEX_SORTED_IDX[m+1];
byte nxt_y = PLEX_YPOS[nxt_idx];
for(char m: 0..PLEX_COUNT-2) {
char nxt_idx = PLEX_SORTED_IDX[m+1];
char nxt_y = PLEX_YPOS[nxt_idx];
if(nxt_y<PLEX_YPOS[PLEX_SORTED_IDX[m]]) {
// Shift values until we encounter a value smaller than nxt_y
byte s = m;
char s = m;
do {
PLEX_SORTED_IDX[s+1] = PLEX_SORTED_IDX[s];
s--;
@ -89,12 +89,12 @@ void plexSort() {
// Show the next sprite.
// plexSort() prepares showing the sprites
void plexShowSprite() {
byte plex_sprite_idx2 = plex_sprite_idx*2;
byte ypos = PLEX_YPOS[PLEX_SORTED_IDX[plex_show_idx]];
char plex_sprite_idx2 = plex_sprite_idx*2;
char ypos = PLEX_YPOS[PLEX_SORTED_IDX[plex_show_idx]];
SPRITES_YPOS[plex_sprite_idx2] = ypos;
plexFreeAdd(ypos);
PLEX_SCREEN_PTR[plex_sprite_idx] = PLEX_PTR[PLEX_SORTED_IDX[plex_show_idx]];
byte xpos_idx = PLEX_SORTED_IDX[plex_show_idx];
char xpos_idx = PLEX_SORTED_IDX[plex_show_idx];
SPRITES_XPOS[plex_sprite_idx2] = <PLEX_XPOS[xpos_idx];
if(>PLEX_XPOS[xpos_idx]!=0) {
*SPRITES_XMSB |= plex_sprite_msb;
@ -110,31 +110,31 @@ void plexShowSprite() {
}
// Get the y-position of the next sprite to show
inline byte plexShowNextYpos() {
inline char plexShowNextYpos() {
return PLEX_YPOS[PLEX_SORTED_IDX[plex_show_idx]];
}
// Contains the Y-position where each sprite is free again. PLEX_FREE_YPOS[s] holds the Y-position where sprite s is free to use again.
byte[8] PLEX_FREE_YPOS;
char[8] PLEX_FREE_YPOS;
// The index of the sprite that is free next. Since sprites are used round-robin this moves forward each time a sprite is shown.
volatile byte plex_free_next = 0;
volatile char plex_free_next = 0;
// Prepare for a new frame. Initialize free to zero for all sprites.
inline void plexFreePrepare() {
for( byte s: 0..7) {
for( char s: 0..7) {
PLEX_FREE_YPOS[s] = 0;
}
plex_free_next = 0;
}
// Get the Y-position where the next sprite to be shown is free to use.
inline byte plexFreeNextYpos() {
inline char plexFreeNextYpos() {
return PLEX_FREE_YPOS[plex_free_next];
}
// Update the data structure to reflect that a sprite has been shown. This sprite will be free again after 21 lines.
inline void plexFreeAdd(byte ypos) {
inline void plexFreeAdd(char ypos) {
PLEX_FREE_YPOS[plex_free_next] = ypos+21;
plex_free_next = (plex_free_next+1)&7;
}

22
src/test/kc/multiplexer-irq/simple-multiplexer-irq.kc
View File

@ -2,9 +2,9 @@
import "c64"
import "multiplexer-irq"
// Location of screen & sprites
byte* SCREEN = $400;
char* SCREEN = $400;
byte* SPRITE = $2000;
char* SPRITE = $2000;
kickasm(pc SPRITE, resource "balloon.png") {{
.var pic = LoadPicture("balloon.png", List().add($000000, $ffffff))
.for (var y=0; y<21; y++)
@ -12,7 +12,7 @@ kickasm(pc SPRITE, resource "balloon.png") {{
.byte pic.getSinglecolorByte(x,y)
}}
byte[0x100] align(0x100) YSIN = kickasm {{
char[0x100] align(0x100) YSIN = kickasm {{
.var min = 50
.var max = 250-21
.var ampl = max-min;
@ -32,15 +32,15 @@ void init() {
// Initialize the multiplexer
plexInit(SCREEN);
// Set the x-positions & pointers
word xp = 32;
for(byte sx: 0..PLEX_COUNT-1) {
PLEX_PTR[sx] = (byte)(SPRITE/$40);
unsigned int xp = 32;
for(char sx: 0..PLEX_COUNT-1) {
PLEX_PTR[sx] = (char)(SPRITE/$40);
PLEX_XPOS[sx] = xp;
xp += 9;
}
// Enable & initialize sprites
*SPRITES_ENABLE = $ff;
for(byte ss: 0..7) {
for(char ss: 0..7) {
SPRITES_COLS[ss] = GREEN;
}
// enable the interrupt
@ -55,7 +55,7 @@ void init() {
volatile bool framedone = true;
interrupt(kernel_min) void plex_irq() {
byte rasterY;
char rasterY;
*BORDERCOL = WHITE;
do {
plexShowSprite();
@ -73,13 +73,13 @@ interrupt(kernel_min) void plex_irq() {
// The raster loop
void loop() {
// The current index into the y-sinus
byte sin_idx = 0;
char sin_idx = 0;
while(true) {
while(!framedone) { }
*BORDERCOL = RED;
// Assign sinus positions
byte y_idx = sin_idx;
for(byte sy: 0..PLEX_COUNT-1) {
char y_idx = sin_idx;
for(char sy: 0..PLEX_COUNT-1) {
PLEX_YPOS[sy] = YSIN[y_idx];
y_idx += 8;
}

14
src/test/ref/multiplexer-irq/simple-multiplexer-irq.log
View File

@ -4606,7 +4606,7 @@ loop: {
// [22] (byte) loop::y_idx#1 ← (byte) loop::y_idx#2 + (byte) 8 -- vbuxx=vbuxx_plus_vbuc1
txa
axs #-[8]
// for(byte sy: 0..PLEX_COUNT-1)
// for(char sy: 0..PLEX_COUNT-1)
// [23] (byte) loop::sy#1 ← ++ (byte) loop::sy#2 -- vbuyy=_inc_vbuyy
iny
// [24] if((byte) loop::sy#1!=(const byte) PLEX_COUNT-(byte) 1+(byte) 1) goto loop::@4 -- vbuyy_neq_vbuc1_then_la1
@ -4722,7 +4722,7 @@ plexSort: {
sta PLEX_SORTED_IDX,x
// plexSort::@2
__b2:
// for(byte m: 0..PLEX_COUNT-2)
// for(char m: 0..PLEX_COUNT-2)
// [45] (byte) plexSort::m#1 ← ++ (byte) plexSort::m#2 -- vbuz1=_inc_vbuz1
inc.z m
// [46] if((byte) plexSort::m#1!=(const byte) PLEX_COUNT-(byte) 2+(byte) 1) goto plexSort::@1 -- vbuz1_neq_vbuc1_then_la1
@ -4755,7 +4755,7 @@ plexSort: {
// [52] *((const byte[8]) PLEX_FREE_YPOS + (byte) plexSort::plexFreePrepare1_s#2) ← (byte) 0 -- pbuc1_derefidx_vbuxx=vbuc2
lda #0
sta PLEX_FREE_YPOS,x
// for( byte s: 0..7)
// for( char s: 0..7)
// [53] (byte) plexSort::plexFreePrepare1_s#1 ← ++ (byte) plexSort::plexFreePrepare1_s#2 -- vbuxx=_inc_vbuxx
inx
// [54] if((byte) plexSort::plexFreePrepare1_s#1!=(byte) 8) goto plexSort::plexFreePrepare1_@1 -- vbuxx_neq_vbuc1_then_la1
@ -4795,7 +4795,7 @@ init: {
// [59] phi (byte) init::sx#2 = (byte) init::sx#1 [phi:init::@1->init::@1#1] -- register_copy
// init::@1
__b1:
// PLEX_PTR[sx] = (byte)(SPRITE/$40)
// PLEX_PTR[sx] = (char)(SPRITE/$40)
// [60] *((const byte[PLEX_COUNT]) PLEX_PTR + (byte) init::sx#2) ← (byte)(const byte*) SPRITE/(byte) $40 -- pbuc1_derefidx_vbuxx=vbuc2
lda #SPRITE/$40
sta PLEX_PTR,x
@ -4818,7 +4818,7 @@ init: {
bcc !+
inc.z xp+1
!:
// for(byte sx: 0..PLEX_COUNT-1)
// for(char sx: 0..PLEX_COUNT-1)
// [64] (byte) init::sx#1 ← ++ (byte) init::sx#2 -- vbuxx=_inc_vbuxx
inx
// [65] if((byte) init::sx#1!=(const byte) PLEX_COUNT-(byte) 1+(byte) 1) goto init::@1 -- vbuxx_neq_vbuc1_then_la1
@ -4841,7 +4841,7 @@ init: {
// [68] *((const byte*) SPRITES_COLS + (byte) init::ss#2) ← (const byte) GREEN -- pbuc1_derefidx_vbuxx=vbuc2
lda #GREEN
sta SPRITES_COLS,x
// for(byte ss: 0..7)
// for(char ss: 0..7)
// [69] (byte) init::ss#1 ← ++ (byte) init::ss#2 -- vbuxx=_inc_vbuxx
inx
// [70] if((byte) init::ss#1!=(byte) 8) goto init::@3 -- vbuxx_neq_vbuc1_then_la1
@ -4893,7 +4893,7 @@ plexInit: {
// [81] *((const byte[PLEX_COUNT]) PLEX_SORTED_IDX + (byte) plexInit::i#2) ← (byte) plexInit::i#2 -- pbuc1_derefidx_vbuxx=vbuxx
txa
sta PLEX_SORTED_IDX,x
// for(byte i: 0..PLEX_COUNT-1)
// for(char i: 0..PLEX_COUNT-1)
// [82] (byte) plexInit::i#1 ← ++ (byte) plexInit::i#2 -- vbuxx=_inc_vbuxx
inx
// [83] if((byte) plexInit::i#1!=(const byte) PLEX_COUNT-(byte) 1+(byte) 1) goto plexInit::@1 -- vbuxx_neq_vbuc1_then_la1