Paso 8: Programm (effekte Arduino Mega)
Este es un ejemplo del código (efectos)
encontrar el código completo (y actual) en el último paso
void loop()
{
int i, x, y, z;
mientras que (gamechoice == 0)
{
effect_count_up(); AZ
effect_count_thru(); AZ
effect_text(1000,0,13);
effect_text_up(5000,0,6);
effect_rain(50);
effect_random_filler(75,1);
effect_random_filler(75,0);
effect_planboing (AXIS_Z, 400);
effect_planboing (AXIS_Y, 400);
effect_planboing (AXIS_X, 400);
effect_boxside_randsend_parallel (AXIS_X, 0, 150, 1);
effect_boxside_randsend_parallel (AXIS_X, 1, 150, 1);
effect_boxside_randsend_parallel (AXIS_Y, 0, 150, 1);
effect_boxside_randsend_parallel (AXIS_Y, 1, 150, 1);
effect_boxside_randsend_parallel (AXIS_Z, 0, 150, 1);
effect_boxside_randsend_parallel (AXIS_Z, 1, 150, 1);
effect_fireworks(10,30,500);
effect_intro();
sinelines(4000,10);
linespin(1500,10);
mirror_ripples(600,400);
effect_axis_updown_randsuspend (AXIS_Z, 550,5000,0);
effect_axis_updown_randsuspend (AXIS_Z, 550,5000,1);
effect_axis_updown_randsuspend (AXIS_Z, 550,5000,0);
effect_axis_updown_randsuspend (AXIS_Z, 550,5000,1);
effect_axis_updown_randsuspend (AXIS_X, 550,5000,0);
effect_axis_updown_randsuspend (AXIS_X, 550,5000,1);
effect_axis_updown_randsuspend (AXIS_Y, 550,5000,0);
effect_axis_updown_randsuspend (AXIS_Y, 550,5000,1);
side_ripples (300, 500);
effect_random_sparkle();
quad_ripples (600.300);
box_filled(2,2,2,5,5,5);
box_walls(2,2,2,5,5,5);
box_wireframe(2,2,2,5,5,5);
}
}
// ==========================================================================================
Funciones de los efectos
// ==========================================================================================
void draw_positions_axis (eje de char, unsigned char posiciones [64], int invertido)
{
int x, y, p;
Fill(0x00);
para (x = 0; x < 8; x ++)
{
para (y = 0; y < 8; y ++)
{
Si (invertir)
{
p = (7-positions[(x*8)+y]);
} else
{
p = posición [(x*8) + y];
}
Si (eje == AXIS_Z)
setvoxel(x,y,p);
Si (eje == AXIS_Y)
setvoxel(x,p,y);
Si (eje == AXIS_X)
setvoxel(p,y,x);
}
}
}
effect_count_up (AZ).
void effect_count_up)
{
int i, ii, iii;
int x;
int y;
int z;
Fill(0x00);
para (i = 0; i < 8; i ++)
{
Si (i < = 0)
{
x = 0;
y = 0;
z = 0;
}
para (ii = 0; ii < 8; ii ++)
{
para (iii = 0; iii < 7; iii ++)
{
setvoxel(x,y,z);
delay_ms(500);
z = z ++;
}
setvoxel(x,y,z);
delay_ms(500);
y = y ++;
z = 0;
}
setvoxel(x,y,z);
delay_ms(500);
x = x ++;
y = 0;
}
}
effect_count_thru (AZ).
void effect_count_thru)
{
int i, ii, iii;
int x;
int y;
int z;
Fill(0x00);
para (i = 0; i < 8; i ++)
{
Si (i < = 0)
{
x = 0;
y = 0;
z = 0;
}
para (ii = 0; ii < 8; ii ++)
{
para (iii = 0; iii < 7; iii ++)
{
setvoxel(x,y,z);
delay_ms(1000);
clrvoxel(x,y,z);
z = z ++;
}
setvoxel(x,y,z);
delay_ms(1000);
clrvoxel(x,y,z);
y = y ++;
z = 0;
}
setvoxel(x,y,z);
delay_ms(1000);
clrvoxel(x,y,z);
x = x ++;
y = 0;
}
}
void effect_text_up (int delayt, int primero, int ultimo) {}
const int charNum = 6;
char cadena [charNum] = {'S', 'U', 'P', 'E', 'R'};
Fill(0x00);
para (int litros = primero; ltr < último; ltr ++) {/ / para cada letra en la matriz de cadenas
para (dist int = 0; dist < 8; dist ++) {Carta de //bring adelante
relleno (0 x 00), cubo de //blank
rev int = 0;
para (int rw = 7; rw > = 0; rw--) {//copy filas
poner esto en para mal alambrado hacia atrás cubo: cubo [rev] [dist] = bitswap(font_data[string[ltr]][rw]);
Cube [rev] [dist] = font_data [string [litros]] [rw];
Cube [dist] [rev] = fuente [cadena [litros]] [rw];
utilizar por encima de la línea de cubos adecuados
Rev ++;
}
delay_ms(delayt);
}
}
}
void effect_text (int delayt, int primero, int ultimo) {}
const int charNum = 13;
char cadena [charNum] = {'P', 'r', 'e', de ', de ',' ', de ', ' t ', 'a', 'r', ' t ','! ',' '};
Fill(0x00);
para (int litros = primero; ltr < último; ltr ++) {/ / para cada letra en la matriz de cadenas
para (dist int = 0; dist < 8; dist ++) {Carta de //bring adelante
Fill(0x00); cubo en blanco
rev int = 0;
para (int rw = 7; rw > = 0; rw--) {//copy filas
poner esto en cubo normal:
Cube [rev] [dist] = bitswap(font[string[ltr]][rw]);
Cube [rev] [dist] = fuente [cadena [litros]] [rw];
Cube [dist] [rev] = fuente [cadena [litros]] [rw];
utilizar por encima de la línea de cubos de culo hacia atrás
Rev ++;
}
delay_ms(delayt);
}
}
}
void effect_boxside_randsend_parallel (char eje, int origen, int retardo, int modo)
{
int i;
int hecha;
unsigned char cubepos [64];
unsigned char pos [64];
notdone int = 1;
int notdone2 = 1;
Enviado int = 0;
para (i = 0; i < 64; i ++)
{
pos [i] = 0;
}
mientras (notdone)
{
Si (modo == 1)
{
notdone2 = 1;
mientras que (notdone2 & & enviado < 64)
{
i = rand () % 64;
Si (pos [i] == 0)
{
Enviado ++;
pos [i] += 1;
notdone2 = 0;
}
}
} else if (modo == 2)
{
Si (enviado < 64)
{
pos [enviados] += 1;
Enviado ++;
}
}
= 0;
para (i = 0; i < 64; i ++)
{
Si (pos [i] > 0 & & pos [i] < 7)
{
pos [i] += 1;
}
Si (pos [i] == 7)
hecho ++;
}
Si (== 64)
notdone = 0;
para (i = 0; i < 64; i ++)
{
Si (origen == 0)
{
cubepos [i] = pos [i];
} else
{
cubepos [i] = (7-pos[i]);
}
}
delay_ms(Delay);
draw_positions_axis(Axis,cubepos,0);
}
}
void effect_rain (int iteraciones)
{
int i, ii;
int rnd_x;
int rnd_y;
int rnd_num;
para (ii = 0; ii {}
rnd_num = rand () %4;
para (i = 0; i < rnd_num; i ++)
{
rnd_x = rand () %8;
rnd_y = rand () %8;
setvoxel(rnd_x,rnd_y,7);
}
delay_ms(1500);
Shift(AXIS_Z,-1);
}
}
Establecer o borrar exactamente 512 voxels en un orden aleatorio.
void effect_random_filler (int retardo, int estado)
{
int x, y, z;
int bucle = 0;
Si (estado == 1)
{
Fill(0x00);
} else
{
Fill(0xFF);
}
mientras que (lazo < 511)
{
x = rand () %8;
y = rand () %8;
z = rand () %8;
Si ((estado == 0 & & getvoxel(x,y,z) == 0 x 01) || (estado == 1 & & getvoxel(x,y,z) == 0 x 00))
{
altervoxel(x,y,z,State);
delay_ms(Delay);
bucle ++;
}
}
}
Dibujar un plano en un eje y enviarlo hacia atrás y adelante una vez.
void effect_planboing (int plano, int velocidad)
{
int i;
para (i = 0; i < 8; i ++)
{
Fill(0x00);
setplane(Plane, i);
delay_ms(5000);
}
para (i = 7; i > = 0; i--)
{
Fill(0x00);
setplane(Plane,i);
delay_ms(5000);
}
}
void effect_fireworks (int iteraciones, int n, int delay)
{
Fill(0x00);
int i, f, e;
Float origin_x = 3;
Float origin_y = 3;
Float origin_z = 3;
int rand_y, rand_x, rand_z;
slowrate flotador, gravedad;
Las partículas y su posición x, y, z y su movimiento, dx, dy, dz
flotador de partículas [n] [6];
para (i = 0; i {}
origin_x = rand () %4;
origin_y = rand () %4;
origin_z = rand () %2;
origin_z += 5;
origin_x += 2;
origin_y += 2;
disparar una partícula en el aire
para (e = 0; e {}
setvoxel(origin_x,origin_y,e);
delay_ms(600+500*e);
Fill(0x00);
}
Llenar matriz de partículas
para (f = 0; f {}
Posición
partículas [f] [0] = origin_x;
partículas [f] [1] = origin_y;
partículas [f] [2] = origin_z;
rand_x = rand () % 200;
rand_y = rand () % 200;
rand_z = rand () % 200;
Movimiento
partículas [f] [3] = 1-(float) rand_x/100; DX
partículas [f] [4] = 1-(float) rand_y/100; DY
partículas [f] [5] = 1-(float) rand_z/100; DZ
}
explotar
para (e = 0; e < 25; e ++)
{
slowrate = 1 + tan ((e+0.1)/20) * 10;
gravedad = tan ((e+0.1)/20) / 2;
para (f = 0; f {}
las partículas partículas [f] [0] += [f] [3] / slowrate;
las partículas partículas [f] += [1] [f] [4] / slowrate;
las partículas partículas [f] [2] += [f] [5] / slowrate;
partículas [f] [2]-= gravedad;
setvoxel(particles[f][0],particles[f][1],particles[f][2]);
}
delay_ms(Delay);
Fill(0x00);
}
}
}
void effect_intro() {}
int cnt, cnt_2, tiempo;
Abajo hacia arriba
para (cnt = 0; cnt < = 7; cnt ++) {}
box_wireframe (0, 0, 0, 7, 7, cnt);
delay_ms(2000);
}
para (cnt = 0; cnt < 7; cnt ++) {}
clrplane_z(CNT);
delay_ms(2000);
}
Cambio cosas bien
1
Shift(AXIS_Y,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,0,6);
}
delay_ms(2000);
2
Shift(AXIS_Y,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,0,5);
}
setvoxel(0,0,6);
setvoxel(7,0,6);
delay_ms(2000);
3
Shift(AXIS_Y,-1);
para (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(2000);
4
Shift(AXIS_Y,-1);
para (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(2000);
5
Shift(AXIS_Y,-1);
para (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(2000);
6
Shift(AXIS_Y,-1);
para (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(2000);
7
Shift(AXIS_Y,-1);
para (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(2000);
De derecha a izquierda
para (cnt = 0; cnt < = 7; cnt ++) {}
box_wireframe (0, 0, 0, 7, cnt, 7);
delay_ms(2000);
}
para (cnt = 0; cnt < 7; cnt ++) {}
clrplane_y(CNT);
delay_ms(2000);
}
Pasar a la parte inferior
para (cnt_2 = 6; cnt_2 > = 0; cnt_2--) {}
Shift(AXIS_Z,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,cnt_2,0);
}
para (cnt = 6; cnt > cnt_2; cnt--) {}
setvoxel(0,CNT,0);
setvoxel(7,CNT,0);
}
delay_ms(2000);
}
Hacer caja de pared todos
para (cnt = 0; cnt < = 6; cnt ++) {}
Fill(0x00);
box_walls(0,0,0,7,7,CNT);
delay_ms(2000);
}
tiempo = 2000;
para (cnt_2 = 0; cnt_2 < 5; cnt_2 ++) {}
tiempo = tiempo - 300;
Hacer la caja más pequeña
para (cnt = 0; cnt < = 3; cnt ++) {}
Fill(0x00);
box_walls(CNT,CNT,CNT,7-CNT,7-CNT,7-CNT);
delay_ms(Time);
}
Hacer la caja más grande
para (cnt = 0; cnt < = 3; cnt ++) {}
Fill(0x00);
box_walls(3-CNT,3-CNT,3-CNT,4+CNT,4+CNT,4+CNT);
delay_ms(Time);
}
}
para (cnt_2 = 0; cnt_2 < 5; cnt_2 ++) {}
tiempo = tiempo + 300;
Hacer la caja más pequeña
para (cnt = 0; cnt < = 3; cnt ++) {}
Fill(0x00);
box_walls(CNT,CNT,CNT,7-CNT,7-CNT,7-CNT);
delay_ms(Time);
}
Hacer la caja más grande
para (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(2000);
}
void sinelines (int iteraciones, int delay)
{
int i, x;
flotador, izquierda, derecha, sine_base, x_dividor, ripple_height;
para (i = 0; i {}
para (x = 0; x < 8; x ++)
{
x_dividor = 2 + pecado ((float) i / 100) + 1;
ripple_height = 3 + (pecado ((float) i / 200) + 1) * 6;
sine_base = (float) i / 40 + (float) x / x_dividor;
izquierda = 4 + pecado (sine_base) * ripple_height;
derecha = 4 + cos (sine_base) * ripple_height;
derecha = izquierda 7;
printf ("%i %i \n", (int) izquierda, derecha (int));
line_3d (0-3, x, (int) izquierda, 7 + 3, x, (int) derecha);
derecho de line_3d((int), 7, x);
}
delay_ms(Delay);
Fill(0x00);
}
}
void linespin (int iteraciones, int delay)
{
flotador top_x, top_y, top_z, bot_x, bot_y, bot_z, sin_base;
flotador center_x, center_y;
center_x = 4;
center_y = 4;
int i, z;
para (i = 0; i {}
printf ("pecado base %f \n",sin_base);
para (z = 0; z < 8; z ++)
{
sin_base = (float) i / 50 + (float)z/(10+(7*sin((float)i/200)));
top_x = center_x + pecado (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 + pecado (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);
}
}
void mirror_ripples (int iteraciones, int delay)
{
16 valores de raíz cuadrada de a ^ 2 + b ^ 2. Índice de un * 4 + b = 10 * sqrt
Esto da la distancia a 3.5,3.5 desde el punto de
unsigned char sqrt_LUT [] = {49,43,38,35,43,35,29,26,38,29,21,16,35,25,16,7};
LUT_START / / Macro de nueva tottymath. Comentado y reemplazado con el código completo
unsigned char LUT [65];
init_LUT(LUT);
int i;
unsigned char x, y, altura, distancia;
para (i = 0; i {}
Fill(0x00);
para (x = 0; x < 4; x ++)
para (y = 0; y < 4; y ++)
{
x + y * 4 da no. de 0-15 para sqrt_LUT
distancia = sqrt_LUT [x + y * 4] ;// la distancia es aproximadamente 0-50
la altura es pecado de iteración + distancia * 4
altura = 4 + totty_sin(LUT,distance+i)/52;
Height=(196+totty_sin(LUT,Distance+i)) / 49;
Utiliza 4-way mirroring para ahorrar en cálculos
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 effect_axis_updown_randsuspend (char eje, int retardo, sueño de int, int invertido)
{
posiciones de unsigned char [64];
destinos de unsigned char [64];
int i, px;
Set de 64 posiciones al azar
para (i = 0; i < 64; i ++)
{
posiciones [i] = 0; Todas las posiciones de partida se establece en 0
destinos [i] = rand () %8;
}
Lazo 8 veces para permitir que el destino 7 llegar a la
para (i = 0; i < 8; i ++)
{
Para cada iteración, mueva que toda la posición un paso más cerca a su destino
para (px = 0; px < 64; px ++)
{
Si (posiciones {} [px]
posiciones [px] ++;
}
}
Dibujar las posiciones y tomar una siesta
draw_positions_axis (eje, posiciones, invertir);
delay_ms(Delay);
}
Establece todos los destinos en 7 (enfrente del lado comenzaron hacia fuera)
para (i = 0; i < 64; i ++)
{
destinos [i] = 7;
}
Suspender las posiciones en el aire por un tiempo
delay_ms(SLEEP);
Luego hacer lo mismo una vez más
para (i = 0; i < 8; i ++)
{
para (px = 0; px < 64; px ++)
{
Si (posiciones {} [px]
posiciones [px] ++;
}
Si (posiciones [px] > destinations[px])
{
posiciones [px]--;
}
}
draw_positions_axis (eje, posiciones, invertir);
delay_ms(Delay);
}
}
void side_ripples (int iteraciones, int delay)
{
16 valores de raíz cuadrada de a ^ 2 + b ^ 2. Índice de un * 4 + b = 10 * sqrt
Esto da la distancia a 3.5,3.5 desde el punto de
unsigned char sqrt_LUT [] = {49,43,38,35,43,35,29,26,38,29,21,16,35,25,16,7};
LUT_START / / Macro de nueva tottymath. Comentado y reemplazado con el código completo
unsigned char LUT [65];
init_LUT(LUT);
int i;
unsigned char x, y, altura, distancia;
para (i = 0; i {}
Fill(0x00);
para (x = 0; x < 4; x ++)
para (y = 0; y < 4; y ++)
{
x + y * 4 da no. de 0-15 para sqrt_LUT
distancia = sqrt_LUT [x + y * 4] ;// la distancia es aproximadamente 0-50
la altura es pecado de iteración + distancia * 4
altura = 4 + totty_sin(LUT,distance+i)/52;
Height=(196+totty_sin(LUT,Distance+i)) / 49;
Utiliza 4-way mirroring para ahorrar en cálculos
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);
}
}
1 voxel al azar a parpadear, parpadear 2 vóxeles al azar... parpadear vóxeles al azar 20
y de vuelta a 1.
void effect_random_sparkle (void)
{
int i;
para (i = 1; i < 20; i ++)
{
effect_random_sparkle_flash(5,i,200);
}
para (i = 20; i > = 1; i--)
{
effect_random_sparkle_flash(5,i,200);
}
}
void quad_ripples (int iteraciones, int delay)
{
16 valores de raíz cuadrada de a ^ 2 + b ^ 2. Índice de un * 4 + b = 10 * sqrt
Esto da la distancia a 3.5,3.5 desde el punto de
unsigned char sqrt_LUT [] = {49,43,38,35,43,35,29,26,38,29,21,16,35,25,16,7};
LUT_START / / Macro de nueva tottymath. Comentado y reemplazado con el código completo
unsigned char LUT [65];
init_LUT(LUT);
int i;
unsigned char x, y, altura, distancia;
para (i = 0; i {}
Fill(0x00);
para (x = 0; x < 4; x ++)
para (y = 0; y < 4; y ++)
{
x + y * 4 da no. de 0-15 para sqrt_LUT
distancia = sqrt_LUT [x + y * 4] ;// la distancia es aproximadamente 0-50
la altura es pecado de iteración + distancia * 4
altura = 4 + totty_sin(LUT,distance+i)/52;
Height=(196+totty_sin(LUT,Distance+i)) / 49;
Utiliza 4-way mirroring para ahorrar en cálculos
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);
}
}
// ==========================================================================================
Dibujar funciones
// ==========================================================================================
Activado un único voxel (o)
void setvoxel (int x, int y, int z)
{
Si (inrange(x,y,z))
Cube [z] [y] | = (1 << x);
}
Activado un único voxel (y)
void clrvoxel (int x, int y, int z)
{
Si (inrange(x,y,z))
cubo de [z] [y] & = ~ (1 << x);
}
Esta función valida que estamos dibujando dentro del cubo.
unsigned char inrange (int x, int y, int z)
{
Si (x > = 0 & & x < 8 & & y > = 0 & & y < 8 & & z > = 0 & & z < 8)
{
devolver 0 x 01;
} else
{
Una de las coordenadas estaba fuera del cubo.
retorno 0 x 00;
}
}
Conseguir el estado actual de un voxel
unsigned char getvoxel (int x, int y, int z)
{
Si (inrange(x,y,z))
{
Si (cubo [z] [y] & (1 << x))
{
devolver 0 x 01;
} else
{
retorno 0 x 00;
}
} else
{
retorno 0 x 00;
}
}
En un cierto efecto queremos toma bool y escribirlo en un voxel
Esta función llama a la función de manipulación adecuada voxel.
void altervoxel (int x, int y, int z, int estado)
{
Si (estado == 1)
{
setvoxel(x,y,z);
} else
{
clrvoxel(x,y,z);
}
}
El estado de un voxel del tirón.
Si el voxel es 1, su vuelta a un 0 y viceversa.
void flpvoxel (int x, int y, int z)
{
Si (inrange (x, y, z))
Cube [z] [y] ^ = (1 << x);
}
X1 es alwas menor que x2
Esto es útil para funciones que utiliza para los bucles,
para evitar bucles infinitos
void argorder (int ix1, ix2 int, int * ox1, int * ox2)
{
Si (ix1 > ix2)
{
int tmp;
tmp = ix1;
ix1 = ix2;
ix2 = tmp;
}
* ox1 = ix1;
* ox2 = ix2;
}
Establece todos los vóxeles en un X / Y plano en un punto dado
en eje Z
void setplane_z (int z)
{
int i;
Si (z > = 0 & & z < 8)
{
para (i = 0; i < 8; i ++)
Cube [z] [i] = 0xff;
}
}
Vóxeles se borra de la misma manera que el anterior
void clrplane_z (int z)
{
int i;
Si (z > = 0 & & z < 8)
{
para (i = 0; i < 8; i ++)
Cube [z] [i] = 0 x 00;
}
}
void setplane_x (int x)
{
int z;
int y;
Si (x > = 0 & & x < 8)
{
para (z = 0; z < 8; z ++)
{
para (y = 0; y < 8; y ++)
{
Cube [z] [y] | = (1 << x);
}
}
}
}
void clrplane_x (int x)
{
int z;
int y;
Si (x > = 0 & & x < 8)
{
para (z = 0; z < 8; z ++)
{
para (y = 0; y < 8; y ++)
{
cubo de [z] [y] & = ~ (1 << x);
}
}
}
}
void setplane_y (int y)
{
int z;
Si (y > = 0 & & y < 8)
{
para (z = 0; z < 8; z ++)
Cube [z] [y] = 0xff;
}
}
void clrplane_y (int y)
{
int z;
Si (y > = 0 & & y < 8)
{
para (z = 0; z < 8; z ++)
Cube [z] [y] = 0 x 00;
}
}
void setplane (eje de char, unsigned char i)
{
interruptor (eje)
{
caso AXIS_X:
setplane_x(i);
rotura;
caso AXIS_Y:
setplane_y(i);
rotura;
caso AXIS_Z:
setplane_z(i);
rotura;
}
}
void clrplane (eje de char, unsigned char i)
{
interruptor (eje)
{
caso AXIS_X:
clrplane_x(i);
rotura;
caso AXIS_Y:
clrplane_y(i);
rotura;
caso AXIS_Z:
clrplane_z(i);
rotura;
}
}
Introduzca un valor en todos 64 byts del búfer cubo
Se utiliza sobre todo para claro. Fill(0x00)
o todos en. Fill(0xFF)
relleno (patrón de char sin signo)
{
int z;
int y;
para (z = 0; z < 8; z ++)
{
para (y = 0; y < 8; y ++)
{
Cube [z] [y] = patrón;
}
}
}
Dibujar un cuadro con todas las paredes dibujadas y todos los vóxeles en conjunto
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 y y1 y y2);
argorder (z1, z2 y z1 y z2);
para (iz = z1; iz < = z2; iz ++)
{
para (iy = y1; iy < = y2; iy ++)
{
Cube [iz] [iy] | = byteline(x1,x2);
}
}
}
Darw una caja hueca con paredes laterales.
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 y y1 y y2);
argorder (z1, z2 y z1 y z2);
para (iz = z1; iz < = z2; iz ++)
{
para (iy = y1; iy < = y2; iy ++)
{
Si (iy == y1 || iy == y2 || iz == z1 || iz == z2)
{
Cube [iz] [iy] = byteline(x1,x2);
} else
{
Cube [iz] [iy] | = ((0 x 01 << x1) | (0 x 01 << x2));
}
}
}
}
Trazar un rectángulo de alambre. Esto sólo dibuja las esquinas y bordes,
no hay paredes.
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 y y1 y y2);
argorder (z1, z2 y z1 y z2);
Líneas a lo largo de eje X
Cube [z1] [y1] = byteline(x1,x2);
Cube [z1] [y2] = byteline(x1,x2);
Cube [z2] [y1] = byteline(x1,x2);
Cube [z2] [y2] = byteline(x1,x2);
Líneas a lo largo del eje Y
para (iy = y1; iy < = y2; iy ++)
{
setvoxel(x1,IY,Z1);
setvoxel(x1,IY,Z2);
setvoxel(x2,IY,Z1);
setvoxel(x2,IY,Z2);
}
Líneas a lo largo del eje Z
para (iz = z1; iz < = z2; iz ++)
{
setvoxel(x1,Y1,iz);
setvoxel(x1,Y2,iz);
setvoxel(x2,Y1,iz);
setvoxel(x2,Y2,iz);
}
}
bitswap char sin signo (unsigned char x) //Reverses un byte (por lo que cartas no al revés);
{resultado byte;
ASM ("mov __tmp_reg__, % [en] \n\t"
«lsl __tmp_reg__ \n\t» / * cambio de un poco alta para llevar a * /
«ror % [out] \n\t» / * llevar gire __tmp_reg__to baja poco (eventualmente) * /
«lsl __tmp_reg__ \n\t» / * 2 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 3 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 4 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 5 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 6 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 7 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 8 * /
«ror % [out] \n\t»
: [a] "r =" (resultado): [en] "r" (x));
Return(Result);
}
Devuelve un byte con una fila de 1 dibujado en ella.
byteline(2,5) da 0b00111100
char byteline (int Inicio, int final)
{
regresar ((0xff <}
Un byte se girará 180 grados.
MSB se convierte en LSB, LSB se convierte en MSB.
char flipbyte (byte char)
{
flop char = 0 x 00;
= flop (flop & 0b11111110) | (0b00000001 & (byte >> 7));
= flop (flop & 0b11111101) | (0b00000010 & (byte >> 5));
= flop (flop & 0b11111011) | (0b00000100 & (byte >> 3));
= flop (flop & 0b11110111) | (0b00001000 & (bytes >> 1));
= flop (flop & 0b11101111) | (0b00010000 & (bytes << 1));
= flop (flop & 0b11011111) | (0b00100000 & (byte << 3));
= flop (flop & 0b10111111) | (0b01000000 & (byte << 5));
= flop (flop & 0b01111111) | (0b10000000 & (byte << 7));
volver flop;
}
Trace una línea entre cualquier coordenadas en el espacio 3d.
Utiliza valores enteros de entrada, así que no esperes animaciones suaves.
línea de vacía (int x1, int y1, int z1, int x2, int y2, int z2)
{
flotador de xy; voxels cuantos nos movemos en el eje y para cada paso en el eje x
xz del flotador; voxels cuantos nos movemos en el eje y para cada paso en el eje x
unsigned char x, y, z;
unsigned char lasty, lastz;
Siempre queremos llamar a la línea de x = 0 a x = 7.
Si x1 es bigget que x2, tenemos que voltear todos los valores.
Si (x1 > x2)
{
int tmp;
tmp = x2; x2 = x1; x1 = tmp;
tmp = y2; Y2 = y1; Y1 = tmp;
tmp = z2; z2 = z1; Z1 = tmp;
}
Si (y1 > y2)
{
XY = (float)(y1-y2)/(float)(x2-x1);
lasty = y2;
} else
{
XY = (float)(y2-y1)/(float)(x2-x1);
lasty = y1;
}
Si (z1 > z2)
{
XZ = (float)(z1-z2)/(float)(x2-x1);
lastz = z2;
} else
{
XZ = (float)(z2-z1)/(float)(x2-x1);
lastz = z1;
}
Para cada paso de x, incrementos y por:
para (x = x1; x < = x2; x ++)
{
y = (xy*(x-x1)) + y1;
z = (xz*(x-x1)) + z1;
setvoxel(x,y,z);
}
}
Bucle de retardo.
Esto no está calibrado en milisegundos,
pero teníamos ya a muchos efectos que el uso de este
calibración cuando lo pensamos puede ser una buena idea
para calibrarlo.
void delay_ms(uint16_t x)
{
uint8_t y, z;
para (x > 0; x--) {}
para (y = 0 y < 90; y ++) {}
para (z = 0; z < 6; z ++) {}
ASM volátil ("nop");
}
}
}
}
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-x 1;
DY = y2 - y1;
DZ = z2 - z1;
¿x_inc = (dx < 0)? -1: 1;
l = abs(dx);
¿y_inc = (dy < 0)? -1: 1;
m = abs(dy);
¿z_inc = (dz < 0)? -1: 1;
n = abs(dz);
DX2 = l << 1;
Dy2 = m << 1;
dz2 = n << 1;
Si ((l > = m) & & (l > = n)) {}
err_1 = dy2 - l;
err_2 = dz2 - l;
para (i = 0; i < l; i ++) {}
PUT_PIXEL(pixel);
setvoxel(Pixel[0],pixel[1],pixel[2]);
printf ("%i %i valor %i \n", pixel[0],pixel[1],pixel[2]);
Si (err_1 > 0) {}
Pixel [1] += y_inc;
err_1 = dx2;
}
Si (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;
para (i = 0; i < m; i ++) {}
PUT_PIXEL(pixel);
setvoxel(Pixel[0],pixel[1],pixel[2]);
printf ("%i %i valor %i \n", pixel[0],pixel[1],pixel[2]);
Si (err_1 > 0) {}
Pixel [0] += x_inc;
err_1 = dy2;
}
Si (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;
para (i = 0; i < n; i ++) {}
setvoxel(Pixel[0],pixel[1],pixel[2]);
printf ("%i %i valor %i \n", pixel[0],pixel[1],pixel[2]);
PUT_PIXEL(pixel);
Si (err_1 > 0) {}
Pixel [1] += y_inc;
err_1 = dz2;
}
Si (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 ("%i %i valor %i \n", pixel[0],pixel[1],pixel[2]);
PUT_PIXEL(pixel);
}
void init_LUT (unsigned char LUT[65])
{
unsigned char i;
flotador sin_of, seno;
para (i = 0; i < 65; i ++)
{
sin_of = i * PI/64; Sólo tiene una media onda de pecado
sine=sin(sin_of);
181.0 como este cuadrado es < 32767, por lo que podemos multiplicar dos pecado o cos sin desbordar un int.
LUT [i] = seno * 181.0;
}
}
int totty_sin (unsigned char LUT [65], int sin_of)
{
unsigned char inv = 0;
Si (sin_of < 0)
{
sin_of =-sin_of;
INV = 1;
}
sin_of & = 0x7f; 127
Si (sin_of > 64)
{
sin_of-= 64;
INV = 1-inv;
}
Si (inv)
volver - LUT [sin_of];
otra cosa
volver LUT [sin_of];
}
int totty_cos (unsigned char LUT [65], int cos_of)
{
unsigned char inv = 0;
cos_of += 32; / / simplemente gira 90 grados para COS
cos_of & = 0x7f; //127
Si (cos_of > 64)
{
cos_of-= 64;
INV = 1;
}
Si (inv)
volver - LUT [cos_of];
otra cosa
volver LUT [cos_of];
}
void effect_random_sparkle_flash (int iteraciones, vóxeles de int y int retardo)
{
int i;
int v;
para (i = 0; i < iteraciones; i ++)
{
para (v = 0; v < = vóxeles; v ++)
setvoxel(Rand()%8,Rand()%8,Rand()%8);
delay_ms(Delay);
Fill(0x00);
}
}
Cambiar todo el contenido del cubo a lo largo de un eje
Esto es excelente para efectos donde quieres dibujar algo
en un lado del cubo y con flujo hacia el otro
lado. Como la lluvia que fluye hacia abajo el axiz Z.
desplazamiento vacío (eje de char, int dirección)
{
int i, x, y;
int ii, iii;
int estado;
para (i = 0; i < 8; i ++)
{
Si (Dirección == -1)
{
II = i;
} else
{
II = (7-i);
}
para (x = 0; x < 8; x ++)
{
para (y = 0 y < 8; y ++)
{
Si (Dirección == -1)
{
III = ii + 1;
} else
{
III = ii-1;
}
Si (eje == AXIS_Z)
{
Estado = getvoxel(x,y,iii);
altervoxel(x,y,II,State);
}
Si (eje == AXIS_Y)
{
Estado = getvoxel(x,iii,y);
altervoxel(x,II,y,State);
}
Si (eje == AXIS_X)
{
Estado = getvoxel(iii,y,x);
altervoxel(II,y,x,State);
}
}
}
}
Si (Dirección == -1)
{
i = 7;
} else
{
i = 0;
}
para (x = 0; x < 8; x ++)
{
para (y = 0 y < 8; y ++)
{
Si (eje == AXIS_Z)
clrvoxel(x,y,i);
Si (eje == AXIS_Y)
clrvoxel(x,i,y);
Si (eje == AXIS_X)
clrvoxel(i,y,x);
}
}
}
