429 lines
11 KiB
C
429 lines
11 KiB
C
#include <math.h>
|
|
|
|
// Custom
|
|
#include <hardware/custom.h>
|
|
|
|
// WaitBlit()
|
|
#include <clib/graphics_protos.h>
|
|
|
|
// AllocMem(), FreeMem()
|
|
#include <clib/exec_protos.h>
|
|
#include <exec/memory.h>
|
|
|
|
#include "screen.h"
|
|
#include "bun.h"
|
|
#include "system/system.h"
|
|
|
|
#define COOL_BUN_WIDTH (32)
|
|
#define COOL_BUN_WIDTH_BYTES (COOL_BUN_WIDTH / 8)
|
|
#define COOL_BUN_HEIGHT (32)
|
|
#define COOL_BUN_PLANES (2)
|
|
#define COOL_BUN_LAST_ROW (COOL_BUN_HEIGHT - 1)
|
|
#define COOL_BUN_LAST_ROW_BYTES (COOL_BUN_LAST_ROW * COOL_BUN_WIDTH_BYTES)
|
|
|
|
#define COOL_BUN_PLANE_SIZE (COOL_BUN_WIDTH_BYTES * COOL_BUN_HEIGHT)
|
|
#define COOL_BUN_MEMORY_SIZE (COOL_BUN_PLANE_SIZE * COOL_BUN_PLANES)
|
|
|
|
#define BUN_MAX_RANGE (31 + 320)
|
|
|
|
#define BUN_COUNT (12)
|
|
#define BUN_SPEED (1)
|
|
|
|
#define BUN_HORIZ_DISTANCE_BETWEEN_BUNS ((BUN_MAX_RANGE / 4) - COOL_BUN_WIDTH)
|
|
#define BUN_TOTAL_HORIZ_DISTANCE (BUN_HORIZ_DISTANCE_BETWEEN_BUNS + COOL_BUN_WIDTH)
|
|
#define BUN_ROW_START (50)
|
|
#define BUN_VERT_DISTANCE_BETWEEN_BUNS (30)
|
|
#define BUN_TOTAL_VERT_DISTANCE (COOL_BUN_HEIGHT + BUN_VERT_DISTANCE_BETWEEN_BUNS)
|
|
#define FRAME_MAX (BUN_TOTAL_HORIZ_DISTANCE / BUN_SPEED)
|
|
|
|
#define BUN_WAVE_LENGTH (FRAMES_FOR_SCREEN / 2)
|
|
|
|
// linked as raw bytes in assembler
|
|
extern unsigned char chip coolbun[];
|
|
|
|
#define BLTCON0( \
|
|
minterm, aChan, bChan, cChan, dChan, shift \
|
|
) (minterm + (aChan << 11) + (bChan << 10) + (cChan << 9) + (dChan << 8) + (shift << 12))
|
|
#define BLTCON1(descending, shift) ((descending << 1) + (shift << 12))
|
|
|
|
extern struct Custom far custom;
|
|
|
|
void setupBun(void) {
|
|
}
|
|
|
|
void teardownBun(void) {
|
|
}
|
|
|
|
#define BLITTER_ASCENDING (0)
|
|
#define BLITTER_DESCENDING (1)
|
|
|
|
struct BunClear {
|
|
uint16_t memoryStartOffsetBytes;
|
|
uint16_t widthWords;
|
|
uint16_t heightRows;
|
|
uint8_t direction;
|
|
};
|
|
|
|
#define BUN_OFF_RIGHT_SIDE (0)
|
|
#define BUN_OFF_LEFT_SIDE (1)
|
|
#define BUN_ANYWHERE (2)
|
|
|
|
uint8_t *coolbunPlaneStarts[3][2];
|
|
|
|
void bun_offRightSide(
|
|
int plusXValue,
|
|
int y,
|
|
struct ScreenSetup *screenSetup,
|
|
struct CurrentScreen *currentScreen,
|
|
struct BunClear *bunClear
|
|
) {
|
|
uint8_t i, plane = 0;
|
|
uint8_t shift = plusXValue & 15;
|
|
uint8_t wordShift = (plusXValue >> 4);
|
|
uint16_t bltalwm, bltcon0, bltcon1, bltdmod, bltsize;
|
|
|
|
bunClear->memoryStartOffsetBytes = (y * screenSetup->byteWidth) +
|
|
screenSetup->byteWidth - COOL_BUN_WIDTH_BYTES +
|
|
wordShift * 2;
|
|
bunClear->heightRows = COOL_BUN_HEIGHT;
|
|
bunClear->widthWords = 2 - wordShift;
|
|
bunClear->direction = BLITTER_ASCENDING;
|
|
|
|
bltalwm = 0x0000;
|
|
for (i = 0; i <= 15 - shift; ++i) {
|
|
bltalwm += (1 << (15 - i));
|
|
}
|
|
|
|
bltcon0 = BLTCON0(0xf0, 1, 0, 0, 1, shift);
|
|
bltcon1 = BLTCON1(bunClear->direction, shift);
|
|
|
|
bltdmod = screenSetup->byteWidth - COOL_BUN_WIDTH_BYTES +
|
|
wordShift * 2;
|
|
|
|
bltsize = bunClear->widthWords + (bunClear->heightRows << 6);
|
|
|
|
for (plane = 0; plane < 2; ++plane) {
|
|
custom.bltcon0 = bltcon0;
|
|
custom.bltcon1 = bltcon1;
|
|
|
|
custom.bltapt = coolbunPlaneStarts[BUN_OFF_LEFT_SIDE][plane];
|
|
custom.bltdpt = currentScreen->planes[plane] +
|
|
bunClear->memoryStartOffsetBytes;
|
|
|
|
custom.bltafwm = 0xffff;
|
|
custom.bltalwm = bltalwm;
|
|
|
|
custom.bltamod = wordShift * 2;
|
|
custom.bltdmod = bltdmod;
|
|
|
|
custom.bltsize = bltsize;
|
|
|
|
WaitBlit();
|
|
}
|
|
}
|
|
|
|
void bun_offLeftSide(
|
|
int minusXValue,
|
|
int y,
|
|
struct ScreenSetup *screenSetup,
|
|
struct CurrentScreen *currentScreen,
|
|
struct BunClear *bunClear
|
|
) {
|
|
unsigned char plane;
|
|
uint8_t shift = minusXValue & 15;
|
|
uint8_t wordShift = (minusXValue >> 4);
|
|
uint8_t i;
|
|
uint16_t bltalwm, bltcon0, bltcon1, bltdmod, bltsize;
|
|
|
|
// y can't be 0 otherwise we will corrupt memory for now
|
|
if (y == 0) return;
|
|
|
|
bunClear->memoryStartOffsetBytes = (screenSetup->byteWidth * (y + COOL_BUN_LAST_ROW)) +
|
|
2 - wordShift * 2;
|
|
bunClear->heightRows = COOL_BUN_HEIGHT;
|
|
bunClear->widthWords = 2 - wordShift;
|
|
bunClear->direction = BLITTER_DESCENDING;
|
|
|
|
bltalwm = 0x0000;
|
|
for (i = 0; i <= 15 - shift; ++i) {
|
|
bltalwm += (1 << i);
|
|
}
|
|
|
|
bltcon0 = BLTCON0(0xf0, 1, 0, 0, 1, shift);
|
|
bltcon1 = BLTCON1(bunClear->direction, shift);
|
|
bltdmod = screenSetup->byteWidth - 4 + wordShift * 2;
|
|
|
|
bltsize = bunClear->widthWords + (bunClear->heightRows << 6);
|
|
|
|
for (plane = 0; plane < 2; ++plane) {
|
|
// shift left, so descending
|
|
custom.bltcon0 = bltcon0;
|
|
custom.bltcon1 = bltcon1;
|
|
|
|
// a has bun data
|
|
custom.bltapt = coolbunPlaneStarts[BUN_OFF_RIGHT_SIDE][plane];
|
|
|
|
// d is the part on screen
|
|
custom.bltdpt = currentScreen->planes[plane] + bunClear->memoryStartOffsetBytes;
|
|
|
|
custom.bltafwm = 0xffff;
|
|
custom.bltalwm = bltalwm;
|
|
|
|
custom.bltamod = wordShift * 2;
|
|
custom.bltdmod = bltdmod;
|
|
|
|
custom.bltsize = bltsize;
|
|
|
|
WaitBlit();
|
|
}
|
|
}
|
|
|
|
void bun_anywhere(
|
|
int x,
|
|
int y,
|
|
struct ScreenSetup *screenSetup,
|
|
struct CurrentScreen *currentScreen,
|
|
struct BunClear *bunClear
|
|
) {
|
|
uint8_t plane;
|
|
uint8_t shift = x & 15;
|
|
uint8_t needsExtraWord = shift != 0;
|
|
uint16_t bltcon0, bltcon1, bltalwm, bltamod, bltdmod, bltsize;
|
|
|
|
bunClear->memoryStartOffsetBytes = WORD_ALIGNED_BYTE_POSITION(screenSetup->width, x, y);
|
|
|
|
bunClear->heightRows = COOL_BUN_HEIGHT;
|
|
bunClear->widthWords = 2 + needsExtraWord;
|
|
bunClear->direction = BLITTER_ASCENDING;
|
|
|
|
// buns will never interfere with a background so they don't need a mask
|
|
bltcon0 = BLTCON0(0xf0, 1, 0, 0, 1, shift);
|
|
bltcon1 = BLTCON1(bunClear->direction, shift);
|
|
|
|
if (needsExtraWord) {
|
|
bltalwm = 0x0000;
|
|
} else {
|
|
bltalwm = 0xffff;
|
|
}
|
|
|
|
bltamod = -(needsExtraWord * 2);
|
|
bltdmod = screenSetup->byteWidth - COOL_BUN_WIDTH_BYTES - (needsExtraWord * 2);
|
|
bltsize = bunClear->widthWords + (bunClear->heightRows << 6);
|
|
|
|
for (plane = 0; plane < 2; ++plane) {
|
|
custom.bltcon0 = bltcon0;
|
|
custom.bltcon1 = bltcon1;
|
|
|
|
custom.bltapt = coolbunPlaneStarts[BUN_ANYWHERE][plane];
|
|
custom.bltdpt = currentScreen->planes[plane] +
|
|
bunClear->memoryStartOffsetBytes;
|
|
|
|
custom.bltafwm = 0xffff;
|
|
custom.bltalwm = bltalwm;
|
|
|
|
custom.bltamod = bltamod;
|
|
custom.bltdmod = bltdmod;
|
|
custom.bltsize = bltsize;
|
|
|
|
WaitBlit();
|
|
}
|
|
}
|
|
|
|
void renderBun(
|
|
int x,
|
|
int y,
|
|
struct ScreenSetup *screenSetup,
|
|
struct CurrentScreen *currentScreen,
|
|
struct BunClear *bunClear
|
|
) {
|
|
/**
|
|
* Conditions that will cause the program to crash if met. If your bun
|
|
* isn't rendering, it's due to here.
|
|
*
|
|
* TODO: Handle top/bottom off-screen as well.
|
|
*/
|
|
if (x < -31) return;
|
|
if (x > screenSetup->width + 31) return;
|
|
if (y < 1) return;
|
|
if (y > screenSetup->height - COOL_BUN_HEIGHT - 1) return;
|
|
|
|
if (x < 0) {
|
|
bun_offLeftSide(
|
|
-x,
|
|
y,
|
|
screenSetup,
|
|
currentScreen,
|
|
bunClear
|
|
);
|
|
} else if (x > screenSetup->width - COOL_BUN_WIDTH) {
|
|
bun_offRightSide(
|
|
x - (screenSetup->width - COOL_BUN_WIDTH),
|
|
y,
|
|
screenSetup,
|
|
currentScreen,
|
|
bunClear
|
|
);
|
|
} else {
|
|
bun_anywhere(
|
|
x,
|
|
y,
|
|
screenSetup,
|
|
currentScreen,
|
|
bunClear
|
|
);
|
|
}
|
|
}
|
|
|
|
#define MAX_SINE_WAVE_CHANGE (20)
|
|
|
|
int bunAngleAdjustments[BUN_COUNT];
|
|
|
|
void calculateBunPositions(
|
|
uint16_t frame,
|
|
short int bunPositions[BUN_COUNT][2],
|
|
struct ScreenSetup *screenSetup
|
|
) {
|
|
int x, y, row, column, current;
|
|
float angle, startAngle;
|
|
|
|
frame %= FRAMES_FOR_SCREEN;
|
|
|
|
startAngle = (float)(frame % BUN_WAVE_LENGTH) * 360 / BUN_WAVE_LENGTH;
|
|
|
|
for (current = 0; current < BUN_COUNT; ++current) {
|
|
row = current / 4;
|
|
column = current % 4;
|
|
angle = startAngle + bunAngleAdjustments[current];
|
|
|
|
x = column * BUN_TOTAL_HORIZ_DISTANCE + ((float)frame * BUN_MAX_RANGE / FRAMES_FOR_SCREEN);
|
|
if (row == 1) {
|
|
x += BUN_TOTAL_HORIZ_DISTANCE / 2;
|
|
}
|
|
x %= BUN_MAX_RANGE;
|
|
x -= 31;
|
|
|
|
angle = angle * PI / 180;
|
|
|
|
y = BUN_ROW_START +
|
|
row * BUN_TOTAL_VERT_DISTANCE +
|
|
sin(angle) * MAX_SINE_WAVE_CHANGE;
|
|
|
|
bunPositions[current][0] = x;
|
|
bunPositions[current][1] = y;
|
|
}
|
|
}
|
|
|
|
short int allBunPositionsByFrame[FRAMES_FOR_SCREEN][BUN_COUNT][2];
|
|
|
|
void calculateAllBunPositions(
|
|
struct ScreenSetup *screenSetup
|
|
) {
|
|
int frame;
|
|
|
|
for (frame = 0; frame < FRAMES_FOR_SCREEN; ++frame) {
|
|
calculateBunPositions(
|
|
frame,
|
|
allBunPositionsByFrame[frame],
|
|
screenSetup
|
|
);
|
|
}
|
|
}
|
|
|
|
void buildBunAngleAdjustments() {
|
|
int current, angleAdjustment;
|
|
for (current = 0; current < BUN_COUNT; ++current) {
|
|
angleAdjustment = 0;
|
|
if (current % 2 == 1) angleAdjustment += 180;
|
|
if (current / 4 == 1) angleAdjustment += 90;
|
|
|
|
bunAngleAdjustments[current] = angleAdjustment;
|
|
}
|
|
}
|
|
|
|
void precalculeBunRenderInfo(void) {
|
|
int plane;
|
|
|
|
for (plane = 0; plane < 2; ++plane) {
|
|
coolbunPlaneStarts[BUN_OFF_LEFT_SIDE][plane] = coolbun + plane * COOL_BUN_PLANE_SIZE;
|
|
coolbunPlaneStarts[BUN_ANYWHERE][plane] = coolbun + plane * COOL_BUN_PLANE_SIZE;
|
|
coolbunPlaneStarts[BUN_OFF_RIGHT_SIDE][plane] = coolbun + 2 +
|
|
COOL_BUN_LAST_ROW_BYTES +
|
|
plane * COOL_BUN_PLANE_SIZE;
|
|
}
|
|
}
|
|
|
|
void setupBunRenderer(
|
|
struct BunRenderer *bunRenderer,
|
|
struct ScreenSetup *screenSetup,
|
|
struct CurrentScreen *currentScreen) {
|
|
bunRenderer->screenSetup = screenSetup;
|
|
bunRenderer->currentScreen = currentScreen;
|
|
|
|
setupBun();
|
|
buildBunAngleAdjustments();
|
|
calculateAllBunPositions(screenSetup);
|
|
precalculeBunRenderInfo();
|
|
}
|
|
|
|
int hasBunClear[2] = {0,0};
|
|
struct BunClear bunClearForScreen[2][BUN_COUNT];
|
|
|
|
void clearCurrentBuns(
|
|
struct BunRenderer *bunRenderer
|
|
) {
|
|
int bun, plane;
|
|
struct BunClear *currentBunClear;
|
|
uint16_t bltcon0, bltcon1, bltdmod, bltsize;
|
|
|
|
if (!hasBunClear[bunRenderer->currentScreen->currentBuffer]) return;
|
|
|
|
bltcon0 = 0xc0 + (1 << 8);
|
|
|
|
for (bun = 0; bun < BUN_COUNT; ++bun) {
|
|
currentBunClear = &bunClearForScreen[bunRenderer->currentScreen->currentBuffer][bun];
|
|
|
|
bltcon1 = BLTCON1(currentBunClear->direction, 0);
|
|
bltdmod = bunRenderer->screenSetup->byteWidth - (currentBunClear->widthWords * 2);
|
|
bltsize = currentBunClear->widthWords + (currentBunClear->heightRows << 6);
|
|
|
|
for (plane = 0; plane < 2; ++plane) {
|
|
custom.bltcon0 = bltcon0;
|
|
custom.bltcon1 = bltcon1;
|
|
custom.bltadat = 0x0000;
|
|
custom.bltafwm = 0xffff;
|
|
custom.bltalwm = 0xffff;
|
|
custom.bltdpt = bunRenderer->currentScreen->planes[plane] +
|
|
currentBunClear->memoryStartOffsetBytes;
|
|
custom.bltdmod = bltdmod;
|
|
custom.bltsize = bltsize;
|
|
|
|
WaitBlit();
|
|
}
|
|
}
|
|
}
|
|
|
|
void renderBunFrame(
|
|
int frame,
|
|
struct BunRenderer *bunRenderer
|
|
) {
|
|
int bun;
|
|
|
|
frame %= FRAMES_FOR_SCREEN;
|
|
|
|
for (bun = 0; bun < BUN_COUNT; ++bun) {
|
|
renderBun(
|
|
allBunPositionsByFrame[frame][bun][0],
|
|
allBunPositionsByFrame[frame][bun][1],
|
|
bunRenderer->screenSetup,
|
|
bunRenderer->currentScreen,
|
|
&bunClearForScreen[bunRenderer->currentScreen->currentBuffer][bun]
|
|
);
|
|
}
|
|
|
|
hasBunClear[bunRenderer->currentScreen->currentBuffer] = 1;
|
|
}
|
|
|
|
void teardownBunRenderer() {
|
|
teardownBun();
|
|
}
|