Subversion Repositories Code-Repo

Compare Revisions

Ignore whitespace Rev 205 → Rev 206

/PIC Stuff/Cerebot_32MX7_LED_Cube/CUBE.c/CUBE.c
3,6 → 3,7
#include "defines.h"
#include "CUBE.h"
#include "SPI1.h"
#include "glcdfont.h"
 
static CUBE_DATA *cube_data_ptr;
 
46,11 → 47,19
 
Cube_Write_DCS(BC);
Cube_Clear();
Cube_Overlay_Clear();
}
 
void Cube_Timer_Interrupt(void) {
// OR values in the overlay array with the display array
int i,j;
for (i = 0; i < CUBE_LAYER_COUNT; i++) {
for (j = 0; j < GCS_LAYER_SIZE; j++) {
cube_data_ptr->GCS_WRITE[i][j] = cube_data_ptr->GCS[i][j] | cube_data_ptr->GCS_OVERLAY[i][j];
}
}
// Write to the GCS register
SPI1_Write(cube_data_ptr->GCS[cube_data_ptr->current_layer], GCS_LAYER_SIZE, &Cube_GCS_Write_Callback);
SPI1_Write(cube_data_ptr->GCS_WRITE[cube_data_ptr->current_layer], GCS_LAYER_SIZE, &Cube_GCS_Write_Callback);
}
 
void Cube_DCS_Write_Callback(void) {
215,7 → 224,7
}
 
void Cube_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) {
// Copies data from one pixel to another one
// Copies data from pixel 1 to pixel 2
// Note: destination pixel value is overwritten
int prev_R, prev_G, prev_B;
Cube_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B);
222,113 → 231,483
Cube_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B);
}
 
void Cube_Rotate_Shell(char shell) {
void Cube_Rotate_Shell(char shell, char direction) {
// Shell is the layer to rotate, with the outermost being 0
int layer, origin_R, origin_G, origin_B;;
for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) {
switch(shell) {
case 0:
// Rotate outermost layer
Cube_Get_Pixel(layer, 0, 0, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 0, 1, layer, 0, 0);
Cube_Move_Pixel(layer, 0, 2, layer, 0, 1);
Cube_Move_Pixel(layer, 0, 3, layer, 0, 2);
Cube_Move_Pixel(layer, 0, 4, layer, 0, 3);
Cube_Move_Pixel(layer, 0, 5, layer, 0, 4);
Cube_Move_Pixel(layer, 0, 6, layer, 0, 5);
Cube_Move_Pixel(layer, 0, 7, layer, 0, 6);
Cube_Move_Pixel(layer, 1, 7, layer, 0, 7);
Cube_Move_Pixel(layer, 2, 7, layer, 1, 7);
Cube_Move_Pixel(layer, 3, 7, layer, 2, 7);
Cube_Move_Pixel(layer, 4, 7, layer, 3, 7);
Cube_Move_Pixel(layer, 5, 7, layer, 4, 7);
Cube_Move_Pixel(layer, 6, 7, layer, 5, 7);
Cube_Move_Pixel(layer, 7, 7, layer, 6, 7);
Cube_Move_Pixel(layer, 7, 6, layer, 7, 7);
Cube_Move_Pixel(layer, 7, 5, layer, 7, 6);
Cube_Move_Pixel(layer, 7, 4, layer, 7, 5);
Cube_Move_Pixel(layer, 7, 3, layer, 7, 4);
Cube_Move_Pixel(layer, 7, 2, layer, 7, 3);
Cube_Move_Pixel(layer, 7, 1, layer, 7, 2);
Cube_Move_Pixel(layer, 7, 0, layer, 7, 1);
Cube_Move_Pixel(layer, 6, 0, layer, 7, 0);
Cube_Move_Pixel(layer, 5, 0, layer, 6, 0);
Cube_Move_Pixel(layer, 4, 0, layer, 5, 0);
Cube_Move_Pixel(layer, 3, 0, layer, 4, 0);
Cube_Move_Pixel(layer, 2, 0, layer, 3, 0);
Cube_Move_Pixel(layer, 1, 0, layer, 2, 0);
Cube_Set_Pixel(layer, 1, 0, origin_R, origin_G, origin_B);
break;
case 1:
// Rotate second to outermost layer
Cube_Get_Pixel(layer, 1, 1, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 1, 2, layer, 1, 1);
Cube_Move_Pixel(layer, 1, 3, layer, 1, 2);
Cube_Move_Pixel(layer, 1, 4, layer, 1, 3);
Cube_Move_Pixel(layer, 1, 5, layer, 1, 4);
Cube_Move_Pixel(layer, 1, 6, layer, 1, 5);
Cube_Move_Pixel(layer, 2, 6, layer, 1, 6);
Cube_Move_Pixel(layer, 3, 6, layer, 2, 6);
Cube_Move_Pixel(layer, 4, 6, layer, 3, 6);
Cube_Move_Pixel(layer, 5, 6, layer, 4, 6);
Cube_Move_Pixel(layer, 6, 6, layer, 5, 6);
Cube_Move_Pixel(layer, 6, 5, layer, 6, 6);
Cube_Move_Pixel(layer, 6, 4, layer, 6, 5);
Cube_Move_Pixel(layer, 6, 3, layer, 6, 4);
Cube_Move_Pixel(layer, 6, 2, layer, 6, 3);
Cube_Move_Pixel(layer, 6, 1, layer, 6, 2);
Cube_Move_Pixel(layer, 5, 1, layer, 6, 1);
Cube_Move_Pixel(layer, 4, 1, layer, 5, 1);
Cube_Move_Pixel(layer, 3, 1, layer, 4, 1);
Cube_Move_Pixel(layer, 2, 1, layer, 3, 1);
Cube_Set_Pixel(layer, 2, 1, origin_R, origin_G, origin_B);
break;
case 2:
// Rotate second to innermost layer
Cube_Get_Pixel(layer, 2, 2, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 2, 3, layer, 2, 2);
Cube_Move_Pixel(layer, 2, 4, layer, 2, 3);
Cube_Move_Pixel(layer, 2, 5, layer, 2, 4);
Cube_Move_Pixel(layer, 3, 5, layer, 2, 5);
Cube_Move_Pixel(layer, 4, 5, layer, 3, 5);
Cube_Move_Pixel(layer, 5, 5, layer, 4, 5);
Cube_Move_Pixel(layer, 5, 4, layer, 5, 5);
Cube_Move_Pixel(layer, 5, 3, layer, 5, 4);
Cube_Move_Pixel(layer, 5, 2, layer, 5, 3);
Cube_Move_Pixel(layer, 4, 2, layer, 5, 2);
Cube_Move_Pixel(layer, 3, 2, layer, 4, 2);
Cube_Set_Pixel(layer, 3, 2, origin_R, origin_G, origin_B);
break;
case 3:
// Rotate innermost layer
Cube_Get_Pixel(layer, 3, 3, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 3, 4, layer, 3, 3);
Cube_Move_Pixel(layer, 4, 4, layer, 3, 4);
Cube_Move_Pixel(layer, 4, 3, layer, 4, 4);
Cube_Set_Pixel(layer, 4, 3, origin_R, origin_G, origin_B);
break;
if (direction) {
switch(shell) {
case 0:
// Rotate outermost layer
Cube_Get_Pixel(layer, 0, 0, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 0, 1, layer, 0, 0);
Cube_Move_Pixel(layer, 0, 2, layer, 0, 1);
Cube_Move_Pixel(layer, 0, 3, layer, 0, 2);
Cube_Move_Pixel(layer, 0, 4, layer, 0, 3);
Cube_Move_Pixel(layer, 0, 5, layer, 0, 4);
Cube_Move_Pixel(layer, 0, 6, layer, 0, 5);
Cube_Move_Pixel(layer, 0, 7, layer, 0, 6);
Cube_Move_Pixel(layer, 1, 7, layer, 0, 7);
Cube_Move_Pixel(layer, 2, 7, layer, 1, 7);
Cube_Move_Pixel(layer, 3, 7, layer, 2, 7);
Cube_Move_Pixel(layer, 4, 7, layer, 3, 7);
Cube_Move_Pixel(layer, 5, 7, layer, 4, 7);
Cube_Move_Pixel(layer, 6, 7, layer, 5, 7);
Cube_Move_Pixel(layer, 7, 7, layer, 6, 7);
Cube_Move_Pixel(layer, 7, 6, layer, 7, 7);
Cube_Move_Pixel(layer, 7, 5, layer, 7, 6);
Cube_Move_Pixel(layer, 7, 4, layer, 7, 5);
Cube_Move_Pixel(layer, 7, 3, layer, 7, 4);
Cube_Move_Pixel(layer, 7, 2, layer, 7, 3);
Cube_Move_Pixel(layer, 7, 1, layer, 7, 2);
Cube_Move_Pixel(layer, 7, 0, layer, 7, 1);
Cube_Move_Pixel(layer, 6, 0, layer, 7, 0);
Cube_Move_Pixel(layer, 5, 0, layer, 6, 0);
Cube_Move_Pixel(layer, 4, 0, layer, 5, 0);
Cube_Move_Pixel(layer, 3, 0, layer, 4, 0);
Cube_Move_Pixel(layer, 2, 0, layer, 3, 0);
Cube_Move_Pixel(layer, 1, 0, layer, 2, 0);
Cube_Set_Pixel(layer, 1, 0, origin_R, origin_G, origin_B);
break;
case 1:
// Rotate second to outermost layer
Cube_Get_Pixel(layer, 1, 1, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 1, 2, layer, 1, 1);
Cube_Move_Pixel(layer, 1, 3, layer, 1, 2);
Cube_Move_Pixel(layer, 1, 4, layer, 1, 3);
Cube_Move_Pixel(layer, 1, 5, layer, 1, 4);
Cube_Move_Pixel(layer, 1, 6, layer, 1, 5);
Cube_Move_Pixel(layer, 2, 6, layer, 1, 6);
Cube_Move_Pixel(layer, 3, 6, layer, 2, 6);
Cube_Move_Pixel(layer, 4, 6, layer, 3, 6);
Cube_Move_Pixel(layer, 5, 6, layer, 4, 6);
Cube_Move_Pixel(layer, 6, 6, layer, 5, 6);
Cube_Move_Pixel(layer, 6, 5, layer, 6, 6);
Cube_Move_Pixel(layer, 6, 4, layer, 6, 5);
Cube_Move_Pixel(layer, 6, 3, layer, 6, 4);
Cube_Move_Pixel(layer, 6, 2, layer, 6, 3);
Cube_Move_Pixel(layer, 6, 1, layer, 6, 2);
Cube_Move_Pixel(layer, 5, 1, layer, 6, 1);
Cube_Move_Pixel(layer, 4, 1, layer, 5, 1);
Cube_Move_Pixel(layer, 3, 1, layer, 4, 1);
Cube_Move_Pixel(layer, 2, 1, layer, 3, 1);
Cube_Set_Pixel(layer, 2, 1, origin_R, origin_G, origin_B);
break;
case 2:
// Rotate second to innermost layer
Cube_Get_Pixel(layer, 2, 2, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 2, 3, layer, 2, 2);
Cube_Move_Pixel(layer, 2, 4, layer, 2, 3);
Cube_Move_Pixel(layer, 2, 5, layer, 2, 4);
Cube_Move_Pixel(layer, 3, 5, layer, 2, 5);
Cube_Move_Pixel(layer, 4, 5, layer, 3, 5);
Cube_Move_Pixel(layer, 5, 5, layer, 4, 5);
Cube_Move_Pixel(layer, 5, 4, layer, 5, 5);
Cube_Move_Pixel(layer, 5, 3, layer, 5, 4);
Cube_Move_Pixel(layer, 5, 2, layer, 5, 3);
Cube_Move_Pixel(layer, 4, 2, layer, 5, 2);
Cube_Move_Pixel(layer, 3, 2, layer, 4, 2);
Cube_Set_Pixel(layer, 3, 2, origin_R, origin_G, origin_B);
break;
case 3:
// Rotate innermost layer
Cube_Get_Pixel(layer, 3, 3, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 3, 4, layer, 3, 3);
Cube_Move_Pixel(layer, 4, 4, layer, 3, 4);
Cube_Move_Pixel(layer, 4, 3, layer, 4, 4);
Cube_Set_Pixel(layer, 4, 3, origin_R, origin_G, origin_B);
break;
}
} else {
switch(shell) {
case 0:
// Rotate outermost layer
Cube_Get_Pixel(layer, 0, 0, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 1, 0, layer, 0, 0);
Cube_Move_Pixel(layer, 2, 0, layer, 1, 0);
Cube_Move_Pixel(layer, 3, 0, layer, 2, 0);
Cube_Move_Pixel(layer, 4, 0, layer, 3, 0);
Cube_Move_Pixel(layer, 5, 0, layer, 4, 0);
Cube_Move_Pixel(layer, 6, 0, layer, 5, 0);
Cube_Move_Pixel(layer, 7, 0, layer, 6, 0);
Cube_Move_Pixel(layer, 7, 1, layer, 7, 0);
Cube_Move_Pixel(layer, 7, 2, layer, 7, 1);
Cube_Move_Pixel(layer, 7, 3, layer, 7, 2);
Cube_Move_Pixel(layer, 7, 4, layer, 7, 3);
Cube_Move_Pixel(layer, 7, 5, layer, 7, 4);
Cube_Move_Pixel(layer, 7, 6, layer, 7, 5);
Cube_Move_Pixel(layer, 7, 7, layer, 7, 6);
Cube_Move_Pixel(layer, 6, 7, layer, 7, 7);
Cube_Move_Pixel(layer, 5, 7, layer, 6, 7);
Cube_Move_Pixel(layer, 4, 7, layer, 5, 7);
Cube_Move_Pixel(layer, 3, 7, layer, 4, 7);
Cube_Move_Pixel(layer, 2, 7, layer, 3, 7);
Cube_Move_Pixel(layer, 1, 7, layer, 2, 7);
Cube_Move_Pixel(layer, 0, 7, layer, 1, 7);
Cube_Move_Pixel(layer, 0, 6, layer, 0, 7);
Cube_Move_Pixel(layer, 0, 5, layer, 0, 6);
Cube_Move_Pixel(layer, 0, 4, layer, 0, 5);
Cube_Move_Pixel(layer, 0, 3, layer, 0, 4);
Cube_Move_Pixel(layer, 0, 2, layer, 0, 3);
Cube_Move_Pixel(layer, 0, 1, layer, 0, 2);
Cube_Set_Pixel(layer, 0, 1, origin_R, origin_G, origin_B);
break;
case 1:
// Rotate second to outermost layer
Cube_Get_Pixel(layer, 1, 1, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 2, 1, layer, 1, 1);
Cube_Move_Pixel(layer, 3, 1, layer, 2, 1);
Cube_Move_Pixel(layer, 4, 1, layer, 3, 1);
Cube_Move_Pixel(layer, 5, 1, layer, 4, 1);
Cube_Move_Pixel(layer, 6, 1, layer, 5, 1);
Cube_Move_Pixel(layer, 6, 2, layer, 6, 1);
Cube_Move_Pixel(layer, 6, 3, layer, 6, 2);
Cube_Move_Pixel(layer, 6, 4, layer, 6, 3);
Cube_Move_Pixel(layer, 6, 5, layer, 6, 4);
Cube_Move_Pixel(layer, 6, 6, layer, 6, 5);
Cube_Move_Pixel(layer, 5, 6, layer, 6, 6);
Cube_Move_Pixel(layer, 4, 6, layer, 5, 6);
Cube_Move_Pixel(layer, 3, 6, layer, 4, 6);
Cube_Move_Pixel(layer, 2, 6, layer, 3, 6);
Cube_Move_Pixel(layer, 1, 6, layer, 2, 6);
Cube_Move_Pixel(layer, 1, 5, layer, 1, 6);
Cube_Move_Pixel(layer, 1, 4, layer, 1, 5);
Cube_Move_Pixel(layer, 1, 3, layer, 1, 4);
Cube_Move_Pixel(layer, 1, 2, layer, 1, 3);
Cube_Set_Pixel(layer, 1, 2, origin_R, origin_G, origin_B);
break;
case 2:
// Rotate second to innermost layer
Cube_Get_Pixel(layer, 2, 2, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 3, 2, layer, 2, 2);
Cube_Move_Pixel(layer, 4, 2, layer, 3, 2);
Cube_Move_Pixel(layer, 5, 2, layer, 4, 2);
Cube_Move_Pixel(layer, 5, 3, layer, 5, 2);
Cube_Move_Pixel(layer, 5, 4, layer, 5, 3);
Cube_Move_Pixel(layer, 5, 5, layer, 5, 4);
Cube_Move_Pixel(layer, 4, 5, layer, 5, 5);
Cube_Move_Pixel(layer, 3, 5, layer, 4, 5);
Cube_Move_Pixel(layer, 2, 5, layer, 3, 5);
Cube_Move_Pixel(layer, 2, 4, layer, 2, 5);
Cube_Move_Pixel(layer, 2, 3, layer, 2, 4);
Cube_Set_Pixel(layer, 2, 3, origin_R, origin_G, origin_B);
break;
case 3:
// Rotate innermost layer
Cube_Get_Pixel(layer, 3, 3, &origin_R, &origin_G, &origin_B);
Cube_Move_Pixel(layer, 4, 3, layer, 3, 3);
Cube_Move_Pixel(layer, 4, 4, layer, 4, 3);
Cube_Move_Pixel(layer, 3, 4, layer, 4, 4);
Cube_Set_Pixel(layer, 3, 4, origin_R, origin_G, origin_B);
break;
}
}
}
}
 
void Cube_Rotate(void) {
void Cube_Rotate(char direction) {
// Rotate outermost layer
Cube_Rotate_Shell(0);
Cube_Rotate_Shell(0, direction);
// Rotate second to outermost layer
if ((cube_data_ptr->rotation_counter != 1) && (cube_data_ptr->rotation_counter != 5)) {
Cube_Rotate_Shell(1);
Cube_Rotate_Shell(1, direction);
}
// Rotate second to innermost layer
if ((cube_data_ptr->rotation_counter != 0) && (cube_data_ptr->rotation_counter != 2) &&
(cube_data_ptr->rotation_counter != 4) && (cube_data_ptr->rotation_counter != 6)) {
Cube_Rotate_Shell(2);
Cube_Rotate_Shell(2, direction);
}
// Rotate innermost layer
if ((cube_data_ptr->rotation_counter == 3) || (cube_data_ptr->rotation_counter == 7)) {
Cube_Rotate_Shell(3);
Cube_Rotate_Shell(3, direction);
}
 
cube_data_ptr->rotation_counter = (cube_data_ptr->rotation_counter == CUBE_ROTATIONS-1)
? 0 : cube_data_ptr->rotation_counter + 1;
}
 
 
void Cube_Overlay_Clear(void) {
int i,j;
for (i = 0; i < CUBE_LAYER_COUNT; i++)
for (j = 0; j < GCS_LAYER_SIZE; j++)
cube_data_ptr->GCS_OVERLAY[i][j] = 0x00;
}
 
void Cube_Overlay_Set_Pixel(int layer, int row, int column, int R, int G, int B) {
// Set the specified pixel to the given color
R &= 0x0FFF;
G &= 0x0FFF;
B &= 0x0FFF;
int var = row * GCS_REG_SIZE + (column / 2 * 9);
switch (column % 2) {
case 0:
cube_data_ptr->GCS_OVERLAY[layer][var+0] = R & 0xFF;
cube_data_ptr->GCS_OVERLAY[layer][var+1] = (G << 4) | (R >> 8);
cube_data_ptr->GCS_OVERLAY[layer][var+2] = G >> 4;
cube_data_ptr->GCS_OVERLAY[layer][var+3] = B & 0xFF;
cube_data_ptr->GCS_OVERLAY[layer][var+4] = (cube_data_ptr->GCS_OVERLAY[layer][var+4] & 0xF0) | (B >> 8);
break;
case 1:
cube_data_ptr->GCS_OVERLAY[layer][var+4] = (cube_data_ptr->GCS_OVERLAY[layer][var+4] & 0x0F) | (R << 4);
cube_data_ptr->GCS_OVERLAY[layer][var+5] = R >> 4;
cube_data_ptr->GCS_OVERLAY[layer][var+6] = G & 0xFF;
cube_data_ptr->GCS_OVERLAY[layer][var+7] = (B << 4) | (G >> 8);
cube_data_ptr->GCS_OVERLAY[layer][var+8] = B >> 4;
break;
}
}
 
void Cube_Overlay_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B) {
int var = row * GCS_REG_SIZE + (column / 2 * 9);
switch (column % 2) {
// Concatenate lower byte and upper byte of each color channel
case 0:
*R = cube_data_ptr->GCS_OVERLAY[layer][var+0] | ((cube_data_ptr->GCS_OVERLAY[layer][var+1] & 0x0F) << 8);
*G = (cube_data_ptr->GCS_OVERLAY[layer][var+1] >> 4) | (cube_data_ptr->GCS_OVERLAY[layer][var+2] << 4);
*B = cube_data_ptr->GCS_OVERLAY[layer][var+3] | ((cube_data_ptr->GCS_OVERLAY[layer][var+4] & 0x0F) << 8);
break;
case 1:
*R = (cube_data_ptr->GCS_OVERLAY[layer][var+4] >> 4) | (cube_data_ptr->GCS_OVERLAY[layer][var+5] << 4);
*G = cube_data_ptr->GCS_OVERLAY[layer][var+6] | ((cube_data_ptr->GCS_OVERLAY[layer][var+7] & 0x0F) << 8);
*B = (cube_data_ptr->GCS_OVERLAY[layer][var+7] >> 4) | (cube_data_ptr->GCS_OVERLAY[layer][var+8] << 4);
break;
}
}
 
void Cube_Overlay_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) {
// Copies data from pixel 1 to pixel 2
// Note: destination pixel value is overwritten
int prev_R, prev_G, prev_B;
Cube_Overlay_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B);
Cube_Overlay_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B);
}
 
void Cube_Overlay_Rotate_Shell(char shell, char direction) {
// Shell is the layer to rotate, with the outermost being 0
int layer, origin_R, origin_G, origin_B;;
for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) {
if (direction) {
switch(shell) {
case 0:
// Rotate outermost layer
Cube_Overlay_Get_Pixel(layer, 0, 0, &origin_R, &origin_G, &origin_B);
Cube_Overlay_Move_Pixel(layer, 0, 1, layer, 0, 0);
Cube_Overlay_Move_Pixel(layer, 0, 2, layer, 0, 1);
Cube_Overlay_Move_Pixel(layer, 0, 3, layer, 0, 2);
Cube_Overlay_Move_Pixel(layer, 0, 4, layer, 0, 3);
Cube_Overlay_Move_Pixel(layer, 0, 5, layer, 0, 4);
Cube_Overlay_Move_Pixel(layer, 0, 6, layer, 0, 5);
Cube_Overlay_Move_Pixel(layer, 0, 7, layer, 0, 6);
Cube_Overlay_Move_Pixel(layer, 1, 7, layer, 0, 7);
Cube_Overlay_Move_Pixel(layer, 2, 7, layer, 1, 7);
Cube_Overlay_Move_Pixel(layer, 3, 7, layer, 2, 7);
Cube_Overlay_Move_Pixel(layer, 4, 7, layer, 3, 7);
Cube_Overlay_Move_Pixel(layer, 5, 7, layer, 4, 7);
Cube_Overlay_Move_Pixel(layer, 6, 7, layer, 5, 7);
Cube_Overlay_Move_Pixel(layer, 7, 7, layer, 6, 7);
Cube_Overlay_Move_Pixel(layer, 7, 6, layer, 7, 7);
Cube_Overlay_Move_Pixel(layer, 7, 5, layer, 7, 6);
Cube_Overlay_Move_Pixel(layer, 7, 4, layer, 7, 5);
Cube_Overlay_Move_Pixel(layer, 7, 3, layer, 7, 4);
Cube_Overlay_Move_Pixel(layer, 7, 2, layer, 7, 3);
Cube_Overlay_Move_Pixel(layer, 7, 1, layer, 7, 2);
Cube_Overlay_Move_Pixel(layer, 7, 0, layer, 7, 1);
Cube_Overlay_Move_Pixel(layer, 6, 0, layer, 7, 0);
Cube_Overlay_Move_Pixel(layer, 5, 0, layer, 6, 0);
Cube_Overlay_Move_Pixel(layer, 4, 0, layer, 5, 0);
Cube_Overlay_Move_Pixel(layer, 3, 0, layer, 4, 0);
Cube_Overlay_Move_Pixel(layer, 2, 0, layer, 3, 0);
Cube_Overlay_Move_Pixel(layer, 1, 0, layer, 2, 0);
Cube_Overlay_Set_Pixel(layer, 1, 0, origin_R, origin_G, origin_B);
break;
case 1:
// Rotate second to outermost layer
Cube_Overlay_Get_Pixel(layer, 1, 1, &origin_R, &origin_G, &origin_B);
Cube_Overlay_Move_Pixel(layer, 1, 2, layer, 1, 1);
Cube_Overlay_Move_Pixel(layer, 1, 3, layer, 1, 2);
Cube_Overlay_Move_Pixel(layer, 1, 4, layer, 1, 3);
Cube_Overlay_Move_Pixel(layer, 1, 5, layer, 1, 4);
Cube_Overlay_Move_Pixel(layer, 1, 6, layer, 1, 5);
Cube_Overlay_Move_Pixel(layer, 2, 6, layer, 1, 6);
Cube_Overlay_Move_Pixel(layer, 3, 6, layer, 2, 6);
Cube_Overlay_Move_Pixel(layer, 4, 6, layer, 3, 6);
Cube_Overlay_Move_Pixel(layer, 5, 6, layer, 4, 6);
Cube_Overlay_Move_Pixel(layer, 6, 6, layer, 5, 6);
Cube_Overlay_Move_Pixel(layer, 6, 5, layer, 6, 6);
Cube_Overlay_Move_Pixel(layer, 6, 4, layer, 6, 5);
Cube_Overlay_Move_Pixel(layer, 6, 3, layer, 6, 4);
Cube_Overlay_Move_Pixel(layer, 6, 2, layer, 6, 3);
Cube_Overlay_Move_Pixel(layer, 6, 1, layer, 6, 2);
Cube_Overlay_Move_Pixel(layer, 5, 1, layer, 6, 1);
Cube_Overlay_Move_Pixel(layer, 4, 1, layer, 5, 1);
Cube_Overlay_Move_Pixel(layer, 3, 1, layer, 4, 1);
Cube_Overlay_Move_Pixel(layer, 2, 1, layer, 3, 1);
Cube_Overlay_Set_Pixel(layer, 2, 1, origin_R, origin_G, origin_B);
break;
case 2:
// Rotate second to innermost layer
Cube_Overlay_Get_Pixel(layer, 2, 2, &origin_R, &origin_G, &origin_B);
Cube_Overlay_Move_Pixel(layer, 2, 3, layer, 2, 2);
Cube_Overlay_Move_Pixel(layer, 2, 4, layer, 2, 3);
Cube_Overlay_Move_Pixel(layer, 2, 5, layer, 2, 4);
Cube_Overlay_Move_Pixel(layer, 3, 5, layer, 2, 5);
Cube_Overlay_Move_Pixel(layer, 4, 5, layer, 3, 5);
Cube_Overlay_Move_Pixel(layer, 5, 5, layer, 4, 5);
Cube_Overlay_Move_Pixel(layer, 5, 4, layer, 5, 5);
Cube_Overlay_Move_Pixel(layer, 5, 3, layer, 5, 4);
Cube_Overlay_Move_Pixel(layer, 5, 2, layer, 5, 3);
Cube_Overlay_Move_Pixel(layer, 4, 2, layer, 5, 2);
Cube_Overlay_Move_Pixel(layer, 3, 2, layer, 4, 2);
Cube_Overlay_Set_Pixel(layer, 3, 2, origin_R, origin_G, origin_B);
break;
case 3:
// Rotate innermost layer
Cube_Overlay_Get_Pixel(layer, 3, 3, &origin_R, &origin_G, &origin_B);
Cube_Overlay_Move_Pixel(layer, 3, 4, layer, 3, 3);
Cube_Overlay_Move_Pixel(layer, 4, 4, layer, 3, 4);
Cube_Overlay_Move_Pixel(layer, 4, 3, layer, 4, 4);
Cube_Overlay_Set_Pixel(layer, 4, 3, origin_R, origin_G, origin_B);
break;
}
} else {
switch(shell) {
case 0:
// Rotate outermost layer
Cube_Overlay_Get_Pixel(layer, 0, 0, &origin_R, &origin_G, &origin_B);
Cube_Overlay_Move_Pixel(layer, 1, 0, layer, 0, 0);
Cube_Overlay_Move_Pixel(layer, 2, 0, layer, 1, 0);
Cube_Overlay_Move_Pixel(layer, 3, 0, layer, 2, 0);
Cube_Overlay_Move_Pixel(layer, 4, 0, layer, 3, 0);
Cube_Overlay_Move_Pixel(layer, 5, 0, layer, 4, 0);
Cube_Overlay_Move_Pixel(layer, 6, 0, layer, 5, 0);
Cube_Overlay_Move_Pixel(layer, 7, 0, layer, 6, 0);
Cube_Overlay_Move_Pixel(layer, 7, 1, layer, 7, 0);
Cube_Overlay_Move_Pixel(layer, 7, 2, layer, 7, 1);
Cube_Overlay_Move_Pixel(layer, 7, 3, layer, 7, 2);
Cube_Overlay_Move_Pixel(layer, 7, 4, layer, 7, 3);
Cube_Overlay_Move_Pixel(layer, 7, 5, layer, 7, 4);
Cube_Overlay_Move_Pixel(layer, 7, 6, layer, 7, 5);
Cube_Overlay_Move_Pixel(layer, 7, 7, layer, 7, 6);
Cube_Overlay_Move_Pixel(layer, 6, 7, layer, 7, 7);
Cube_Overlay_Move_Pixel(layer, 5, 7, layer, 6, 7);
Cube_Overlay_Move_Pixel(layer, 4, 7, layer, 5, 7);
Cube_Overlay_Move_Pixel(layer, 3, 7, layer, 4, 7);
Cube_Overlay_Move_Pixel(layer, 2, 7, layer, 3, 7);
Cube_Overlay_Move_Pixel(layer, 1, 7, layer, 2, 7);
Cube_Overlay_Move_Pixel(layer, 0, 7, layer, 1, 7);
Cube_Overlay_Move_Pixel(layer, 0, 6, layer, 0, 7);
Cube_Overlay_Move_Pixel(layer, 0, 5, layer, 0, 6);
Cube_Overlay_Move_Pixel(layer, 0, 4, layer, 0, 5);
Cube_Overlay_Move_Pixel(layer, 0, 3, layer, 0, 4);
Cube_Overlay_Move_Pixel(layer, 0, 2, layer, 0, 3);
Cube_Overlay_Move_Pixel(layer, 0, 1, layer, 0, 2);
Cube_Overlay_Set_Pixel(layer, 0, 1, origin_R, origin_G, origin_B);
break;
case 1:
// Rotate second to outermost layer
Cube_Overlay_Get_Pixel(layer, 1, 1, &origin_R, &origin_G, &origin_B);
Cube_Overlay_Move_Pixel(layer, 2, 1, layer, 1, 1);
Cube_Overlay_Move_Pixel(layer, 3, 1, layer, 2, 1);
Cube_Overlay_Move_Pixel(layer, 4, 1, layer, 3, 1);
Cube_Overlay_Move_Pixel(layer, 5, 1, layer, 4, 1);
Cube_Overlay_Move_Pixel(layer, 6, 1, layer, 5, 1);
Cube_Overlay_Move_Pixel(layer, 6, 2, layer, 6, 1);
Cube_Overlay_Move_Pixel(layer, 6, 3, layer, 6, 2);
Cube_Overlay_Move_Pixel(layer, 6, 4, layer, 6, 3);
Cube_Overlay_Move_Pixel(layer, 6, 5, layer, 6, 4);
Cube_Overlay_Move_Pixel(layer, 6, 6, layer, 6, 5);
Cube_Overlay_Move_Pixel(layer, 5, 6, layer, 6, 6);
Cube_Overlay_Move_Pixel(layer, 4, 6, layer, 5, 6);
Cube_Overlay_Move_Pixel(layer, 3, 6, layer, 4, 6);
Cube_Overlay_Move_Pixel(layer, 2, 6, layer, 3, 6);
Cube_Overlay_Move_Pixel(layer, 1, 6, layer, 2, 6);
Cube_Overlay_Move_Pixel(layer, 1, 5, layer, 1, 6);
Cube_Overlay_Move_Pixel(layer, 1, 4, layer, 1, 5);
Cube_Overlay_Move_Pixel(layer, 1, 3, layer, 1, 4);
Cube_Overlay_Move_Pixel(layer, 1, 2, layer, 1, 3);
Cube_Overlay_Set_Pixel(layer, 1, 2, origin_R, origin_G, origin_B);
break;
case 2:
// Rotate second to innermost layer
Cube_Overlay_Get_Pixel(layer, 2, 2, &origin_R, &origin_G, &origin_B);
Cube_Overlay_Move_Pixel(layer, 3, 2, layer, 2, 2);
Cube_Overlay_Move_Pixel(layer, 4, 2, layer, 3, 2);
Cube_Overlay_Move_Pixel(layer, 5, 2, layer, 4, 2);
Cube_Overlay_Move_Pixel(layer, 5, 3, layer, 5, 2);
Cube_Overlay_Move_Pixel(layer, 5, 4, layer, 5, 3);
Cube_Overlay_Move_Pixel(layer, 5, 5, layer, 5, 4);
Cube_Overlay_Move_Pixel(layer, 4, 5, layer, 5, 5);
Cube_Overlay_Move_Pixel(layer, 3, 5, layer, 4, 5);
Cube_Overlay_Move_Pixel(layer, 2, 5, layer, 3, 5);
Cube_Overlay_Move_Pixel(layer, 2, 4, layer, 2, 5);
Cube_Overlay_Move_Pixel(layer, 2, 3, layer, 2, 4);
Cube_Overlay_Set_Pixel(layer, 2, 3, origin_R, origin_G, origin_B);
break;
case 3:
// Rotate innermost layer
Cube_Overlay_Get_Pixel(layer, 3, 3, &origin_R, &origin_G, &origin_B);
Cube_Overlay_Move_Pixel(layer, 4, 3, layer, 3, 3);
Cube_Overlay_Move_Pixel(layer, 4, 4, layer, 4, 3);
Cube_Overlay_Move_Pixel(layer, 3, 4, layer, 4, 4);
Cube_Overlay_Set_Pixel(layer, 3, 4, origin_R, origin_G, origin_B);
break;
}
}
}
}
 
 
void Cube_Text_Init(char *string, char length, int R, int G, int B) {
// Ensure that the length of the string does not exceed the storage buffer
if (length > CUBE_STRING_MAX_LENGTH) length = CUBE_STRING_MAX_LENGTH;
 
// Copy the passed data into the buffer
int i;
for (i = 0; i < length; i++)
cube_data_ptr->string[i] = string[i];
cube_data_ptr->string_length = length;
cube_data_ptr->string_index = 0;
cube_data_ptr->string_line = 0;
cube_data_ptr->string_R = R;
cube_data_ptr->string_G = G;
cube_data_ptr->string_B = B;
}
 
void Cube_Text_Interrupt(void) {
int layer, line;
 
// Rotate before drawing the new line at (0,0)
Cube_Overlay_Rotate_Shell(0, 0);
 
// Get the next vertical line of the character currently being drawn
if (cube_data_ptr->string_line == 5) {
line = 0x0; // Leave a space between characters
} else {
line = font[(cube_data_ptr->string[cube_data_ptr->string_index] * 5)
+ cube_data_ptr->string_line];
}
 
// Draw the line onto (0,0) using the specified color
for (layer = 7; layer >= 0; layer--) {
if (line & 0x1) {
Cube_Overlay_Set_Pixel(layer, 0, 0, cube_data_ptr->string_R,
cube_data_ptr->string_G, cube_data_ptr->string_B);
} else {
Cube_Overlay_Set_Pixel(layer, 0, 0, 0x00, 0x00, 0x00);
}
line >>= 1;
}
 
// Increment the vertical line and the character as needed
if (cube_data_ptr->string_line == 5) {
cube_data_ptr->string_line = 0;
if (cube_data_ptr->string_index == cube_data_ptr->string_length-1) {
cube_data_ptr->string_index = 0;
} else {
cube_data_ptr->string_index += 1;
}
} else {
cube_data_ptr->string_line += 1;
}
}