/*
=============
Reset
=============
All variables that are not held over a GLFont::Draw() call are reset here.
*/
void GLFont::Reset(void)
{
bold = 0;
italic = 0;
gradient = 0;
shadow = 0;
region = 0;
regionDims[0] = regionDims[1] = regionDims[2] = regionDims[3] = 0;
ColorCopy(colorForGrnd, white, 4);
ColorCopy(colorGrad, gray, 4);
ColorCopy(colorShadow, gray, 4);
}
/*
=============
ParseColor
=============
Parses a color out of the string. It is very picky, one problem and
everything is considered wrong. Scans (int int int) and (int int int int).
*/
GLboolean GLFont::ParseColor(GLubyte *clr, char **where, GLint num)
{
GLubyte temp[4] = {0, 0, 0, 255};
if (!*++(*where) || *(*where)++ != '(')
return 0;
if (!**where)
return 0;
for (int i = 0; i < num - 1; i++)
{
temp[i] = Utility::Clamp(Utility::LineReadInt(where), 0, 255);
if (!**where || *(*where)++ != ' ')
return 0;
}
temp[num - 1] = Utility::Clamp(Utility::LineReadInt(where), 0, 255);
if (**where && **where == ')')
{
ColorCopy(clr, temp, 4);
return 1;
}
return 0;
}
/*
=============
WalkString
=============
Walks the passed string and either renders or changes some font state based
on what it encounters. Makes sure that failed formatters don't break anything.
*/
void GLFont::WalkString(GLint xpos, GLint ypos, char *string)
{
GLint px = region ? regionDims[0] : xpos;
GLint py = region ? regionDims[1] - (coord.up * size) : ypos;
for (char *where = string; *where; where++)
{
if (region)
{
// ugly mess
if ((coord.right > 0 && (px + size) > (regionDims[0] + regionDims[2]))
|| (coord.right < 0 && (px - size) < (regionDims[0] - regionDims[2])))
{
py -= (size * coord.up);
px = regionDims[0];
}
if (coord.up < 0 && py > (regionDims[1] + regionDims[3]) ||
coord.up > 0 && py < (regionDims[1] - regionDims[3]))
break;
}
if (*where == '\t')
px += (size * fontTabSize);
else if (*where == '\n')
{
py -= (coord.up * size);
px = region ? regionDims[0] : xpos;
}
else if (*where == '\\')
{
GLubyte clr[4];
GLint format = FormatCheck(&where, clr);
if (!format)
{
ProcessChar(px, py, *where);
px += (coord.right * size);
}
else if (format == formatBoldOn)
bold = 1;
else if (format == formatBoldOff)
bold = 0;
else if (format == formatItalicOn)
italic = 1;
else if (format == formatItalicOff)
italic = 0;
else if (format == formatColor || format == formatColorA)
ColorCopy(colorForGrnd, clr, 4);
}
else
{
ProcessChar(px, py, *where);
px += (coord.right * size);
}
}
}
text_t::text_t()
{
ColorCopy(fgColor, white);
ColorCopy(gdColor, gray);
ColorCopy(bgColor, gray);
size = 12;
shadow = 0;
gradient = 0;
italic = 0;
bold = 0;
region = 0;;
regionX = 0;
regionY = 0;
regionW = 0;
regionH = 0;
tIncX = 0.0f;
tIncY = 0.0f;
blockRow = fontBlockRow;
blockCol = fontBlockCol;
texId = 0;
/* Interspacing */
gap = 0;
}
void ResetWithColor(struct Color* color)
{
if (activeEffect == 0xFF)
{
activeEffect = 0xFF - 1;
}
else
{
activeEffect = 0xFF;
}
ColorCopy(color, &resetColor);
lastPatternSelect = chVTGetSystemTime();
}
Font::Font(void)
{
fontTabSpace = 4;
fontITOF = 1.f/255.f; // 1/255 -> used for color
fontItalic = 8;
ColorCopy(fgColor, white);
ColorCopy(gdColor, gray);
ColorCopy(gdColor, gray);
ysize = 12;
shadow = 0;
gradient = 0;
italic = 0;
bold = 0;
texId = 0;
tHeight = 1;
height = 12;
ratio = 1.f;
SetScale(1.f);
memset(tWidth, 0, 256*sizeof(float));
memset(width, 0, 256*sizeof(int));
}
/*===========================================================================*/
static void SetRandomColor(struct Color* color, struct EffectFallingPixelsCfg* cfg)
{
ColorCopy(&cfg->color, color);
if (cfg->randomRed == true)
{
color->R = rand() % 256;
}
if (cfg->randomGreen == true)
{
color->G = rand() % 256;
}
if (cfg->randomBlue == true)
{
color->B = rand() % 256;
}
}
bool ParticleSystem::Create(SceneNode *pParticle,
Color color,
Vector velocity,
Vector accel,
uint count,
bool reduceSize,
bool reduceAlpha,
float maxSize,
float spread,
float minFade,
float maxFade,
float maxLife)
{
if (pParticle && count <= MAX_NUM_PARTICLES)
{
//create particle display list
if (m_particle.Create(pParticle))
{
//initialize color
ColorCopy(m_color, color);
//initialize particle velocity
VectorCopy(m_velocity, velocity);
//initialize acceleration
VectorCopy(m_accel, accel);
//initialize other parameters
m_reduceSize = reduceSize;
m_reduceAlpha = reduceAlpha;
m_maxSize = maxSize;
m_spread = spread;
m_maxLife = maxLife;
m_minFade = minFade;
m_maxFade = maxFade;
//initialize all particles
m_count = count;
Reset(true);
return true;
}
}
return false;
}
void EffectPlasmaUpdate(int16_t x, int16_t y, systime_t time, void* effectcfg, void* effectdata, struct Effect* next, struct DisplayBuffer* display)
{
struct EffectPlasmaCfg* cfg = (struct EffectPlasmaCfg*) effectcfg;
struct EffectPlasmaData* data = (struct EffectPlasmaData*) effectdata;
bool newColors = false;
systime_t diff = time - data->lastspawn;
if (diff >= cfg->spawninterval)
{
newColors = true;
data->lastspawn += cfg->spawninterval;
}
int16_t originX = display->width / 2;
int16_t originY = display->height / 2;
int16_t width;
int16_t height;
for (width = 0; width < display->width; width++)
{
for (height = 0; height < display->height; height++)
{
int16_t pixelNumber = 0;
DisplayCoordToLed(width, height, &pixelNumber, display);
if (newColors == true)
{
float distance = hypot(originX - width, originY - height) * cfg->period1;
uint16_t value = (uint8_t)(128 + (127 * sin(time + distance)));
value += (uint8_t)(128 + (127 * sin((time / 1000) + (height/(3+5*cos(width/11)) ) * cos((time / 1000) + (width/(3+5*sin(height/5)))))));
ColorCopy(&cfg->palette[value / 2], &data->pixelColors[pixelNumber]);
}
DisplayDraw(width, height, &data->pixelColors[pixelNumber], display);
}
}
}
void EffectFallingPixelsUpdate(int16_t x, int16_t y, systime_t time, void* effectcfg, void* effectdata, struct Effect* next, struct DisplayBuffer* display)
{
(void) x;
(void) y;
(void) next;
struct EffectFallingPixelsCfg* cfg = (struct EffectFallingPixelsCfg*) effectcfg;
struct EffectFallingPixelsData* data = (struct EffectFallingPixelsData*) effectdata;
bool newSpawn = false;
systime_t diffSpawn = time - data->lastspawn;
systime_t diffUpdate = time - data->lastupdate;
if (diffSpawn >= cfg->spawninterval)
{
newSpawn = true;
data->lastspawn += cfg->spawninterval;
}
int16_t pixel;
for (pixel = 0; pixel < 30; pixel++)
{
struct EffectFallingPixelHead* pixelHead = &data->pixelHeads[pixel];
if (pixelHead->active == true)
{
pixelHead->time += diffUpdate;
if (pixelHead->time >= pixelHead->speed)
{
pixelHead->time -= pixelHead->speed;
pixelHead->posY += 1;
uint16_t pixelNumber = 0;
if (DisplayCoordToLed(pixelHead->posX, pixelHead->posY, &pixelNumber, display) == true)
{
FadeResetState(cfg->fadeperiod, &data->fadeStates[pixelNumber]);
ColorCopy(&pixelHead->color, &data->pixelColors[pixelNumber]);
}
else
{
pixelHead->active = false;
}
}
}
else if (newSpawn == true)
{
//spawn a new head
pixelHead->active = true;
pixelHead->posX = rand() % display->width;
pixelHead->posY = 0;
pixelHead->speed = cfg->speed + rand() % cfg->speedVariance;
pixelHead->time = 0;
SetRandomColor(&pixelHead->color, cfg);
uint16_t pixelNumber = 0;
DisplayCoordToLed(pixelHead->posX, pixelHead->posY, &pixelNumber, display);
FadeResetState(cfg->fadeperiod, &data->fadeStates[pixelNumber]);
ColorCopy(&pixelHead->color, &data->pixelColors[pixelNumber]);
newSpawn = false;
}
}
int16_t width;
int16_t height;
for (width = 0; width < display->width; width++)
{
for (height = 0; height < display->height; height++)
{
uint16_t pixelNumber = 0;
DisplayCoordToLed(width, height, &pixelNumber, display);
float fade = FadeUpdateState(diffUpdate, cfg->fadeperiod, &data->fadeStates[pixelNumber]);
ColorScale(&data->pixelColors[pixelNumber], fade);
DisplayDraw(width, height, &data->pixelColors[pixelNumber], display);
}
}
data->lastupdate = time;
}
void Font::GradientColorReset(void)
{
ColorCopy(gdColor, gray);
}
void Font::ShadowColorReset(void)
{
ColorCopy(bgColor, gray);
}
void Font::ForeColorReset(void)
{
ColorCopy(fgColor, white);
}
