3119 lines
92 KiB
C
3119 lines
92 KiB
C
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <sys/time.h>
|
||
#include "cube.h"
|
||
|
||
#define AXIS_X 1
|
||
#define AXIS_Y 2
|
||
#define AXIS_Z 3
|
||
|
||
unsigned char cube[8][8];
|
||
|
||
// Delay loop.
|
||
// This is not calibrated to milliseconds,
|
||
// but we had allready made to many effects using this
|
||
// calibration when we figured it might be a good idea
|
||
// to calibrate it.
|
||
void delay_ms(unsigned duration)
|
||
{
|
||
struct timeval t0, now;
|
||
int z, msec;
|
||
|
||
gettimeofday(&t0, 0);
|
||
z = 0;
|
||
for (;;) {
|
||
/* Send layer data. Latch is active,
|
||
* so previous layer is still displayed. */
|
||
gpio_plane(cube[z]);
|
||
|
||
/* Disable output, activate latch,
|
||
* switch to next layer. */
|
||
gpio_oe(0);
|
||
gpio_le(0);
|
||
gpio_le(1);
|
||
gpio_layer(z);
|
||
gpio_oe(1);
|
||
|
||
/* Next layer. */
|
||
z++;
|
||
if (z >= CUBE_SIZE) {
|
||
z = 0;
|
||
|
||
/* Check time. */
|
||
gettimeofday(&now, 0);
|
||
msec = (now.tv_sec - t0.tv_sec) * 1000;
|
||
msec += (now.tv_usec - t0.tv_usec) / 1000;
|
||
if (msec >= duration)
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// ==========================================================================================
|
||
// Draw functions
|
||
// ==========================================================================================
|
||
|
||
// Set a single voxel to ON
|
||
void setvoxel(int x, int y, int z)
|
||
{
|
||
if (inrange(x, y, z))
|
||
cube[z][y] |= (1 << x);
|
||
}
|
||
|
||
// Set a single voxel to ON
|
||
void clrvoxel(int x, int y, int z)
|
||
{
|
||
if (inrange(x, y, z))
|
||
cube[z][y] &= ~(1 << x);
|
||
}
|
||
|
||
// This function validates that we are drawing inside the cube.
|
||
int inrange(int x, int y, int z)
|
||
{
|
||
return x >= 0 && x < 8 && y >= 0 && y < 8 && z >= 0 && z < 8;
|
||
}
|
||
|
||
// Get the current status of a voxel
|
||
int getvoxel(int x, int y, int z)
|
||
{
|
||
if (! inrange(x, y, z))
|
||
return 0;
|
||
|
||
return (cube[z][y] >> x) & 1;
|
||
}
|
||
|
||
// In some effect we want to just take bool and write it to a voxel
|
||
// this function calls the apropriate voxel manipulation function.
|
||
void altervoxel(int x, int y, int z, int state)
|
||
{
|
||
if (state == 1) {
|
||
setvoxel(x, y, z);
|
||
} else {
|
||
clrvoxel(x, y, z);
|
||
}
|
||
}
|
||
|
||
// Flip the state of a voxel.
|
||
// If the voxel is 1, its turned into a 0, and vice versa.
|
||
void flpvoxel(int x, int y, int z)
|
||
{
|
||
if (inrange(x, y, z))
|
||
cube[z][y] ^= (1 << x);
|
||
}
|
||
|
||
// Makes sure x1 is alwas smaller than x2
|
||
// This is usefull for functions that uses for loops,
|
||
// to avoid infinite loops
|
||
void argorder(int ix1, int ix2, int *ox1, int *ox2)
|
||
{
|
||
if (ix1>ix2)
|
||
{
|
||
int tmp;
|
||
tmp = ix1;
|
||
ix1= ix2;
|
||
ix2 = tmp;
|
||
}
|
||
*ox1 = ix1;
|
||
*ox2 = ix2;
|
||
}
|
||
|
||
// Sets all voxels along a X/Y plane at a given point
|
||
// on axis Z
|
||
void setplane_z(int z)
|
||
{
|
||
int i;
|
||
|
||
if (z>=0 && z<8)
|
||
{
|
||
for (i=0;i<8;i++)
|
||
cube[z][i] = 0xff;
|
||
}
|
||
}
|
||
|
||
// Clears voxels in the same manner as above
|
||
void clrplane_z (int z)
|
||
{
|
||
int i;
|
||
|
||
if (z>=0 && z<8)
|
||
{
|
||
for (i=0;i<8;i++)
|
||
cube[z][i] = 0x00;
|
||
}
|
||
}
|
||
|
||
void setplane_x(int x)
|
||
{
|
||
int z, y;
|
||
|
||
if (x>=0 && x<8)
|
||
{
|
||
for (z=0;z<8;z++)
|
||
{
|
||
for (y=0;y<8;y++)
|
||
{
|
||
cube[z][y] |= (1 << x);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void clrplane_x(int x)
|
||
{
|
||
int z;
|
||
int y;
|
||
if (x>=0 && x<8)
|
||
{
|
||
for (z=0;z<8;z++)
|
||
{
|
||
for (y=0;y<8;y++)
|
||
{
|
||
cube[z][y] &= ~(1 << x);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void setplane_y(int y)
|
||
{
|
||
int z;
|
||
if (y>=0 && y<8)
|
||
{
|
||
for (z=0;z<8;z++)
|
||
cube[z][y] = 0xff;
|
||
}
|
||
}
|
||
|
||
void clrplane_y(int y)
|
||
{
|
||
int z;
|
||
if (y>=0 && y<8)
|
||
{
|
||
for (z=0;z<8;z++)
|
||
cube[z][y] = 0x00;
|
||
}
|
||
}
|
||
|
||
void setplane(char axis, unsigned char i)
|
||
{
|
||
switch (axis)
|
||
{
|
||
case AXIS_X:
|
||
setplane_x(i);
|
||
break;
|
||
|
||
case AXIS_Y:
|
||
setplane_y(i);
|
||
break;
|
||
|
||
case AXIS_Z:
|
||
setplane_z(i);
|
||
break;
|
||
}
|
||
}
|
||
|
||
void clrplane(char axis, unsigned char i)
|
||
{
|
||
switch (axis)
|
||
{
|
||
case AXIS_X:
|
||
clrplane_x(i);
|
||
break;
|
||
|
||
case AXIS_Y:
|
||
clrplane_y(i);
|
||
break;
|
||
|
||
case AXIS_Z:
|
||
clrplane_z(i);
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Fill a value into all 64 byts of the cube buffer
|
||
// Mostly used for clearing. fill(0x00)
|
||
// or setting all on. fill(0xff)
|
||
void fill(unsigned char pattern)
|
||
{
|
||
int z;
|
||
int y;
|
||
for (z=0;z<8;z++)
|
||
{
|
||
for (y=0;y<8;y++)
|
||
{
|
||
cube[z][y] = pattern;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Returns a byte with a row of 1's drawn in it.
|
||
// byteline(2,5) gives 0b00111100
|
||
char byteline(int start, int end)
|
||
{
|
||
return (0xff << start) & ~(0xff << (end+1));
|
||
}
|
||
|
||
// Draw a box with all walls drawn and all voxels inside set
|
||
void box_filled(int x1, int y1, int z1, int x2, int y2, int z2)
|
||
{
|
||
int iy;
|
||
int iz;
|
||
|
||
argorder(x1, x2, &x1, &x2);
|
||
argorder(y1, y2, &y1, &y2);
|
||
argorder(z1, z2, &z1, &z2);
|
||
|
||
for (iz=z1;iz<=z2;iz++)
|
||
{
|
||
for (iy=y1;iy<=y2;iy++)
|
||
{
|
||
cube[iz][iy] |= byteline(x1, x2);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
// Darw a hollow box with side walls.
|
||
void box_walls(int x1, int y1, int z1, int x2, int y2, int z2)
|
||
{
|
||
int iy;
|
||
int iz;
|
||
|
||
argorder(x1, x2, &x1, &x2);
|
||
argorder(y1, y2, &y1, &y2);
|
||
argorder(z1, z2, &z1, &z2);
|
||
|
||
for (iz=z1;iz<=z2;iz++)
|
||
{
|
||
for (iy=y1;iy<=y2;iy++)
|
||
{
|
||
if (iy == y1 || iy == y2 || iz == z1 || iz == z2)
|
||
{
|
||
cube[iz][iy] = byteline(x1, x2);
|
||
} else
|
||
{
|
||
cube[iz][iy] |= ((0x01 << x1) | (0x01 << x2));
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
// Draw a wireframe box. This only draws the corners and edges,
|
||
// no walls.
|
||
void box_wireframe(int x1, int y1, int z1, int x2, int y2, int z2)
|
||
{
|
||
int iy;
|
||
int iz;
|
||
|
||
argorder(x1, x2, &x1, &x2);
|
||
argorder(y1, y2, &y1, &y2);
|
||
argorder(z1, z2, &z1, &z2);
|
||
|
||
// Lines along X axis
|
||
cube[z1][y1] = byteline(x1, x2);
|
||
cube[z1][y2] = byteline(x1, x2);
|
||
cube[z2][y1] = byteline(x1, x2);
|
||
cube[z2][y2] = byteline(x1, x2);
|
||
|
||
// Lines along Y axis
|
||
for (iy=y1;iy<=y2;iy++)
|
||
{
|
||
setvoxel(x1, iy, z1);
|
||
setvoxel(x1, iy, z2);
|
||
setvoxel(x2, iy, z1);
|
||
setvoxel(x2, iy, z2);
|
||
}
|
||
|
||
// Lines along Z axis
|
||
for (iz=z1;iz<=z2;iz++)
|
||
{
|
||
setvoxel(x1, y1, iz);
|
||
setvoxel(x1, y2, iz);
|
||
setvoxel(x2, y1, iz);
|
||
setvoxel(x2, y2, iz);
|
||
}
|
||
|
||
}
|
||
|
||
// Draw a line between any coordinates in 3d space.
|
||
// Uses integer values for input, so dont expect smooth animations.
|
||
void line(int x1, int y1, int z1, int x2, int y2, int z2)
|
||
{
|
||
int x, y, z, dx, dy, dz;
|
||
int lasty, lastz;
|
||
|
||
// We always want to draw the line from x=0 to x=7.
|
||
// If x1 is bigget than x2, we need to flip all the values.
|
||
if (x1 > x2) {
|
||
int tmp;
|
||
tmp = x2; x2 = x1; x1 = tmp;
|
||
tmp = y2; y2 = y1; y1 = tmp;
|
||
tmp = z2; z2 = z1; z1 = tmp;
|
||
}
|
||
dx = x2 - x1;
|
||
|
||
if (y1 > y2) {
|
||
dy = y1 - y2;
|
||
lasty = y2;
|
||
} else {
|
||
dy = y2 - y1;
|
||
lasty = y1;
|
||
}
|
||
|
||
if (z1 > z2) {
|
||
dz = z1 - z2;
|
||
lastz = z2;
|
||
} else {
|
||
dz = z2 - z1;
|
||
lastz = z1;
|
||
}
|
||
|
||
// For each step of x, y increments by:
|
||
for (x = x1; x <= x2; x++) {
|
||
y = (dy * (x-x1) / dx) + y1;
|
||
z = (dz * (x-x1) / dx) + z1;
|
||
setvoxel(x, y, z);
|
||
}
|
||
}
|
||
|
||
// Shift the entire contents of the cube along an axis
|
||
// This is great for effects where you want to draw something
|
||
// on one side of the cube and have it flow towards the other
|
||
// side. Like rain flowing down the Z axiz.
|
||
void shift(char axis, int direction)
|
||
{
|
||
int i, x, y;
|
||
int ii, iii;
|
||
int state;
|
||
|
||
for (i = 0; i < 8; i++)
|
||
{
|
||
if (direction == -1)
|
||
{
|
||
ii = i;
|
||
} else
|
||
{
|
||
ii = (7-i);
|
||
}
|
||
|
||
|
||
for (x = 0; x < 8; x++)
|
||
{
|
||
for (y = 0; y < 8; y++)
|
||
{
|
||
if (direction == -1)
|
||
{
|
||
iii = ii+1;
|
||
} else
|
||
{
|
||
iii = ii-1;
|
||
}
|
||
|
||
if (axis == AXIS_Z)
|
||
{
|
||
state = getvoxel(x, y, iii);
|
||
altervoxel(x, y, ii, state);
|
||
}
|
||
|
||
if (axis == AXIS_Y)
|
||
{
|
||
state = getvoxel(x, iii, y);
|
||
altervoxel(x, ii, y, state);
|
||
}
|
||
|
||
if (axis == AXIS_X)
|
||
{
|
||
state = getvoxel(iii, y, x);
|
||
altervoxel(ii, y, x, state);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (direction == -1)
|
||
{
|
||
i = 7;
|
||
} else
|
||
{
|
||
i = 0;
|
||
}
|
||
|
||
for (x = 0; x < 8; x++)
|
||
{
|
||
for (y = 0; y < 8; y++)
|
||
{
|
||
if (axis == AXIS_Z)
|
||
clrvoxel(x, y, i);
|
||
|
||
if (axis == AXIS_Y)
|
||
clrvoxel(x, i, y);
|
||
|
||
if (axis == AXIS_X)
|
||
clrvoxel(i, y, x);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ==========================================================================================
|
||
// Effect functions
|
||
// ==========================================================================================
|
||
|
||
void fireworks(int iterations, int delay)
|
||
{
|
||
#define NFIREWORKS 30
|
||
int i, f, e;
|
||
int origin_x = 3;
|
||
int origin_y = 3;
|
||
int origin_z = 3;
|
||
int rand_y, rand_x, rand_z;
|
||
int slowrate, gravity;
|
||
|
||
// Particles and their position, x,y,z and their movement, dx,dy,dz.
|
||
// Scaled by 100 for integer arith.
|
||
int particles[NFIREWORKS][6];
|
||
|
||
fill(0x00);
|
||
for (i=0; i<iterations; i++) {
|
||
|
||
origin_x = rand() % 4;
|
||
origin_y = rand() % 4;
|
||
origin_z = rand() % 2;
|
||
origin_z += 5;
|
||
origin_x += 2;
|
||
origin_y += 2;
|
||
|
||
// shoot a particle up in the air
|
||
for (e=0; e<origin_z; e++) {
|
||
setvoxel(origin_x, origin_y, e);
|
||
delay_ms(300+250*e);
|
||
fill(0x00);
|
||
}
|
||
|
||
// Fill particle array
|
||
for (f=0; f<NFIREWORKS; f++) {
|
||
// Position
|
||
particles[f][0] = origin_x * 100;
|
||
particles[f][1] = origin_y * 100;
|
||
particles[f][2] = origin_z * 100;
|
||
|
||
rand_x = rand() % 200;
|
||
rand_y = rand() % 200;
|
||
rand_z = rand() % 200;
|
||
|
||
// Movement
|
||
particles[f][3] = 100 - rand_x; // dx
|
||
particles[f][4] = 100 - rand_y; // dy
|
||
particles[f][5] = 100 - rand_z; // dz
|
||
}
|
||
|
||
// explode
|
||
for (e=0; e<25; e++) {
|
||
// Coefficient = tan((e+0.1)/20) * 1000.
|
||
static const int coeff[25] = {
|
||
5, 55, 105, 156, 207, 260, 314, 370, 428, 489,
|
||
552, 620, 691, 768, 850, 940, 1039, 1149, 1273, 1413,
|
||
1574, 1763, 1989, 2264, 2610,
|
||
};
|
||
|
||
slowrate = 100 + coeff[e];
|
||
gravity = coeff[e] / 20;
|
||
|
||
for (f=0; f<NFIREWORKS; f++) {
|
||
particles[f][0] += particles[f][3] * 100 / slowrate;
|
||
particles[f][1] += particles[f][4] * 100 / slowrate;
|
||
particles[f][2] += particles[f][5] * 100 / slowrate;
|
||
particles[f][2] -= gravity;
|
||
|
||
setvoxel(particles[f][0] / 100,
|
||
particles[f][1] / 100,
|
||
particles[f][2] / 100);
|
||
}
|
||
delay_ms(delay);
|
||
fill(0x00);
|
||
}
|
||
}
|
||
}
|
||
|
||
const unsigned char LUT[65] = {
|
||
0, 8, 17, 26, 35, 43, 52, 60, 69, 77,
|
||
85, 93, 100, 107, 114, 121, 127, 134, 139, 145,
|
||
150, 155, 159, 163, 167, 170, 173, 175, 177, 179,
|
||
180, 180, 181, 180, 180, 179, 177, 175, 173, 170,
|
||
167, 163, 159, 155, 150, 145, 139, 134, 127, 121,
|
||
114, 107, 100, 93, 85, 77, 69, 60, 52, 43,
|
||
35, 26, 17, 8, 0,
|
||
};
|
||
|
||
int totty_sin(int sin_of)
|
||
{
|
||
unsigned char inv = 0;
|
||
if (sin_of < 0) {
|
||
sin_of = -sin_of;
|
||
inv = 1;
|
||
}
|
||
sin_of &= 0x7f; //127
|
||
if (sin_of > 64) {
|
||
sin_of -= 64;
|
||
inv = 1-inv;
|
||
}
|
||
if (inv)
|
||
return -LUT[sin_of];
|
||
else
|
||
return LUT[sin_of];
|
||
}
|
||
|
||
int totty_cos(int cos_of)
|
||
{
|
||
unsigned char inv = 0;
|
||
|
||
cos_of += 32; // Simply rotate by 90 degrees for COS
|
||
cos_of &= 0x7f; // 127
|
||
if (cos_of > 64) {
|
||
cos_of -= 64;
|
||
inv = 1;
|
||
}
|
||
if (inv)
|
||
return -LUT[cos_of];
|
||
else
|
||
return LUT[cos_of];
|
||
}
|
||
|
||
void quad_ripples(int iterations, int delay)
|
||
{
|
||
// 16 values for square root of a^2+b^2. index a*4+b = 10*sqrt
|
||
// This gives the distance to 3.5,3.5 from the point
|
||
unsigned char sqrt_LUT[] = {
|
||
49, 43, 38, 35, 43, 35, 29, 26, 38, 29, 21, 16, 35, 25, 16, 7
|
||
};
|
||
unsigned char x, y, height, distance;
|
||
int i;
|
||
|
||
for (i=0; i<iterations*4; i+=4) {
|
||
fill(0x00);
|
||
for (x=0; x<4; x++) {
|
||
for (y=0; y<4; y++) {
|
||
// x+y*4 gives no. from 0-15 for sqrt_LUT
|
||
distance = sqrt_LUT[x + y*4]; // distance is 0-50 roughly
|
||
|
||
// height is sin of distance + iteration*4
|
||
//height = 4 + totty_sin(distance+i) / 52;
|
||
height = (196 + totty_sin(distance+i)) / 49;
|
||
|
||
// Use 4-way mirroring to save on calculations
|
||
setvoxel(x, y, height);
|
||
setvoxel(7-x, y, height);
|
||
setvoxel(x, 7-y, height);
|
||
setvoxel(7-x, 7-y, height);
|
||
setvoxel(x, y, 7-height);
|
||
setvoxel(7-x, y, 7-height);
|
||
setvoxel(x, 7-y, 7-height);
|
||
setvoxel(7-x, 7-y, 7-height);
|
||
setvoxel(x, height, y);
|
||
setvoxel(7-x, height, y);
|
||
setvoxel(x, height, 7-y);
|
||
setvoxel(7-x, height, 7-y);
|
||
setvoxel(x, 7-height, y);
|
||
setvoxel(7-x, 7-height, y);
|
||
setvoxel(x, 7-height, 7-y);
|
||
setvoxel(7-x, 7-height, 7-y);
|
||
}
|
||
}
|
||
delay_ms(delay);
|
||
}
|
||
}
|
||
|
||
// **********************************************************
|
||
|
||
void effect_random_sparkle_flash(int iterations, int voxels, int delay)
|
||
{
|
||
int i;
|
||
int v;
|
||
for (i = 0; i < iterations; i++)
|
||
{
|
||
for (v=0;v<=voxels;v++)
|
||
setvoxel(rand()%8, rand()%8, rand()%8);
|
||
|
||
delay_ms(delay);
|
||
fill(0x00);
|
||
}
|
||
}
|
||
|
||
// blink 1 random voxel, blink 2 random voxels..... blink 20 random voxels
|
||
// and back to 1 again.
|
||
void effect_random_sparkle(void)
|
||
{
|
||
int i;
|
||
|
||
for (i=1;i<20;i++)
|
||
{
|
||
effect_random_sparkle_flash(5, i, 100);
|
||
}
|
||
|
||
for (i=20;i>=1;i--)
|
||
{
|
||
effect_random_sparkle_flash(5, i, 100);
|
||
}
|
||
|
||
}
|
||
|
||
int effect_telcstairs_do(int x, int val, int delay)
|
||
{
|
||
int y, z;
|
||
|
||
for(y = 0, z = x; y <= z; y++, x--)
|
||
{
|
||
if(x < CUBE_SIZE && y < CUBE_SIZE)
|
||
{
|
||
cube[x][y] = val;
|
||
}
|
||
}
|
||
delay_ms(delay);
|
||
return z;
|
||
}
|
||
|
||
void effect_telcstairs(int invert, int delay, int val)
|
||
{
|
||
int x;
|
||
|
||
if(invert)
|
||
{
|
||
for(x = CUBE_SIZE*2; x >= 0; x--)
|
||
{
|
||
x = effect_telcstairs_do(x, val, delay);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for(x = 0; x < CUBE_SIZE*2; x++)
|
||
{
|
||
x = effect_telcstairs_do(x, val, delay);
|
||
}
|
||
}
|
||
}
|
||
|
||
void draw_positions_axis(char axis, unsigned char positions[64], int invert)
|
||
{
|
||
int x, y, p;
|
||
|
||
fill(0x00);
|
||
|
||
for (x=0; x<8; x++)
|
||
{
|
||
for (y=0; y<8; y++)
|
||
{
|
||
if (invert)
|
||
{
|
||
p = (7-positions[(x*8)+y]);
|
||
} else
|
||
{
|
||
p = positions[(x*8)+y];
|
||
}
|
||
|
||
if (axis == AXIS_Z)
|
||
setvoxel(x, y, p);
|
||
|
||
if (axis == AXIS_Y)
|
||
setvoxel(x, p, y);
|
||
|
||
if (axis == AXIS_X)
|
||
setvoxel(p, y, x);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
void effect_wormsqueeze(int size, int axis, int direction, int iterations,
|
||
int delay)
|
||
{
|
||
int x, y, i, j, k, dx, dy;
|
||
int cube_size;
|
||
int origin = 0;
|
||
|
||
if (direction == -1)
|
||
origin = 7;
|
||
|
||
cube_size = 8-(size-1);
|
||
|
||
x = rand()%cube_size;
|
||
y = rand()%cube_size;
|
||
|
||
for (i=0; i<iterations; i++)
|
||
{
|
||
dx = ((rand()%3)-1);
|
||
dy = ((rand()%3)-1);
|
||
|
||
if ((x+dx) > 0 && (x+dx) < cube_size)
|
||
x += dx;
|
||
|
||
if ((y+dy) > 0 && (y+dy) < cube_size)
|
||
y += dy;
|
||
|
||
shift(axis, direction);
|
||
|
||
|
||
for (j=0; j<size;j++)
|
||
{
|
||
for (k=0; k<size;k++)
|
||
{
|
||
if (axis == AXIS_Z)
|
||
setvoxel(x+j, y+k, origin);
|
||
|
||
if (axis == AXIS_Y)
|
||
setvoxel(x+j, origin, y+k);
|
||
|
||
if (axis == AXIS_X)
|
||
setvoxel(origin, y+j, x+k);
|
||
}
|
||
}
|
||
|
||
delay_ms(delay);
|
||
}
|
||
}
|
||
|
||
void line_3d(int x1, int y1, int z1, int x2, int y2, int z2)
|
||
{
|
||
int i, dx, dy, dz, l, m, n, x_inc, y_inc, z_inc,
|
||
err_1, err_2, dx2, dy2, dz2;
|
||
int pixel[3];
|
||
|
||
pixel[0] = x1;
|
||
pixel[1] = y1;
|
||
pixel[2] = z1;
|
||
dx = x2 - x1;
|
||
dy = y2 - y1;
|
||
dz = z2 - z1;
|
||
if (dx >= 0) {
|
||
x_inc = 1;
|
||
l = dx;
|
||
} else {
|
||
x_inc = -1;
|
||
l = -dx;
|
||
}
|
||
if (dy >= 0) {
|
||
y_inc = 1;
|
||
m = dy;
|
||
} else {
|
||
y_inc = -1;
|
||
m = -dy;
|
||
}
|
||
if (dz >= 0) {
|
||
z_inc = 1;
|
||
n = dz;
|
||
} else {
|
||
z_inc = -1;
|
||
n = -dz;
|
||
}
|
||
dx2 = l << 1;
|
||
dy2 = m << 1;
|
||
dz2 = n << 1;
|
||
if ((l >= m) && (l >= n)) {
|
||
err_1 = dy2 - l;
|
||
err_2 = dz2 - l;
|
||
for (i = 0; i < l; i++) {
|
||
//PUT_PIXEL(pixel);
|
||
setvoxel(pixel[0], pixel[1], pixel[2]);
|
||
//printf("Setting %i %i %i \n", pixel[0], pixel[1], pixel[2]);
|
||
if (err_1 > 0) {
|
||
pixel[1] += y_inc;
|
||
err_1 -= dx2;
|
||
}
|
||
if (err_2 > 0) {
|
||
pixel[2] += z_inc;
|
||
err_2 -= dx2;
|
||
}
|
||
err_1 += dy2;
|
||
err_2 += dz2;
|
||
pixel[0] += x_inc;
|
||
}
|
||
} else if ((m >= l) && (m >= n)) {
|
||
err_1 = dx2 - m;
|
||
err_2 = dz2 - m;
|
||
for (i = 0; i < m; i++) {
|
||
//PUT_PIXEL(pixel);
|
||
setvoxel(pixel[0], pixel[1], pixel[2]);
|
||
//printf("Setting %i %i %i \n", pixel[0], pixel[1], pixel[2]);
|
||
if (err_1 > 0) {
|
||
pixel[0] += x_inc;
|
||
err_1 -= dy2;
|
||
}
|
||
if (err_2 > 0) {
|
||
pixel[2] += z_inc;
|
||
err_2 -= dy2;
|
||
}
|
||
err_1 += dx2;
|
||
err_2 += dz2;
|
||
pixel[1] += y_inc;
|
||
}
|
||
} else {
|
||
err_1 = dy2 - n;
|
||
err_2 = dx2 - n;
|
||
for (i = 0; i < n; i++) {
|
||
setvoxel(pixel[0], pixel[1], pixel[2]);
|
||
//printf("Setting %i %i %i \n", pixel[0], pixel[1], pixel[2]);
|
||
//PUT_PIXEL(pixel);
|
||
if (err_1 > 0) {
|
||
pixel[1] += y_inc;
|
||
err_1 -= dz2;
|
||
}
|
||
if (err_2 > 0) {
|
||
pixel[0] += x_inc;
|
||
err_2 -= dz2;
|
||
}
|
||
err_1 += dy2;
|
||
err_2 += dx2;
|
||
pixel[2] += z_inc;
|
||
}
|
||
}
|
||
setvoxel(pixel[0], pixel[1], pixel[2]);
|
||
//printf("Setting %i %i %i \n", pixel[0], pixel[1], pixel[2]);
|
||
//PUT_PIXEL(pixel);
|
||
}
|
||
|
||
#if 0
|
||
void sinelines(int iterations, int delay)
|
||
{
|
||
int i, x;
|
||
|
||
float left, right, sine_base, x_dividor, ripple_height;
|
||
|
||
for (i=0; i<iterations; i++) {
|
||
for (x=0; x<8; x++) {
|
||
x_dividor = 2 + sin((float)i / 100) + 1;
|
||
ripple_height = 3 + (sin((float)i / 200) + 1) * 6;
|
||
|
||
sine_base = (float) i/40 + (float) x/x_dividor;
|
||
|
||
left = 4 + sin(sine_base) * ripple_height;
|
||
right = 4 + cos(sine_base) * ripple_height;
|
||
right = 7-left;
|
||
|
||
//printf("%i %i \n", (int) left, (int) right);
|
||
|
||
line_3d(0-3, x, (int) left, 7+3, x, (int) right);
|
||
//line_3d((int) right, 7, x);
|
||
}
|
||
|
||
// delay_ms(delay);
|
||
fill(0x00);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
void effect_boxside_randsend_parallel(char axis, int origin, int delay,
|
||
int mode)
|
||
{
|
||
int i;
|
||
int done;
|
||
unsigned char cubepos[64];
|
||
unsigned char pos[64];
|
||
int notdone = 1;
|
||
int notdone2 = 1;
|
||
int sent = 0;
|
||
|
||
for (i=0;i<64;i++)
|
||
{
|
||
pos[i] = 0;
|
||
}
|
||
|
||
while (notdone)
|
||
{
|
||
if (mode == 1)
|
||
{
|
||
notdone2 = 1;
|
||
while (notdone2 && sent<64)
|
||
{
|
||
i = rand()%64;
|
||
if (pos[i] == 0)
|
||
{
|
||
sent++;
|
||
pos[i] += 1;
|
||
notdone2 = 0;
|
||
}
|
||
}
|
||
} else if (mode == 2)
|
||
{
|
||
if (sent<64)
|
||
{
|
||
pos[sent] += 1;
|
||
sent++;
|
||
}
|
||
}
|
||
|
||
done = 0;
|
||
for (i=0;i<64;i++)
|
||
{
|
||
if (pos[i] > 0 && pos[i] <7)
|
||
{
|
||
pos[i] += 1;
|
||
}
|
||
|
||
if (pos[i] == 7)
|
||
done++;
|
||
}
|
||
|
||
if (done == 64)
|
||
notdone = 0;
|
||
|
||
for (i=0;i<64;i++)
|
||
{
|
||
if (origin == 0)
|
||
{
|
||
cubepos[i] = pos[i];
|
||
} else
|
||
{
|
||
cubepos[i] = (7-pos[i]);
|
||
}
|
||
}
|
||
|
||
delay_ms(delay);
|
||
draw_positions_axis(axis, cubepos, 0);
|
||
}
|
||
|
||
}
|
||
|
||
void effect_rain(int iterations)
|
||
{
|
||
int i, ii;
|
||
int rnd_x;
|
||
int rnd_y;
|
||
int rnd_num;
|
||
|
||
for (ii=0;ii<iterations;ii++)
|
||
{
|
||
rnd_num = rand()%4;
|
||
|
||
for (i=0; i < rnd_num;i++)
|
||
{
|
||
rnd_x = rand()%8;
|
||
rnd_y = rand()%8;
|
||
setvoxel(rnd_x, rnd_y, 7);
|
||
}
|
||
|
||
delay_ms(500);
|
||
shift(AXIS_Z, -1);
|
||
}
|
||
}
|
||
|
||
// Set or clear exactly 512 voxels in a random order.
|
||
void effect_random_filler(int delay, int state)
|
||
{
|
||
int x, y, z;
|
||
int loop = 0;
|
||
|
||
if (state == 1) {
|
||
fill(0x00);
|
||
} else {
|
||
fill(0xff);
|
||
}
|
||
|
||
while (loop < 511)
|
||
{
|
||
x = rand()%8;
|
||
y = rand()%8;
|
||
z = rand()%8;
|
||
|
||
if ((state == 0 && getvoxel(x, y, z) == 1) ||
|
||
(state == 1 && getvoxel(x, y, z) == 0))
|
||
{
|
||
altervoxel(x, y, z, state);
|
||
delay_ms(delay);
|
||
loop++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void effect_axis_updown_randsuspend(char axis, int delay, int sleep, int invert)
|
||
{
|
||
unsigned char positions[64];
|
||
unsigned char destinations[64];
|
||
|
||
int i, px;
|
||
|
||
// Set 64 random positions
|
||
for (i=0; i<64; i++)
|
||
{
|
||
positions[i] = 0; // Set all starting positions to 0
|
||
destinations[i] = rand()%8;
|
||
}
|
||
|
||
// Loop 8 times to allow destination 7 to reach all the way
|
||
for (i=0; i<8; i++)
|
||
{
|
||
// For every iteration, move all position one step closer to their destination
|
||
for (px=0; px<64; px++)
|
||
{
|
||
if (positions[px]<destinations[px])
|
||
{
|
||
positions[px]++;
|
||
}
|
||
}
|
||
// Draw the positions and take a nap
|
||
draw_positions_axis(axis, positions, invert);
|
||
delay_ms(delay);
|
||
}
|
||
|
||
// Set all destinations to 7 (opposite from the side they started out)
|
||
for (i=0; i<64; i++)
|
||
{
|
||
destinations[i] = 7;
|
||
}
|
||
|
||
// Suspend the positions in mid-air for a while
|
||
delay_ms(sleep);
|
||
|
||
// Then do the same thing one more time
|
||
for (i=0; i<8; i++)
|
||
{
|
||
for (px=0; px<64; px++)
|
||
{
|
||
if (positions[px]<destinations[px])
|
||
{
|
||
positions[px]++;
|
||
}
|
||
if (positions[px]>destinations[px])
|
||
{
|
||
positions[px]--;
|
||
}
|
||
}
|
||
draw_positions_axis(axis, positions, invert);
|
||
delay_ms(delay);
|
||
}
|
||
}
|
||
|
||
void effect_blinky2()
|
||
{
|
||
int i, r;
|
||
fill(0x00);
|
||
|
||
for (r=0;r<2;r++)
|
||
{
|
||
i = 350;
|
||
while (i>0)
|
||
{
|
||
fill(0x00);
|
||
delay_ms(i);
|
||
|
||
fill(0xff);
|
||
delay_ms(100);
|
||
|
||
i = i - (7 + (500 / (i/10)));
|
||
}
|
||
|
||
delay_ms(500);
|
||
|
||
i = 350;
|
||
while (i>0)
|
||
{
|
||
fill(0x00);
|
||
delay_ms(351-i);
|
||
|
||
fill(0xff);
|
||
delay_ms(100);
|
||
|
||
i = i - (7 + (500 / (i/10)));
|
||
}
|
||
}
|
||
}
|
||
|
||
// Draw a plane on one axis and send it back and forth once.
|
||
void effect_planboing(int plane, int speed)
|
||
{
|
||
int i;
|
||
for (i=0;i<8;i++)
|
||
{
|
||
fill(0x00);
|
||
setplane(plane, i);
|
||
delay_ms(speed);
|
||
}
|
||
|
||
for (i=7;i>=0;i--)
|
||
{
|
||
fill(0x00);
|
||
setplane(plane, i);
|
||
delay_ms(speed);
|
||
}
|
||
}
|
||
|
||
|
||
//********************************************************
|
||
|
||
// ********************************************************
|
||
const char font_data[128][8] =
|
||
{
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0 :
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
|
||
{ 0x00, 0x3E, 0x41, 0x55, 0x41, 0x55, 0x49, 0x3E }, // 1 :
|
||
// | |
|
||
// | ***** |
|
||
// | * * |
|
||
// | * * * * |
|
||
// | * * |
|
||
// | * * * * |
|
||
// | * * * |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x3E, 0x7F, 0x6B, 0x7F, 0x6B, 0x77, 0x3E }, // 2 :
|
||
// | |
|
||
// | ***** |
|
||
// | ******* |
|
||
// | ** * ** |
|
||
// | ******* |
|
||
// | ** * ** |
|
||
// | *** *** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x22, 0x77, 0x7F, 0x7F, 0x3E, 0x1C, 0x08 }, // 3 :
|
||
// | |
|
||
// | * * |
|
||
// | *** *** |
|
||
// | ******* |
|
||
// | ******* |
|
||
// | ***** |
|
||
// | *** |
|
||
// | * |
|
||
|
||
{ 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x3E, 0x1C, 0x08 }, // 4 :
|
||
// | |
|
||
// | * |
|
||
// | *** |
|
||
// | ***** |
|
||
// | ******* |
|
||
// | ***** |
|
||
// | *** |
|
||
// | * |
|
||
|
||
{ 0x00, 0x08, 0x1C, 0x2A, 0x7F, 0x2A, 0x08, 0x1C }, // 5 :
|
||
// | |
|
||
// | * |
|
||
// | *** |
|
||
// | * * * |
|
||
// | ******* |
|
||
// | * * * |
|
||
// | * |
|
||
// | *** |
|
||
|
||
{ 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x3E, 0x08, 0x1C }, // 6 :
|
||
// | |
|
||
// | * |
|
||
// | *** |
|
||
// | ***** |
|
||
// | ******* |
|
||
// | ***** |
|
||
// | * |
|
||
// | *** |
|
||
|
||
{ 0x00, 0x00, 0x1C, 0x3E, 0x3E, 0x3E, 0x1C, 0x00 }, // 7 :
|
||
// | |
|
||
// | |
|
||
// | *** |
|
||
// | ***** |
|
||
// | ***** |
|
||
// | ***** |
|
||
// | *** |
|
||
// | |
|
||
|
||
{ 0xFF, 0xFF, 0xE3, 0xC1, 0xC1, 0xC1, 0xE3, 0xFF }, // 8 :
|
||
// | ******** |
|
||
// | ******** |
|
||
// | *** ** |
|
||
// | ** * |
|
||
// | ** * |
|
||
// | ** * |
|
||
// | *** ** |
|
||
// | ******** |
|
||
|
||
{ 0x00, 0x00, 0x1C, 0x22, 0x22, 0x22, 0x1C, 0x00 }, // 9 :
|
||
// | |
|
||
// | |
|
||
// | *** |
|
||
// | * * |
|
||
// | * * |
|
||
// | * * |
|
||
// | *** |
|
||
// | |
|
||
|
||
{ 0xFF, 0xFF, 0xE3, 0xDD, 0xDD, 0xDD, 0xE3, 0xFF }, // 10 :
|
||
|
||
// | ******** |
|
||
// | ******** |
|
||
// | *** ** |
|
||
// | ** *** * |
|
||
// | ** *** * |
|
||
// | ** *** * |
|
||
// | *** ** |
|
||
// | ******** |
|
||
|
||
{ 0x00, 0x0F, 0x03, 0x05, 0x39, 0x48, 0x48, 0x30 }, // 11 :
|
||
|
||
// | |
|
||
// | **** |
|
||
// | ** |
|
||
// | * * |
|
||
// | *** * |
|
||
// | * * |
|
||
// | * * |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x08, 0x3E, 0x08, 0x1C, 0x22, 0x22, 0x1C }, // 12 :
|
||
// | |
|
||
// | * |
|
||
// | ***** |
|
||
// | * |
|
||
// | *** |
|
||
// | * * |
|
||
// | * * |
|
||
// | *** |
|
||
|
||
{ 0x00, 0x18, 0x14, 0x10, 0x10, 0x30, 0x70, 0x60 }, // 13 :
|
||
|
||
// | |
|
||
// | ** |
|
||
// | * * |
|
||
// | * |
|
||
// | * |
|
||
// | ** |
|
||
// | *** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x0F, 0x19, 0x11, 0x13, 0x37, 0x76, 0x60 }, // 14 :
|
||
// | |
|
||
// | **** |
|
||
// | ** * |
|
||
// | * * |
|
||
// | * ** |
|
||
// | ** *** |
|
||
// | *** ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x08, 0x2A, 0x1C, 0x77, 0x1C, 0x2A, 0x08 }, // 15 :
|
||
// | |
|
||
// | * |
|
||
// | * * * |
|
||
// | *** |
|
||
// | *** *** |
|
||
// | *** |
|
||
// | * * * |
|
||
// | * |
|
||
|
||
{ 0x00, 0x60, 0x78, 0x7E, 0x7F, 0x7E, 0x78, 0x60 }, // 16 :
|
||
// | |
|
||
// | ** |
|
||
// | **** |
|
||
// | ****** |
|
||
// | ******* |
|
||
// | ****** |
|
||
// | **** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x03, 0x0F, 0x3F, 0x7F, 0x3F, 0x0F, 0x03 }, // 17 :
|
||
// | |
|
||
// | ** |
|
||
// | **** |
|
||
// | ****** |
|
||
// | ******* |
|
||
// | ****** |
|
||
// | **** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x08, 0x1C, 0x2A, 0x08, 0x2A, 0x1C, 0x08 }, // 18 :
|
||
// | |
|
||
// | * |
|
||
// | *** |
|
||
// | * * * |
|
||
// | * |
|
||
// | * * * |
|
||
// | *** |
|
||
// | * |
|
||
|
||
{ 0x00, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x66 }, // 19 :
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x3F, 0x65, 0x65, 0x3D, 0x05, 0x05, 0x05 }, // 20 :
|
||
// | |
|
||
// | ****** |
|
||
// | ** * * |
|
||
// | ** * * |
|
||
// | **** * |
|
||
// | * * |
|
||
// | * * |
|
||
// | * * |
|
||
|
||
{ 0x00, 0x0C, 0x32, 0x48, 0x24, 0x12, 0x4C, 0x30 }, // 21 :
|
||
// | |
|
||
// | ** |
|
||
// | ** * |
|
||
// | * * |
|
||
// | * * |
|
||
// | * * |
|
||
// | * ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F }, // 22 :
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ******* |
|
||
// | ******* |
|
||
// | ******* |
|
||
|
||
{ 0x00, 0x08, 0x1C, 0x2A, 0x08, 0x2A, 0x1C, 0x3E }, // 23 :
|
||
// | |
|
||
// | * |
|
||
// | *** |
|
||
// | * * * |
|
||
// | * |
|
||
// | * * * |
|
||
// | *** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x1C, 0x1C, 0x1C }, // 24 :
|
||
// | |
|
||
// | * |
|
||
// | *** |
|
||
// | ***** |
|
||
// | ******* |
|
||
// | *** |
|
||
// | *** |
|
||
// | *** |
|
||
|
||
{ 0x00, 0x1C, 0x1C, 0x1C, 0x7F, 0x3E, 0x1C, 0x08 }, // 25 :
|
||
// | |
|
||
// | *** |
|
||
// | *** |
|
||
// | *** |
|
||
// | ******* |
|
||
// | ***** |
|
||
// | *** |
|
||
// | * |
|
||
|
||
{ 0x00, 0x08, 0x0C, 0x7E, 0x7F, 0x7E, 0x0C, 0x08 }, // 26 :
|
||
// | |
|
||
// | * |
|
||
// | ** |
|
||
// | ****** |
|
||
// | ******* |
|
||
// | ****** |
|
||
// | ** |
|
||
// | * |
|
||
|
||
{ 0x00, 0x08, 0x18, 0x3F, 0x7F, 0x3F, 0x18, 0x08 }, // 27 :
|
||
// | |
|
||
// | * |
|
||
// | ** |
|
||
// | ****** |
|
||
// | ******* |
|
||
// | ****** |
|
||
// | ** |
|
||
// | * |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x70, 0x70, 0x70, 0x7F, 0x7F }, // 28 :
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | *** |
|
||
// | *** |
|
||
// | *** |
|
||
// | ******* |
|
||
// | ******* |
|
||
|
||
{ 0x00, 0x00, 0x14, 0x22, 0x7F, 0x22, 0x14, 0x00 }, // 29 :
|
||
// | |
|
||
// | |
|
||
// | * * |
|
||
// | * * |
|
||
// | ******* |
|
||
// | * * |
|
||
// | * * |
|
||
// | |
|
||
|
||
{ 0x00, 0x08, 0x1C, 0x1C, 0x3E, 0x3E, 0x7F, 0x7F }, // 30 :
|
||
// | |
|
||
// | * |
|
||
// | *** |
|
||
// | *** |
|
||
// | ***** |
|
||
// | ***** |
|
||
// | ******* |
|
||
// | ******* |
|
||
|
||
{ 0x00, 0x7F, 0x7F, 0x3E, 0x3E, 0x1C, 0x1C, 0x08 }, // 31 :
|
||
// | |
|
||
// | ******* |
|
||
// | ******* |
|
||
// | ***** |
|
||
// | ***** |
|
||
// | *** |
|
||
// | *** |
|
||
// | * |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 32 :
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
|
||
{ 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18 }, // 33 : !
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x36, 0x36, 0x14, 0x00, 0x00, 0x00, 0x00 }, // 34 : "
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | * * |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
|
||
{ 0x00, 0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36 }, // 35 : #
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ******* |
|
||
// | ** ** |
|
||
// | ******* |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x08, 0x1E, 0x20, 0x1C, 0x02, 0x3C, 0x08 }, // 36 : $
|
||
// | |
|
||
// | * |
|
||
// | **** |
|
||
// | * |
|
||
// | *** |
|
||
// | * |
|
||
// | **** |
|
||
// | * |
|
||
|
||
{ 0x00, 0x60, 0x66, 0x0C, 0x18, 0x30, 0x66, 0x06 }, // 37 : %
|
||
// | |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x3C, 0x28, 0x65, 0x66, 0x3F }, // 38 : &
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | **** |
|
||
// | * * |
|
||
// | ** * * |
|
||
// | ** ** |
|
||
// | ****** |
|
||
|
||
{ 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00 }, // 39 : '
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
|
||
{ 0x00, 0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60 }, // 40 : (
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x06, 0x0C, 0x18, 0x18, 0x18, 0x0C, 0x06 }, // 41 : )
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x36, 0x1C, 0x7F, 0x1C, 0x36, 0x00 }, // 42 : *
|
||
// | |
|
||
// | |
|
||
// | ** ** |
|
||
// | *** |
|
||
// | ******* |
|
||
// | *** |
|
||
// | ** ** |
|
||
// | |
|
||
|
||
{ 0x00, 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00 }, // 43 : +
|
||
// | |
|
||
// | |
|
||
// | * |
|
||
// | * |
|
||
// | ***** |
|
||
// | * |
|
||
// | * |
|
||
// | |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x30, 0x60 }, // 44 : ,
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00 }, // 45 : -
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | **** |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60 }, // 46 : .
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00 }, // 47 : /
|
||
// | |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x6E, 0x76, 0x66, 0x66, 0x3C }, // 48 : 0
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** *** |
|
||
// | *** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x18, 0x18, 0x38, 0x18, 0x18, 0x18, 0x7E }, // 49 : 1
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | *** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ****** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x06, 0x0C, 0x30, 0x60, 0x7E }, // 50 : 2
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ****** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C }, // 51 : 3
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | *** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x0C, 0x1C, 0x2C, 0x4C, 0x7E, 0x0C, 0x0C }, // 52 : 4
|
||
// | |
|
||
// | ** |
|
||
// | *** |
|
||
// | * ** |
|
||
// | * ** |
|
||
// | ****** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x7E, 0x60, 0x7C, 0x06, 0x06, 0x66, 0x3C }, // 53 : 5
|
||
// | |
|
||
// | ****** |
|
||
// | ** |
|
||
// | ***** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x60, 0x7C, 0x66, 0x66, 0x3C }, // 54 : 6
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x7E, 0x66, 0x0C, 0x0C, 0x18, 0x18, 0x18 }, // 55 : 7
|
||
// | |
|
||
// | ****** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x3C }, // 56 : 8
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x66, 0x3E, 0x06, 0x66, 0x3C }, // 57 : 9
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00 }, // 58 : :
|
||
// | |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | |
|
||
|
||
{ 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30 }, // 59 : ;
|
||
// | |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x06, 0x0C, 0x18, 0x30, 0x18, 0x0C, 0x06 }, // 60 : <
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00 }, // 61 : =
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | **** |
|
||
// | |
|
||
// | **** |
|
||
// | |
|
||
// | |
|
||
|
||
{ 0x00, 0x60, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x60 }, // 62 : >
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x06, 0x1C, 0x18, 0x00, 0x18 }, // 63 : ?
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | *** |
|
||
// | ** |
|
||
// | |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x38, 0x44, 0x5C, 0x58, 0x42, 0x3C, 0x00 }, // 64 : @
|
||
// | |
|
||
// | *** |
|
||
// | * * |
|
||
// | * *** |
|
||
// | * ** |
|
||
// | * * |
|
||
// | **** |
|
||
// | |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66 }, // 65 : A
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ****** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x7C }, // 66 : B
|
||
// | |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C }, // 67 : C
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7C }, // 68 : D
|
||
// | |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E }, // 69 : E
|
||
// | |
|
||
// | ****** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ***** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ****** |
|
||
|
||
{ 0x00, 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x60 }, // 70 : F
|
||
// | |
|
||
// | ****** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ***** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x60, 0x60, 0x6E, 0x66, 0x3C }, // 71 : G
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** *** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x66, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66 }, // 72 : H
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ****** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C }, // 73 : I
|
||
// | |
|
||
// | **** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x1E, 0x0C, 0x0C, 0x0C, 0x6C, 0x6C, 0x38 }, // 74 : J
|
||
// | |
|
||
// | **** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | *** |
|
||
|
||
{ 0x00, 0x66, 0x6C, 0x78, 0x70, 0x78, 0x6C, 0x66 }, // 75 : K
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
// | *** |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7E }, // 76 : L
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ****** |
|
||
|
||
{ 0x00, 0x63, 0x77, 0x7F, 0x6B, 0x63, 0x63, 0x63 }, // 77 : M
|
||
// | |
|
||
// | ** ** |
|
||
// | *** *** |
|
||
// | ******* |
|
||
// | ** * ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x63, 0x73, 0x7B, 0x6F, 0x67, 0x63, 0x63 }, // 78 : N
|
||
// | |
|
||
// | ** ** |
|
||
// | *** ** |
|
||
// | **** ** |
|
||
// | ** **** |
|
||
// | ** *** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C }, // 79 : O
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x7C, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60 }, // 80 : P
|
||
// | |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x66, 0x66, 0x6E, 0x3C, 0x06 }, // 81 : Q
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** *** |
|
||
// | **** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x78, 0x6C, 0x66 }, // 82 : R
|
||
// | |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x3C, 0x66, 0x60, 0x3C, 0x06, 0x66, 0x3C }, // 83 : S
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | **** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x7E, 0x5A, 0x18, 0x18, 0x18, 0x18, 0x18 }, // 84 : T
|
||
// | |
|
||
// | ****** |
|
||
// | * ** * |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3E }, // 85 : U
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18 }, // 86 : V
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63 }, // 87 : W
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** * ** |
|
||
// | ******* |
|
||
// | *** *** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x63, 0x63, 0x36, 0x1C, 0x36, 0x63, 0x63 }, // 88 : X
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | *** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18 }, // 89 : Y
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x7E, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x7E }, // 90 : Z
|
||
// | |
|
||
// | ****** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ****** |
|
||
|
||
{ 0x00, 0x1E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1E }, // 91 : [
|
||
// | |
|
||
// | **** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x00, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00 }, // 92 : \
|
||
// | |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | |
|
||
|
||
{ 0x00, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78 }, // 93 : ]
|
||
// | |
|
||
// | **** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x08, 0x14, 0x22, 0x41, 0x00, 0x00, 0x00 }, // 94 : ^
|
||
// | |
|
||
// | * |
|
||
// | * * |
|
||
// | * * |
|
||
// | * * |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F }, // 95 : _
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ******* |
|
||
|
||
{ 0x00, 0x0C, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00 }, // 96 : `
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x3E }, // 97 : a
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | **** |
|
||
// | ** |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C }, // 98 : b
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C }, // 99 : c
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x06, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3E }, // 100 : d
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x3C, 0x66, 0x7E, 0x60, 0x3C }, // 101 : e
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ****** |
|
||
// | ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x1C, 0x36, 0x30, 0x30, 0x7C, 0x30, 0x30 }, // 102 : f
|
||
// | |
|
||
// | *** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ***** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x06, 0x3C }, // 103 : g
|
||
// | |
|
||
// | |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
// | ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66 }, // 104 : h
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x00, 0x18, 0x00, 0x18, 0x18, 0x18, 0x3C }, // 105 : i
|
||
// | |
|
||
// | |
|
||
// | ** |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x0C, 0x00, 0x0C, 0x0C, 0x6C, 0x6C, 0x38 }, // 106 : j
|
||
// | |
|
||
// | ** |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | *** |
|
||
|
||
{ 0x00, 0x60, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0x66 }, // 107 : k
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18 }, // 108 : l
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x63, 0x77, 0x7F, 0x6B, 0x6B }, // 109 : m
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ** ** |
|
||
// | *** *** |
|
||
// | ******* |
|
||
// | ** * ** |
|
||
// | ** * ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x7C, 0x7E, 0x66, 0x66, 0x66 }, // 110 : n
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ***** |
|
||
// | ****** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C }, // 111 : o
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60 }, // 112 : p
|
||
// | |
|
||
// | |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x3C, 0x6C, 0x6C, 0x3C, 0x0D, 0x0F }, // 113 : q
|
||
// | |
|
||
// | |
|
||
// | **** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
// | ** * |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x7C, 0x66, 0x66, 0x60, 0x60 }, // 114 : r
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ***** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x3E, 0x40, 0x3C, 0x02, 0x7C }, // 115 : s
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ***** |
|
||
// | * |
|
||
// | **** |
|
||
// | * |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x18 }, // 116 : t
|
||
// | |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ****** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3E }, // 117 : u
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x3C, 0x18 }, // 118 : v
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | **** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x63, 0x6B, 0x6B, 0x6B, 0x3E }, // 119 : w
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ** ** |
|
||
// | ** * ** |
|
||
// | ** * ** |
|
||
// | ** * ** |
|
||
// | ***** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66 }, // 120 : x
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ** ** |
|
||
// | **** |
|
||
// | ** |
|
||
// | **** |
|
||
// | ** ** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x66, 0x66, 0x3E, 0x06, 0x3C }, // 121 : y
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | ***** |
|
||
// | ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x3C, 0x0C, 0x18, 0x30, 0x3C }, // 122 : z
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | **** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | **** |
|
||
|
||
{ 0x00, 0x0E, 0x18, 0x18, 0x30, 0x18, 0x18, 0x0E }, // 123 : {
|
||
// | |
|
||
// | *** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | *** |
|
||
|
||
{ 0x00, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18 }, // 124 : |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
|
||
{ 0x00, 0x70, 0x18, 0x18, 0x0C, 0x18, 0x18, 0x70 }, // 125 : }
|
||
// | |
|
||
// | *** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | ** |
|
||
// | *** |
|
||
|
||
{ 0x00, 0x00, 0x00, 0x3A, 0x6C, 0x00, 0x00, 0x00 }, // 126 : ~
|
||
// | |
|
||
// | |
|
||
// | |
|
||
// | *** * |
|
||
// | ** ** |
|
||
// | |
|
||
// | |
|
||
// | |
|
||
|
||
{ 0x00, 0x08, 0x1C, 0x36, 0x63, 0x41, 0x41, 0x7F } // 127 :
|
||
// | |
|
||
// | * |
|
||
// | *** |
|
||
// | ** ** |
|
||
// | ** ** |
|
||
// | * * |
|
||
// | * * |
|
||
// | ******* |
|
||
|
||
|
||
};
|
||
|
||
void effect_text(char *string, int delayt)
|
||
{
|
||
int ltr, dist, rw;
|
||
|
||
fill(0x00);
|
||
for (ltr=0; string[ltr]; ltr++) { // For each letter in string array
|
||
for (dist = 0; dist < 8; dist++) { // bring letter forward
|
||
int rev = 0;
|
||
|
||
fill(0x00); // blank cube
|
||
for (rw = 7; rw >= 0; rw--) { // copy rows
|
||
#if 0
|
||
// put this in for normal cube
|
||
cube[rev][dist] = bitswap(font_data[string[ltr]][rw]);
|
||
#else
|
||
cube[rev][dist] = font_data[string[ltr]][rw];
|
||
// use above line for backward ass cubes
|
||
#endif
|
||
rev++;
|
||
}
|
||
delay_ms(delayt);
|
||
}
|
||
}
|
||
}
|
||
|
||
void effect_text_up(char *string, int delayt)
|
||
{
|
||
int ltr, dist, rw;
|
||
|
||
fill(0x00);
|
||
for (ltr=0; string[ltr]; ltr++) { // For each letter in string array
|
||
for (dist = 0; dist < 8; dist++) { // bring letter forward
|
||
int rev = 0;
|
||
|
||
fill(0x00); // blank cube
|
||
for (rw = 7; rw >= 0; rw--) { // copy rows
|
||
#if 0
|
||
// put this in for miswired backwards cube
|
||
cube[rev][dist] = bitswap(font_data[string[ltr]][rw]);
|
||
#else
|
||
cube[dist][rev] = font_data[string[ltr]][rw];
|
||
// use above line for proper cubes
|
||
#endif
|
||
rev++;
|
||
}
|
||
delay_ms(delayt);
|
||
}
|
||
}
|
||
}
|
||
|
||
void int_ripples(int iterations, int delay)
|
||
{
|
||
// 16 values for square root of a^2+b^2. index a*4+b = 10*sqrt
|
||
// This gives the distance to 3.5,3.5 from the point
|
||
unsigned char sqrt_LUT[]={
|
||
49, 43, 38, 35, 43, 35, 29, 26, 38, 29, 21, 16, 35, 25, 16, 7
|
||
};
|
||
unsigned char x, y, height, distance;
|
||
int i;
|
||
|
||
for (i=0;i<iterations*4;i+=4)
|
||
{
|
||
fill(0x00);
|
||
for (x=0;x<4;x++)
|
||
for (y=0;y<4;y++)
|
||
{
|
||
// x+y*4 gives no. from 0-15 for sqrt_LUT
|
||
distance=sqrt_LUT[x+y*4];// distance is 0-50 roughly
|
||
// height is sin of distance + iteration*4
|
||
//height = 4 + totty_sin(distance+i) / 52;
|
||
height = (196 + totty_sin(distance+i)) / 49;
|
||
// Use 4-way mirroring to save on calculations
|
||
setvoxel(x, y, height);
|
||
setvoxel(7-x, y, height);
|
||
setvoxel(x, 7-y, height);
|
||
setvoxel(7-x, 7-y, height);
|
||
}
|
||
delay_ms(delay);
|
||
}
|
||
}
|
||
|
||
void side_ripples(int iterations, int delay)
|
||
{
|
||
// 16 values for square root of a^2+b^2. index a*4+b = 10*sqrt
|
||
// This gives the distance to 3.5,3.5 from the point
|
||
unsigned char sqrt_LUT[]={
|
||
49, 43, 38, 35, 43, 35, 29, 26, 38, 29, 21, 16, 35, 25, 16, 7
|
||
};
|
||
unsigned char x, y, height, distance;
|
||
int i;
|
||
|
||
for (i=0;i<iterations*4;i+=4)
|
||
{
|
||
fill(0x00);
|
||
for (x=0;x<4;x++)
|
||
for (y=0;y<4;y++)
|
||
{
|
||
// x+y*4 gives no. from 0-15 for sqrt_LUT
|
||
distance=sqrt_LUT[x+y*4];// distance is 0-50 roughly
|
||
// height is sin of distance + iteration*4
|
||
//height = 4 + totty_sin(distance+i) / 52;
|
||
height = (196 + totty_sin(distance+i)) / 49;
|
||
// Use 4-way mirroring to save on calculations
|
||
setvoxel(x, height, y);
|
||
setvoxel(7-x, height, y);
|
||
setvoxel(x, height, 7-y);
|
||
setvoxel(7-x, height, 7-y);
|
||
setvoxel(x, 7-height, y);
|
||
setvoxel(7-x, 7-height, y);
|
||
setvoxel(x, 7-height, 7-y);
|
||
setvoxel(7-x, 7-height, 7-y);
|
||
}
|
||
delay_ms(delay);
|
||
}
|
||
}
|
||
|
||
void mirror_ripples(int iterations, int delay)
|
||
{
|
||
// 16 values for square root of a^2+b^2. index a*4+b = 10*sqrt
|
||
// This gives the distance to 3.5,3.5 from the point
|
||
unsigned char sqrt_LUT[]={
|
||
49, 43, 38, 35, 43, 35, 29, 26, 38, 29, 21, 16, 35, 25, 16, 7
|
||
};
|
||
unsigned char x, y, height, distance;
|
||
int i;
|
||
|
||
for (i=0;i<iterations*4;i+=4)
|
||
{
|
||
fill(0x00);
|
||
for (x=0;x<4;x++)
|
||
for (y=0;y<4;y++)
|
||
{
|
||
// x+y*4 gives no. from 0-15 for sqrt_LUT
|
||
distance=sqrt_LUT[x+y*4];// distance is 0-50 roughly
|
||
// height is sin of distance + iteration*4
|
||
//height = 4 + totty_sin(distance+i) / 52;
|
||
height = (196 + totty_sin(distance+i)) / 49;
|
||
// Use 4-way mirroring to save on calculations
|
||
setvoxel(x, y, height);
|
||
setvoxel(7-x, y, height);
|
||
setvoxel(x, 7-y, height);
|
||
setvoxel(7-x, 7-y, height);
|
||
setvoxel(x, y, 7-height);
|
||
setvoxel(7-x, y, 7-height);
|
||
setvoxel(x, 7-y, 7-height);
|
||
setvoxel(7-x, 7-y, 7-height);
|
||
}
|
||
delay_ms(delay);
|
||
}
|
||
}
|
||
|
||
void zoom_pyramid_clear()
|
||
{
|
||
//1
|
||
|
||
box_walls(0, 0, 0, 7, 0, 7);
|
||
delay_ms(250);
|
||
|
||
//2
|
||
|
||
//Pyramid
|
||
box_wireframe(0, 0, 0, 7, 0, 1);
|
||
|
||
clrplane_y(0);
|
||
delay_ms(250);
|
||
|
||
//3
|
||
|
||
//Pyramid
|
||
clrplane_y(1);
|
||
box_walls(0, 2, 0, 7, 2, 7);
|
||
delay_ms(250);
|
||
|
||
//4
|
||
|
||
//Pyramid
|
||
clrplane_y(2);
|
||
box_walls(0, 3, 0, 7, 3, 7);
|
||
delay_ms(250);
|
||
|
||
//5
|
||
|
||
//Pyramid
|
||
clrplane_y(3);
|
||
box_walls(0, 4, 0, 7, 4, 7);
|
||
delay_ms(250);
|
||
|
||
//5
|
||
|
||
//Pyramid
|
||
|
||
clrplane_y(4);
|
||
box_walls(0, 5, 0, 7, 5, 7);
|
||
delay_ms(250);
|
||
//6
|
||
|
||
|
||
//Pyramid
|
||
|
||
clrplane_y(5);
|
||
box_walls(0, 6, 0, 7, 6, 7);
|
||
delay_ms(250);
|
||
//7
|
||
|
||
//Pyramid
|
||
|
||
clrplane_y(6);
|
||
box_walls(0, 7, 0, 7, 7, 7);
|
||
delay_ms(250);
|
||
|
||
clrplane_y(7);
|
||
delay_ms(5000);
|
||
}
|
||
|
||
void zoom_pyramid()
|
||
{
|
||
int i, j, k, time;
|
||
|
||
//1
|
||
fill(0x00);
|
||
|
||
box_walls(0, 0, 0, 7, 0, 7);
|
||
delay_ms(250);
|
||
|
||
//2
|
||
fill(0x00);
|
||
//Pyramid
|
||
box_wireframe(0, 0, 0, 7, 0, 1);
|
||
|
||
box_walls(0, 1, 0, 7, 1, 7);
|
||
delay_ms(250);
|
||
|
||
//3
|
||
fill(0x00);
|
||
//Pyramid
|
||
box_wireframe(0, 0, 0, 7, 1, 1);
|
||
box_wireframe(1, 1, 2, 6, 1, 3);
|
||
|
||
box_walls(0, 2, 0, 7, 2, 7);
|
||
delay_ms(250);
|
||
|
||
//4
|
||
fill(0x00);
|
||
//Pyramid
|
||
box_wireframe(0, 0, 0, 7, 2, 1);
|
||
box_wireframe(1, 1, 2, 6, 2, 3);
|
||
box_wireframe(2, 2, 4, 5, 2, 5);
|
||
|
||
box_walls(0, 3, 0, 7, 3, 7);
|
||
delay_ms(250);
|
||
|
||
//5
|
||
fill(0x00);
|
||
//Pyramid
|
||
box_wireframe(0, 0, 0, 7, 3, 1);
|
||
box_wireframe(1, 1, 2, 6, 3, 3);
|
||
box_wireframe(2, 2, 4, 5, 3, 5);
|
||
box_wireframe(3, 3, 6, 4, 3, 7);
|
||
|
||
box_walls(0, 4, 0, 7, 4, 7);
|
||
delay_ms(250);
|
||
|
||
//5
|
||
fill(0x00);
|
||
//Pyramid
|
||
box_wireframe(0, 0, 0, 7, 4, 1);
|
||
box_wireframe(1, 1, 2, 6, 4, 3);
|
||
box_wireframe(2, 2, 4, 5, 4, 5);
|
||
box_wireframe(3, 3, 6, 4, 4, 7);
|
||
|
||
box_walls(0, 5, 0, 7, 5, 7);
|
||
delay_ms(250);
|
||
//6
|
||
|
||
fill(0x00);
|
||
//Pyramid
|
||
box_wireframe(0, 0, 0, 7, 5, 1);
|
||
box_wireframe(1, 1, 2, 6, 5, 3);
|
||
box_wireframe(2, 2, 4, 5, 5, 5);
|
||
box_wireframe(3, 3, 6, 4, 4, 7);
|
||
|
||
box_walls(0, 6, 0, 7, 6, 7);
|
||
delay_ms(250);
|
||
//7
|
||
fill(0x00);
|
||
//Pyramid
|
||
box_wireframe(0, 0, 0, 7, 6, 1);
|
||
box_wireframe(1, 1, 2, 6, 6, 3);
|
||
box_wireframe(2, 2, 4, 5, 5, 5);
|
||
box_wireframe(3, 3, 6, 4, 4, 7);
|
||
|
||
box_walls(0, 7, 0, 7, 7, 7);
|
||
delay_ms(250);
|
||
|
||
fill(0x00);
|
||
box_wireframe(0, 0, 0, 7, 7, 1);
|
||
box_wireframe(1, 1, 2, 6, 6, 3);
|
||
box_wireframe(2, 2, 4, 5, 5, 5);
|
||
box_wireframe(3, 3, 6, 4, 4, 7);
|
||
|
||
delay_ms(5000);
|
||
}
|
||
|
||
void effect_intro()
|
||
{
|
||
int cnt, cnt_2, time;
|
||
|
||
// Bottom To Top
|
||
|
||
for (cnt=0; cnt<=7; cnt++) {
|
||
box_wireframe(0, 0, 0, 7, 7, cnt);
|
||
delay_ms(300);
|
||
}
|
||
for (cnt=0; cnt<7; cnt++) {
|
||
clrplane_z(cnt);
|
||
delay_ms(300);
|
||
}
|
||
|
||
// Shift Things Right
|
||
// 1
|
||
shift(AXIS_Y, -1);
|
||
for (cnt=0; cnt<=7; cnt++) {
|
||
setvoxel(cnt, 0, 6);
|
||
}
|
||
delay_ms(300);
|
||
// 2
|
||
shift(AXIS_Y, -1);
|
||
for (cnt=0; cnt<=7; cnt++) {
|
||
setvoxel(cnt, 0, 5);
|
||
}
|
||
setvoxel(0, 0, 6);
|
||
setvoxel(7, 0, 6);
|
||
delay_ms(300);
|
||
// 3
|
||
shift(AXIS_Y, -1);
|
||
for (cnt=0; cnt<=7; cnt++) {
|
||
setvoxel(cnt, 0, 4);
|
||
}
|
||
setvoxel(0, 0, 5);
|
||
setvoxel(7, 0, 5);
|
||
setvoxel(0, 0, 6);
|
||
setvoxel(7, 0, 6);
|
||
delay_ms(300);
|
||
|
||
// 4
|
||
shift(AXIS_Y, -1);
|
||
for (cnt=0; cnt<=7; cnt++) {
|
||
setvoxel(cnt, 0, 3);
|
||
}
|
||
setvoxel(0, 0 ,4);
|
||
setvoxel(7, 0, 4);
|
||
setvoxel(0, 0, 5);
|
||
setvoxel(7, 0, 5);
|
||
setvoxel(0, 0, 6);
|
||
setvoxel(7, 0, 6);
|
||
delay_ms(300);
|
||
|
||
// 5
|
||
shift(AXIS_Y, -1);
|
||
for(cnt=0; cnt<=7; cnt++) {
|
||
setvoxel(cnt, 0, 2);
|
||
}
|
||
setvoxel(0, 0, 3);
|
||
setvoxel(7, 0, 3);
|
||
setvoxel(0, 0, 4);
|
||
setvoxel(7, 0, 4);
|
||
setvoxel(0, 0, 5);
|
||
setvoxel(7, 0, 5);
|
||
setvoxel(0, 0, 6);
|
||
setvoxel(7, 0, 6);
|
||
delay_ms(300);
|
||
|
||
// 6
|
||
shift(AXIS_Y, -1);
|
||
for(cnt=0; cnt<=7; cnt++) {
|
||
setvoxel(cnt, 0, 1);
|
||
}
|
||
setvoxel(0, 0, 2);
|
||
setvoxel(7, 0, 2);
|
||
setvoxel(0, 0, 3);
|
||
setvoxel(7, 0, 3);
|
||
setvoxel(0, 0, 4);
|
||
setvoxel(7, 0, 4);
|
||
setvoxel(0, 0, 5);
|
||
setvoxel(7, 0, 5);
|
||
delay_ms(300);
|
||
|
||
// 7
|
||
shift(AXIS_Y, -1);
|
||
for(cnt=0;cnt<=7;cnt++){
|
||
setvoxel(cnt, 0, 0);
|
||
}
|
||
setvoxel(0, 0, 1);
|
||
setvoxel(7, 0, 1);
|
||
setvoxel(0, 0, 2);
|
||
setvoxel(7, 0, 2);
|
||
setvoxel(0, 0, 3);
|
||
setvoxel(7, 0, 3);
|
||
setvoxel(0, 0, 4);
|
||
setvoxel(7, 0, 4);
|
||
setvoxel(0, 0, 5);
|
||
setvoxel(7, 0, 5);
|
||
delay_ms(300);
|
||
|
||
// Right To Left
|
||
for (cnt=0; cnt<=7; cnt++) {
|
||
box_wireframe(0, 0, 0, 7, cnt, 7);
|
||
delay_ms(300);
|
||
}
|
||
for (cnt=0; cnt<7; cnt++) {
|
||
clrplane_y(cnt);
|
||
delay_ms(300);
|
||
}
|
||
|
||
// Shift to the bottom
|
||
for (cnt_2=6; cnt_2>=0; cnt_2--) {
|
||
shift(AXIS_Z, -1);
|
||
for (cnt=0; cnt<=7; cnt++) {
|
||
setvoxel(cnt, cnt_2, 0);
|
||
}
|
||
for (cnt=6; cnt>cnt_2; cnt--) {
|
||
setvoxel(0, cnt, 0);
|
||
setvoxel(7, cnt, 0);
|
||
}
|
||
delay_ms(300);
|
||
}
|
||
|
||
// Make All Wall Box
|
||
|
||
for (cnt=0; cnt<=6; cnt++) {
|
||
fill(0x00);
|
||
box_walls(0, 0, 0, 7, 7, cnt);
|
||
delay_ms(300);
|
||
}
|
||
|
||
time = 500;
|
||
for (cnt_2=0; cnt_2<5; cnt_2++) {
|
||
time -= 75;
|
||
// Make Box Smaller
|
||
for (cnt=0; cnt<=3; cnt++) {
|
||
fill(0x00);
|
||
box_walls(cnt, cnt, cnt, 7-cnt, 7-cnt, 7-cnt);
|
||
delay_ms(time);
|
||
}
|
||
|
||
// Make Box Bigger
|
||
for (cnt=0; cnt<=3; cnt++) {
|
||
fill(0x00);
|
||
box_walls(3-cnt, 3-cnt, 3-cnt, 4+cnt, 4+cnt, 4+cnt);
|
||
delay_ms(time);
|
||
}
|
||
}
|
||
for (cnt_2=0; cnt_2<5; cnt_2++) {
|
||
time += 75;
|
||
// Make Box Smaller
|
||
for (cnt=0; cnt<=3; cnt++) {
|
||
fill(0x00);
|
||
box_walls(cnt, cnt, cnt, 7-cnt, 7-cnt, 7-cnt);
|
||
delay_ms(time);
|
||
}
|
||
|
||
// Make Box Bigger
|
||
for (cnt=0; cnt<=3; cnt++) {
|
||
fill(0x00);
|
||
box_walls(3-cnt, 3-cnt, 3-cnt, 4+cnt, 4+cnt, 4+cnt);
|
||
delay_ms(time);
|
||
}
|
||
}
|
||
delay_ms(500);
|
||
}
|
||
|
||
// ******************************************
|
||
// 3D addins ********************************
|
||
// ******************************************
|
||
#if 0
|
||
void linespin(int iterations, int delay)
|
||
{
|
||
float top_x, top_y, top_z, bot_x, bot_y, bot_z, sin_base;
|
||
float center_x, center_y;
|
||
|
||
center_x = 4;
|
||
center_y = 4;
|
||
|
||
int i, z;
|
||
for (i=0;i<iterations;i++)
|
||
{
|
||
|
||
//printf("Sin base %f \n", sin_base);
|
||
|
||
for (z = 0; z < 8; z++)
|
||
{
|
||
|
||
sin_base = (float)i/50 + (float)z/(10 + (7*sin((float)i / 200)));
|
||
|
||
top_x = center_x + sin(sin_base) * 5;
|
||
top_y = center_x + cos(sin_base) * 5;
|
||
//top_z = center_x + cos(sin_base/100) * 2.5;
|
||
|
||
bot_x = center_x + sin(sin_base+3.14) * 10;
|
||
bot_y = center_x + cos(sin_base+3.14) * 10;
|
||
//bot_z = 7-top_z;
|
||
|
||
bot_z = z;
|
||
top_z = z;
|
||
|
||
// setvoxel((int) top_x, (int) top_y, 7);
|
||
// setvoxel((int) bot_x, (int) bot_y, 0);
|
||
|
||
//printf("P1: %i %i %i P2: %i %i %i \n", (int) top_x, (int) top_y, 7, (int) bot_x, (int) bot_y, 0);
|
||
|
||
//line_3d((int) top_x, (int) top_y, (int) top_z, (int) bot_x, (int) bot_y, (int) bot_z);
|
||
line_3d((int) top_z, (int) top_x, (int) top_y, (int) bot_z, (int) bot_x, (int) bot_y);
|
||
}
|
||
|
||
// delay_ms(delay);
|
||
fill(0x00);
|
||
}
|
||
|
||
}
|
||
#endif
|
||
|
||
// circle, len 16, offset 28
|
||
const unsigned char paths[44] = {
|
||
0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00,
|
||
0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x71,
|
||
0x72,0x73,0x74,0x75,0x76,0x77,0x67,0x57,
|
||
0x47,0x37,0x27,0x17,0x04,0x03,0x12,0x21,
|
||
0x30,0x40,0x51,0x62,0x73,0x74,0x65,0x56,
|
||
0x47,0x37,0x26,0x15
|
||
};
|
||
|
||
void font_getpath(unsigned char path, unsigned char *destination, int length)
|
||
{
|
||
int i;
|
||
int offset = 0;
|
||
|
||
if (path == 1)
|
||
offset = 28;
|
||
|
||
for (i = 0; i < length; i++)
|
||
destination[i] = paths[i+offset];
|
||
}
|
||
|
||
// ************************************************************
|
||
|
||
void effect_pathmove(unsigned char *path, int length)
|
||
{
|
||
int i, z;
|
||
unsigned char state;
|
||
|
||
for (i=(length-1);i>=1;i--)
|
||
{
|
||
for (z=0;z<8;z++)
|
||
{
|
||
|
||
state = getvoxel(((path[(i-1)]>>4) & 0x0f), (path[(i-1)] & 0x0f), z);
|
||
altervoxel(((path[i]>>4) & 0x0f), (path[i] & 0x0f), z, state);
|
||
}
|
||
}
|
||
for (i=0;i<8;i++)
|
||
clrvoxel(((path[0]>>4) & 0x0f), (path[0] & 0x0f), i);
|
||
}
|
||
|
||
void effect_rand_patharound(int iterations, int delay)
|
||
{
|
||
int z, dz, i;
|
||
z = 4;
|
||
unsigned char path[28];
|
||
|
||
font_getpath(0, path, 28);
|
||
|
||
for (i = 0; i < iterations; i++)
|
||
{
|
||
dz = ((rand()%3)-1);
|
||
z += dz;
|
||
|
||
if (z>7)
|
||
z = 7;
|
||
|
||
if (z<0)
|
||
z = 0;
|
||
|
||
effect_pathmove(path, 28);
|
||
setvoxel(0, 7, z);
|
||
delay_ms(delay);
|
||
}
|
||
}
|
||
|
||
void main()
|
||
{
|
||
int i, x, y, z, m, n;
|
||
|
||
gpio_init();
|
||
gpio_ext(1);
|
||
|
||
for (y=0; y<8; y++) {
|
||
for (x=0; x<8; x++) {
|
||
for (z=0; z<8; z++) {
|
||
setvoxel(x, y, z);
|
||
}
|
||
|
||
delay_ms(20);
|
||
|
||
for (z=0; z<8; z++) {
|
||
clrvoxel(x, y, z);
|
||
}
|
||
}
|
||
}
|
||
for (z=0; z<8; z++) {
|
||
for (y=0; y<8; y++) {
|
||
for (x=0; x<8; x++) {
|
||
setvoxel(x, y, z);
|
||
delay_ms(5);
|
||
}
|
||
}
|
||
}
|
||
fill(0);
|
||
|
||
for (;;) {
|
||
printf("intro\n");
|
||
effect_intro();
|
||
|
||
printf("wormsqueeze\n");
|
||
effect_wormsqueeze(2, AXIS_Z, -1, 100, 500);
|
||
|
||
printf("pyramid\n");
|
||
zoom_pyramid();
|
||
zoom_pyramid_clear();
|
||
|
||
printf("text\n");
|
||
effect_text("MIPS RETROBSD", 600);
|
||
//sinelines(4000, 10);
|
||
//linespin(1500, 10);
|
||
|
||
printf("planboing\n");
|
||
effect_planboing(AXIS_Z, 450);
|
||
effect_planboing(AXIS_Y, 450);
|
||
effect_planboing(AXIS_X, 450);
|
||
|
||
printf("blinky2\n");
|
||
effect_blinky2();
|
||
|
||
printf("mirror ripples\n");
|
||
mirror_ripples(600, 200);
|
||
|
||
printf("axis_updown_randsuspend\n");
|
||
effect_axis_updown_randsuspend(AXIS_Z, 250, 2500, 0);
|
||
effect_axis_updown_randsuspend(AXIS_Z, 250, 2500, 1);
|
||
effect_axis_updown_randsuspend(AXIS_Z, 250, 2500, 0);
|
||
effect_axis_updown_randsuspend(AXIS_Z, 250, 2500, 1);
|
||
effect_axis_updown_randsuspend(AXIS_X, 250, 2500, 0);
|
||
effect_axis_updown_randsuspend(AXIS_X, 250, 2500, 1);
|
||
effect_axis_updown_randsuspend(AXIS_Y, 250, 2500, 0);
|
||
effect_axis_updown_randsuspend(AXIS_Y, 250, 2500, 1);
|
||
|
||
printf("rand_patharound\n");
|
||
effect_rand_patharound(200, 250);
|
||
|
||
printf("fireworks\n");
|
||
fireworks(10, 250);
|
||
|
||
//printf("random_filler\n");
|
||
//effect_random_filler(35, 1);
|
||
//effect_random_filler(35, 0);
|
||
|
||
printf("rain\n");
|
||
effect_rain(100);
|
||
|
||
printf("side ripples\n");
|
||
side_ripples(300, 250);
|
||
|
||
printf("text up\n");
|
||
effect_text_up("MIPS RETROBSD", 600);
|
||
|
||
printf("random sparkle\n");
|
||
effect_random_sparkle();
|
||
|
||
printf("quad ripples\n");
|
||
quad_ripples(600, 150);
|
||
|
||
printf("boxside_randsend_parallel\n");
|
||
effect_boxside_randsend_parallel(AXIS_X, 0, 70, 1);
|
||
effect_boxside_randsend_parallel(AXIS_X, 1, 70, 1);
|
||
effect_boxside_randsend_parallel(AXIS_Y, 0, 70, 1);
|
||
effect_boxside_randsend_parallel(AXIS_Y, 1, 70, 1);
|
||
effect_boxside_randsend_parallel(AXIS_Z, 0, 70, 1);
|
||
effect_boxside_randsend_parallel(AXIS_Z, 1, 70, 1);
|
||
}
|
||
}
|