cool-bun-demo/main.c

#include <stdio.h>

#include <clib/exec_protos.h>
#include <clib/graphics_protos.h>
#include <exec/exec.h>

#include <hardware/custom.h>
#include <hardware/dmabits.h>

#include <graphics/gfx.h>

#include "system/blitter.h"
#include "system/copper.h"
#include "system/system.h"

#include "screen.h"
#include "types.h"
#include "bun.h"

extern struct Custom far custom;

// this should be large enough to hold one bitplane of the largest object
// you are blitting, plus one additional word on each side
#define SCRATCH_AREA_WIDTH_BYTES (8)
#define SCRATCH_AREA_HEIGHT_ROWS (34)
#define SCRATCH_AREA_MEMORY_SIZE (SCRATCH_AREA_WIDTH_BYTES * SCRATCH_AREA_HEIGHT_ROWS)

volatile short *dbg = (volatile short *)0x100;

unsigned char *scratchArea;
struct ScreenSetup screenSetup;
struct CurrentScreen currentScreen;
void *copperlistBitplanePointers[8][2];
void *copperlistSpritePointers[8];

#define offsetof(s, m) &((struct s *)0)->m
uint16_t custom_color = (uint16_t)offsetof(Custom, color);
uint16_t custom_sprite = (uint16_t)offsetof(Custom, sprpt);

#define BUN_COUNT (12)
#define BUN_SPEED (2)

short int bunPositions[BUN_COUNT][2];

#define BUN_MAX_RANGE (31 + 320 - 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 (10)
#define BUN_VERT_DISTANCE_BETWEEN_BUNS (20)
#define BUN_TOTAL_VERT_DISTANCE (COOL_BUN_HEIGHT + BUN_VERT_DISTANCE_BETWEEN_BUNS)
#define FRAME_MAX (BUN_TOTAL_HORIZ_DISTANCE / BUN_SPEED)

void calculateBunPositions(
  uint16_t frame,
  short int bunPositions[BUN_COUNT][2],
  struct ScreenSetup *screenSetup
) {
  int x, y, row, column, current;

  frame %= FRAME_MAX;

  for (current = 0; current < BUN_COUNT; ++current) {
    row = current / 4;
    column = current % 4;

    x = column * BUN_TOTAL_HORIZ_DISTANCE + frame * BUN_SPEED;
    if (row == 1) {
      //x += BUN_TOTAL_HORIZ_DISTANCE / 2;
    }
    x %= BUN_MAX_RANGE;
    x -= 31;
    y = BUN_ROW_START + row * BUN_TOTAL_VERT_DISTANCE;

    bunPositions[current][0] = x;
    bunPositions[current][1] = y;
  }
}

int main(void) {
  uint16_t *copperlist, *currentCopperlist, result;
  int i, j, x, y, plane;
  int blitShiftRight, memoryXOffset, blitWidth;
  uint32_t wow, wow2;

  color_t colors[8];

  colors[0] = 0x09b8;
  colors[1] = 0x0000;
  colors[2] = 0x0fff;
  colors[3] = 0x000f;

  setupBun();
  setupScreen(&screenSetup, SCREEN_WIDTH, SCREEN_HEIGHT, 3);
  setupInitialCurrentScreen(&screenSetup, &currentScreen);

  // blitter copy the first bitplane row down to the second

  copperlist = prepareNewCopperlist();

  takeOverSystem();

  setCopperlist(copperlist);
  setUpDisplay((uint32_t)screenSetup.bitplanes);

  currentCopperlist = addDisplayToCopperlist(
    copperlist,
    &screenSetup,
    &currentScreen,
    &copperlistBitplanePointers
  );

  currentCopperlist = setUpEmptySpritesInCopperlist(currentCopperlist);

  *(currentCopperlist++) = custom_color;
  *(currentCopperlist++) = 0x000;

  *(currentCopperlist++) = custom_color + 2;
  *(currentCopperlist++) = 0x000;

  *(currentCopperlist++) = custom_color + 4;
  *(currentCopperlist++) = 0xfff;

  *(currentCopperlist++) = custom_color + 6;
  *(currentCopperlist++) = 0x00F;

  for (y = 0; y < 256; ++y) {
    *(currentCopperlist++) = 1 + (31 << 1) + ((44 + y) << 8);
    *(currentCopperlist++) = 0xFFFE;
    *(currentCopperlist++) = custom_color;
    *(currentCopperlist++) = 0x9b8;

    *(currentCopperlist++) = 1 + ((31 + (320 / 4)) << 1) + ((44 + y) << 8);
    *(currentCopperlist++) = 0xFFFE;
    *(currentCopperlist++) = custom_color;
    *(currentCopperlist++) = 0x000;
  }

  endCopperlist(currentCopperlist);

  for (i = 0; i < FRAME_MAX * 6; ++i) {
    calculateBunPositions(i, bunPositions, &screenSetup);

    swapCurrentScreenBuffer(&screenSetup, &currentScreen);

    for (plane = 0; plane < 2; ++plane) {
      custom.bltcon0 = 0xc0 + (1 << 8);
      custom.bltcon1 = 0;
      custom.bltadat = 0x0000;
      custom.bltafwm = 0xffff;
      custom.bltalwm = 0xffff;
      custom.bltdpt = currentScreen.planes[plane];
      custom.bltdmod = 0;
      custom.bltsize = screenSetup.byteWidth / 2 + (screenSetup.height << 6);
      WaitBlit();
    }

    for (j = 0; j < BUN_COUNT; ++j) {
      renderBun(
        bunPositions[j][0],
        bunPositions[j][1],
        &screenSetup,
        &currentScreen
      );
    }

    updateDisplayInCopperList(
      &screenSetup,
      &currentScreen,
      copperlistBitplanePointers
    );

    WaitTOF();
  }

  /*
  for (i = 0; i < 200; ++i) {
    WaitTOF();
  }
  */

  giveBackSystem();

  teardownScreen(&screenSetup);

  freeCopperlist(copperlist);

  teardownBun();

  for (i = 0; i < BUN_COUNT; ++i) {
    printf("%d %d\n", bunPositions[i][0], bunPositions[i][1]);
  }

  return 0;
}