Subversion Repositories Code-Repo

#include "defines.h"
#include "ANIMATIONS.h"
#include "CUBE.h"

void Animation_Solid_Colors(int iterations, int delay_ms) {
    int i;
    for (i = 0; i < iterations; i++) {
        Cube_Set_All(RED);
        Delay_MS(delay_ms);
        Cube_Set_All(GREEN);
        Delay_MS(delay_ms);
        Cube_Set_All(BLUE);
        Delay_MS(delay_ms);
    }
}

void Animation_Layer_Alternate(int iterations, int delay_ms) {
    int i,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            if (i % 3 == 0)
                Cube_Set_Layer(i,RED);
            else if (i % 3 == 1)
                Cube_Set_Layer(i,GREEN);
            else
                Cube_Set_Layer(i,BLUE);
        }
        Delay_MS(delay_ms);
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            if (i % 3 == 0)
                Cube_Set_Layer(i,GREEN);
            else if (i % 3 == 1)
                Cube_Set_Layer(i,BLUE);
            else
                Cube_Set_Layer(i,RED);
        }
        Delay_MS(delay_ms);
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            if (i % 3 == 0)
                Cube_Set_Layer(i,BLUE);
            else if (i % 3 == 1)
                Cube_Set_Layer(i,RED);
            else
                Cube_Set_Layer(i,GREEN);
        }
        Delay_MS(delay_ms);
    }
}

void Animation_Pixel_Alternate(int iterations, int delay_ms) {
    int i,j,k,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            Cube_Clear();
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    int var = (j * 8) + k;
                    if (var % 3 == 0)
                        Cube_Set_Pixel(i,j,k,RED);
                    else if (var % 3 == 1)
                        Cube_Set_Pixel(i,j,k,GREEN);
                    else
                        Cube_Set_Pixel(i,j,k,BLUE);
                }
            }
            Delay_MS(delay_ms);
            Cube_Clear();
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    int var = (j * 8) + k;
                    if (var % 3 == 0)
                        Cube_Set_Pixel(i,j,k,GREEN);
                    else if (var % 3 == 1)
                        Cube_Set_Pixel(i,j,k,BLUE);
                    else
                        Cube_Set_Pixel(i,j,k,RED);
                }
            }
            Delay_MS(delay_ms);
            Cube_Clear();
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    int var = (j * 8) + k;
                    if (var % 3 == 0)
                        Cube_Set_Pixel(i,j,k,BLUE);
                    else if (var % 3 == 1)
                        Cube_Set_Pixel(i,j,k,RED);
                    else
                        Cube_Set_Pixel(i,j,k,GREEN);
                }
            }
            Delay_MS(delay_ms);
        }
    }
}

void Animation_Full_Color_Sweep(int iterations, int delay_us) {
    int i,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < 0x0FF; i+=2) {
            Cube_Set_All(i,0,0);
            Delay_US(delay_us);
        }
        for (i = 0; i < 0x0FF; i+=2) {
            Cube_Set_All(0x0FF,i,0);
            Delay_US(delay_us);
        }
        for (i = 0x0FF; i >= 0; i-=2) {
            Cube_Set_All(i,0x0FF,0);
            Delay_US(delay_us);
        }
        for (i = 0; i < 0x0FF; i+=2) {
            Cube_Set_All(0,0x0FF,i);
            Delay_US(delay_us);
        }
        for (i = 0; i < 0x0FF; i+=2) {
            Cube_Set_All(i,0x0FF,0x0FF);
            Delay_US(delay_us);
        }
        for (i = 0x0FF; i >= 0; i-=2) {
            Cube_Set_All(0x0FF,i,0x0FF);
            Delay_US(delay_us);
        }
        for (i = 0x0FF; i >= 0; i-=2) {
            Cube_Set_All(i,0,0x0FF);
            Delay_US(delay_us);
        }
        for (i = 0x100; i >= 0; i-=2) {
            Cube_Set_All(0,0,i);
            Delay_US(delay_us);
        }
    }
}

void Animation_Row_Column_Sweep(int iterations, int delay_ms) {
    int i,j,k,a,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < 3; i++) {
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                Cube_Clear();
                for (k = 0; k < CUBE_COLUMN_COUNT; k++)
                    if (i % 3 == 0)
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
                            Cube_Set_Pixel(a,j,k,RED);
                    else if (i % 3 == 1)
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
                            Cube_Set_Pixel(a,j,k,GREEN);
                    else
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
                            Cube_Set_Pixel(a,j,k,BLUE);
                Delay_MS(delay_ms);
            }
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                Cube_Clear();
                for (k = 0; k < CUBE_COLUMN_COUNT; k++)
                    if (i % 3 == 0)
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
                            Cube_Set_Pixel(a,k,j,RED);
                    else if (i % 3 == 1)
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
                            Cube_Set_Pixel(a,k,j,GREEN);
                    else
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
                            Cube_Set_Pixel(a,k,j,BLUE);
                Delay_MS(delay_ms);
            }
            for (j = CUBE_LAYER_COUNT-1; j >= 0; j--) {
                Cube_Clear();
                if (i % 3 == 0) {
                    for (k = 0; k < CUBE_LAYER_COUNT; k++)
                        if (k == j)
                            Cube_Set_Layer(k,RED);
                } else if (i % 3 == 1) {
                    for (k = 0; k < CUBE_LAYER_COUNT; k++)
                        if (k == j)
                            Cube_Set_Layer(k,GREEN);
                } else {
                    for (k = 0; k < CUBE_LAYER_COUNT; k++)
                        if (k == j)
                            Cube_Set_Layer(k,BLUE);
                }
                Delay_MS(delay_ms);
            }
        }
    }
}

void Animation_Pixel_Sweep(int iterations, int delay_ms) {
    int i,j,k,z,a;
    for (z = 0; z < iterations; z++) {
        for (a = 0; a < 3; a++) {
            for (i = 0; i < CUBE_LAYER_COUNT; i++) {
                for (j = 0; j < CUBE_ROW_COUNT; j++) {
                    for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                        Cube_Clear();
                        if (a % 3 == 0) {
                            Cube_Set_Pixel(i,j,k,RED);
                        } else if (a % 3 == 1) {
                            Cube_Set_Pixel(i,j,k,GREEN);
                        } else {
                            Cube_Set_Pixel(i,j,k,BLUE);
                        }
                        Delay_MS(delay_ms);
                    }
                }
            }
        }
    }
}

void Animation_Pseudo_Random_Colors(int iterations, int delay_ms) {
    int i,j,k,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    unsigned int a = rand();
                    if (a % 5 == 0)
                        Cube_Set_Pixel(i,j,k,RED);
                    else if (a % 5 == 1)
                        Cube_Set_Pixel(i,j,k,GREEN);
                    else if (a % 5 == 2)
                        Cube_Set_Pixel(i,j,k,BLUE);
                    else if (a % 5 == 3)
                        Cube_Set_Pixel(i,j,k,PURPLE);
                    else if (a % 5 == 4)
                        Cube_Set_Pixel(i,j,k,YELLOW);
                    else
                        Cube_Set_Pixel(i,j,k,ORANGE);
                }
            }
        }
        Delay_MS(delay_ms);
    }
}

void Animation_Random_Colors(int iterations, int delay_ms) {
    int i,j,k,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    Cube_Set_Pixel(i,j,k,rand()&0x0FF,rand()&0x0FF,rand()&0x0FF);
                }
            }
        }
        Delay_MS(delay_ms);
    }
}

void Animation_Cube_In_Cube(int iterations, int delay_ms) {
    int z,x,i,j,k;
    for (z = 0; z < iterations; z++) {
        for (x = 0; x < 5; x++) {
            Cube_Clear();
            for (i = 0; i < CUBE_LAYER_COUNT; i++) {
                if ((x == 0 || x == 4)&&(i == 0 || i == 7)) {
                    Cube_Set_Layer(i,RED);
                } else if ((x == 1 || x == 4)&&(i == 1 || i == 6)) {
                    for (j = 1; j < CUBE_ROW_COUNT-1; j++)
                        for (k = 1; k < CUBE_COLUMN_COUNT-1; k++)
                            Cube_Set_Pixel(i,j,k,YELLOW);
                } else if ((x == 2 || x == 4)&&(i == 2 || i == 5)) {
                    for (j = 2; j < CUBE_ROW_COUNT-2; j++)
                        for (k = 2; k < CUBE_COLUMN_COUNT-2; k++)
                            Cube_Set_Pixel(i,j,k,GREEN);
                } else if ((x == 3 || x == 4)&&(i == 3 || i == 4)) {
                    for (j = 3; j < CUBE_ROW_COUNT-3; j++)
                        for (k = 3; k < CUBE_COLUMN_COUNT-3; k++)
                            Cube_Set_Pixel(i,j,k,BLUE);
                }

                if ((x == 0 || x == 4)&&(i > 0 && i < 8)) {
                    for (j = 0; j < 8; j++) {
                        Cube_Set_Pixel(i,j,0,RED);
                        Cube_Set_Pixel(i,j,7,RED);
                        Cube_Set_Pixel(i,0,j,RED);
                        Cube_Set_Pixel(i,7,j,RED);
                    }
                }
                if ((x == 1 || x == 4)&&(i > 1 && i < 7)) {
                    for (j = 1; j < 7; j++) {
                        Cube_Set_Pixel(i,j,1,YELLOW);
                        Cube_Set_Pixel(i,j,6,YELLOW);
                        Cube_Set_Pixel(i,1,j,YELLOW);
                        Cube_Set_Pixel(i,6,j,YELLOW);
                    }
                }
                if ((x == 2 || x == 4)&&(i > 2 && i < 6)) {
                    for (j = 2; j < 6; j++) {
                        Cube_Set_Pixel(i,j,2,GREEN);
                        Cube_Set_Pixel(i,j,5,GREEN);
                        Cube_Set_Pixel(i,2,j,GREEN);
                        Cube_Set_Pixel(i,5,j,GREEN);
                    }
                }
            }
            Delay_MS(delay_ms);
        }
    }
}

void Animation_Double_Rotation(int iterations, int delay_ms) {
    Cube_Clear();
    int i,x,y,z;
    for (z = 0; z < 3; z++) {
        switch (z % 3) {
            case 0:
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
                    Cube_Set_Pixel(y,0,0,RED);
                    Cube_Set_Pixel(y,1,1,RED);
                    Cube_Set_Pixel(y,2,2,RED);
                    Cube_Set_Pixel(y,3,3,RED);
                    Cube_Set_Pixel(y,4,4,RED);
                    Cube_Set_Pixel(y,5,5,RED);
                    Cube_Set_Pixel(y,6,6,RED);
                    Cube_Set_Pixel(y,7,7,RED);
                }
                break;
            case 1:
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
                    Cube_Set_Pixel(y,0,0,GREEN);
                    Cube_Set_Pixel(y,1,1,GREEN);
                    Cube_Set_Pixel(y,2,2,GREEN);
                    Cube_Set_Pixel(y,3,3,GREEN);
                    Cube_Set_Pixel(y,4,4,GREEN);
                    Cube_Set_Pixel(y,5,5,GREEN);
                    Cube_Set_Pixel(y,6,6,GREEN);
                    Cube_Set_Pixel(y,7,7,GREEN);
                }
                break;
            case 2:
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
                    Cube_Set_Pixel(y,0,0,BLUE);
                    Cube_Set_Pixel(y,1,1,BLUE);
                    Cube_Set_Pixel(y,2,2,BLUE);
                    Cube_Set_Pixel(y,3,3,BLUE);
                    Cube_Set_Pixel(y,4,4,BLUE);
                    Cube_Set_Pixel(y,5,5,BLUE);
                    Cube_Set_Pixel(y,6,6,BLUE);
                    Cube_Set_Pixel(y,7,7,BLUE);
                }
                break;
        }

        for (i = 0; i < iterations; i++) {
            for (x = 0; x < 28; x++) {
                Delay_MS(delay_ms);
                Cube_Rotate(0);
            }
        }
    }
}