Dunce GLB (2 / 4 stap)

Stap 2: De Code

op basis van kleur fietsen plasma
Versie 0.1 - 8 juli 2009
Copyright (c) 2009 Ben Combee. Alle rechten voorbehouden.
Copyright (c) 2009 Ken Corey. Alle rechten voorbehouden.
Copyright (c) 2008 Windell H. Oskay. Alle rechten voorbehouden.
Copyright (c) 2011 Sam C. Lin alle rechten voorbehouden

Deze demo is vrije software; je kunt het herdistribueren en/of
aanpassen onder de voorwaarden van de GNU Lesser algemene openbare
Licentie zoals gepubliceerd door de Free Software Foundation; beide
versie 2.1 van de licentie, of (naar uw keuze) een latere versie.

In deze demo wordt gedistribueerd in de hoop dat het bruikbaar,
maar zonder enige garantie; zelfs zonder de impliciete garantie van
VERKOOPBAARHEID of geschiktheid voor een bepaald doel. Zie GNU
Lesser General Public License voor meer details.

U moet hebt ontvangen een kopie van de GNU Lesser algemene openbare
License along with this library; Als dit niet het geval is, schrijven aan de Vrije Software
Foundation, Inc., 51 Franklin St, vijfde verdieping, Boston, MA 02110-1301 USA
*/

#include

typedef struct
{
unsigned char r;
unsigned char g;
unsigned char b;
} ColorRGB;

een kleur met 3 componenten: h, s en v
typedef struct
{
unsigned char h;
unsigned char s;
unsigned char v;
} ColorHSV;

unsigned char plasma [ColorduinoScreenWidth] [ColorduinoScreenHeight];
lange paletteShift;

Een HSV-kleuren worden omgezet in RGB-kleur
VOID HSVtoRGB (void * vRGB, nietig * vHSV)
{
float r, g, b, h, s, v; deze functie werkt met drijvers tussen 0 en 1
vlotter f, p, q, t;
int i;
ColorRGB * colorRGB =(ColorRGB *) vRGB;
ColorHSV * colorHSV =(ColorHSV *) vHSV;

h = (float) (colorHSV -> h/256.0);
s = (float) (colorHSV -> s/256.0);
v = (float) (colorHSV -> v/256.0);

Als verzadiging 0 is, is de kleur een schaduw van grijs
if(s == 0.0) {}
b = v;
g = b;
r = g;
}
Als verzadiging > 0, meer complexe berekeningen zijn nodig
anders
{
h * = 6.0; om tint naar een getal tussen 0 en 6, beter voor de berekeningen
Ik = (int)(floor(h)); bijvoorbeeld 2.7 wordt 2 en 3.01 wordt 3 of 4.9999 wordt 4
f = h - ik; de fractionele deel van de //the van h

p = (float) (v * (1.0 - s));
q = (float) (v * (1.0 - (s * f)));
t = (float) (v * (1.0 - (s * (1.0 - f)));

switch(i)
{
geval van 0: r = v; g = t; b = p; breken;
geval 1: r = q; g = v; b = p; breken;
geval 2: r = p; g = v; b = t; breken;
Case 3: r = p; g = q; b = v; breken;
geval 4: r = t; g = p; b = v; breken;
geval 5: r = v; g = p; b = q; breken;
standaard: r = g = b = 0; breken;
}
}
colorRGB -> r = (int)(r * 255.0);
colorRGB -> g = (int)(g * 255.0);
colorRGB -> b = (int)(b * 255.0);
}

float
dist (drijven, zweven b, float c, zweven d).
{
Return sqrt((c-a)*(c-a)+(d-b)*(d-b));
}

ongeldig
plasma_morph()
{
unsigned char x, y;
drijvende-kommawaarde;
ColorRGB colorRGB;
ColorHSV colorHSV;

voor (y = 0; y < ColorduinoScreenHeight; y ++)
voor (x = 0; x < ColorduinoScreenWidth; x ++) {}
{
waarde = zonde (dist (x + paletteShift, y, 128.0, 128.0) / 8.0)
+ sin (dist (x, y, 64,0, 64,0) / 8.0)
+ sin (dist (x, y + paletteShift/7, 192.0, 64) / 7.0)
+ sin (dist (x, y, 192.0, 100.0) / 8.0);
colorHSV.h= (unsigned char)((value) * 128) & 0xff;
colorHSV.s=255;
colorHSV.v=255;
HSVtoRGB (colorRGB, & colorHSV);

Colorduino.SetPixel (x, y, colorRGB.r, colorRGB.g, colorRGB.b);
}
}
paletteShift ++;

Colorduino.FlipPage(); swap scherm buffers te laten zien
}

/********************************************************
Naam: ColorFill
Functie: Het frame vullen met een kleur
Parameter: R: de waarde van rood. Bereik: rood 0 ~ 255
G: de waarde van groen. Bereik: rood 0 ~ 255
B: de waarde van blauw. Bereik: rood 0 ~ 255
********************************************************/
VOID ColorFill (unsigned char R, unsigned char G, unsigned char B)
{
PixelRGB * p = Colorduino.GetPixel(0,0);
voor (unsigned char y = 0; j voor (unsigned char x = 0; x-p-r > = R;
p-g > = G;
p -> b = B;
p ++;
}
}

Colorduino.FlipPage();
}

VOID Setup
{
Colorduino.Init(); initialiseren van de Raad van bestuur

compenseren van relatieve intensiteit verschillen in helderheid van de R/G/B
serie van 6-bits basis waarden voor RGB (0 ~ 63)
whiteBalVal [0] = rood
whiteBalVal [1] = groen
whiteBalVal [2] = blauw
unsigned char whiteBalVal [3] = {36,63,63}; voor LEDSEE ronde 6x6cm matrix
Colorduino.SetWhiteBal(whiteBalVal);

beginnen met morphing plasma, maar toestaan gonna kleur fietsen indien gewenst.
paletteShift = 128000;
unsigned char bcolor;

het plasma eenmaal genereren
voor (unsigned char y = 0; y < ColorduinoScreenHeight; y ++)
voor (unsigned char x = 0; x < ColorduinoScreenWidth; x ++)
{
de plasma-buffer is een som van sines
bcolor = (unsigned char)
(
128.0 + (128.0 * sin (x * 8.0/16.0))
+ 128.0 + (128.0 * sin (y * 8.0/16.0))
) / 2;
Plasma [x] [y] = bcolor;
}

om aan te passen witbalans kunt u deze regel uncomment
en commentaar uit de plasma_morph() in de loop
en vervolgens experimenteren met whiteBalVal hierboven
ColorFill(255,255,255);
}

void loop
{
plasma_morph();
}