Rainbow

rainbow.h

#ifndef RAINBOW_H
#define RAINBOW_H

#include "ultra64/ultratypes.h"
#include "libc/stdbool.h"
#include "libc/stddef.h"
#include "color.h"

typedef enum ColorState {
    STATE_RED_TO_YELLOW,
    STATE_YELLOW_TO_GREEN,
    STATE_GREEN_TO_LIGHTBLUE,
    STATE_LIGHTBLUE_TO_BLUE,
    STATE_BLUE_TO_PINK,
    STATE_PINK_TO_RED,
    STATE_MAX
} ColorState;

typedef struct RainbowTarget {
    u8 state;
    Color_RGB8 color;
} RainbowTarget;

typedef struct Rainbow {
    Color_RGB8 color;
    u8 state;
    u8 speed;
    bool allowDebug;
} Rainbow;

void Rainbow_Debug(Rainbow* this);
void Rainbow_InitColor(Rainbow* this);
void Rainbow_Init(Rainbow* this);
bool Rainbow_CheckColor(Rainbow* this, Color_RGB8 rgb);
void Rainbow_UpdateColor(Rainbow* this);
void Rainbow_UpdateState(Rainbow* this, RainbowTarget target);
void Rainbow_Update(Rainbow* this);

void osSyncPrintf(const char* fmt, ...);

#endif

z_rainbow.c

#include "rainbow.h"


static RainbowTarget sRainbowTarget[STATE_MAX] = {
    { STATE_YELLOW_TO_GREEN, { 255, 255, 0 } },
    { STATE_GREEN_TO_LIGHTBLUE, { 0, 255, 0 } },
    { STATE_LIGHTBLUE_TO_BLUE, { 0, 255, 255 } },
    { STATE_BLUE_TO_PINK, { 0, 0, 255 } },
    { STATE_PINK_TO_RED, { 255, 0, 255 } },
    { STATE_RED_TO_YELLOW, { 255, 0, 0 } },
};

void Rainbow_Debug(Rainbow* this) {
    osSyncPrintf(
        "state: %d, r: %d, g: %d, b: %d, speed: %d, sRainbowTarget.state: %d\n",
        this->state, this->color.r, this->color.g, this->color.b, this->speed, sRainbowTarget[this->state].state
    );
}

void Rainbow_InitColor(Rainbow* this) {
    this->color = sRainbowTarget[this->state].color;
}

void Rainbow_Init(Rainbow* this) {
    this->state = STATE_RED_TO_YELLOW;
    this->speed = 8;
    this->allowDebug = false;
    Rainbow_InitColor(this);
}

bool Rainbow_CheckColor(Rainbow* this, Color_RGB8 rgb) {
    return ((this->color.r == rgb.r) && (this->color.g == rgb.g) && (this->color.b == rgb.b));
}

void Rainbow_UpdateColor(Rainbow* this) {
    u8* channel = NULL;

    switch (this->state) {
        case STATE_YELLOW_TO_GREEN:
        case STATE_BLUE_TO_PINK:
            channel = &this->color.r;
            break;
        case STATE_RED_TO_YELLOW:
        case STATE_LIGHTBLUE_TO_BLUE:
            channel = &this->color.g;
            break;
        case STATE_GREEN_TO_LIGHTBLUE:
        case STATE_PINK_TO_RED:
            channel = &this->color.b;
            break;
    }

    if (channel != NULL) {
        s16 newValue = (s16)(!(this->state % 2) ? (*channel + this->speed) : (*channel - this->speed));
        *channel = (u8)(newValue > 255 ? 255 : newValue < 0 ? 0 : newValue);
    }
}

void Rainbow_UpdateState(Rainbow* this, RainbowTarget target) {
    if (Rainbow_CheckColor(this, target.color)) {
        this->state = target.state;
    }
}

void Rainbow_Update(Rainbow* this) {
    Rainbow_UpdateColor(this);
    Rainbow_UpdateState(this, sRainbowTarget[this->state]);

    if (this->allowDebug) {
        Rainbow_Debug(this);
    }
}