223 lines
No EOL
5 KiB
C++
223 lines
No EOL
5 KiB
C++
/*
|
|
* Aurora: https://github.com/pixelmatix/aurora
|
|
* Original Copyright (c) 2014 Jason Coon
|
|
*
|
|
* Modified by Codetastic 2024
|
|
*
|
|
*/
|
|
|
|
#ifndef Patterns_H
|
|
#define Patterns_H
|
|
|
|
#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
|
|
|
|
#include "Vector2.hpp"
|
|
#include "Boid.hpp"
|
|
#include "Attractor.hpp"
|
|
|
|
/*
|
|
* Note from mrfaptastic:
|
|
*
|
|
* Commented out patterns are due to the fact they either didn't work properly with a non-square display,
|
|
* or from my personal opinion, are crap.
|
|
*/
|
|
#include "PatternStarfield.hpp" // new 2024
|
|
#include "PatternAttract.hpp"
|
|
#include "PatternBounce.hpp" // Doesn't seem to work, omitting.
|
|
#include "PatternCube.hpp" // Doesn't seem to work, omitting.
|
|
#include "PatternElectricMandala.hpp"
|
|
#include "PatternFireKoz.hpp" // Doesn't seem to work, omitting.
|
|
#include "PatternFlock.hpp"
|
|
#include "PatternFlowField.hpp"
|
|
#include "PatternIncrementalDrift.hpp"
|
|
#include "PatternIncrementalDrift2.hpp" // Doesn't seem to work, omitting.
|
|
#include "PatternInfinity.hpp"
|
|
#include "PatternMaze.hpp" // ??
|
|
#include "PatternMunch.hpp"
|
|
//#include "PatternNoiseSmearing.hpp"
|
|
#include "PatternPendulumWave.hpp"
|
|
#include "PatternPlasma.hpp"
|
|
#include "PatternRadar.hpp"
|
|
#include "PatternSimplexNoise.hpp"
|
|
#include "PatternSnake.hpp"
|
|
#include "PatternSpiral.hpp"
|
|
#include "PatternSpiro.hpp"
|
|
#include "PatternWave.hpp"
|
|
#include "PatternTheMatrix.hpp"
|
|
#include "PatternJuliaSetFractal.hpp"
|
|
//#include "PatternTunnel.hpp" // fail
|
|
//#include "PatternSphereSpin.hpp" // fail
|
|
|
|
|
|
class Patterns {
|
|
private:
|
|
|
|
PatternStarfield starfield;
|
|
// PatternSphereSpin sspin;
|
|
PatternAttract attract;
|
|
PatternBounce bounce;
|
|
PatternCube cube;
|
|
PatternElectricMandala electricMandala;
|
|
PatternFireKoz fire;
|
|
PatternFlock flock;
|
|
PatternFlowField flowField;
|
|
PatternIncrementalDrift incrementalDrift;
|
|
PatternIncrementalDrift2 incrementalDrift2;
|
|
PatternInfinity infinity;
|
|
PatternMaze maze;
|
|
PatternMunch munch;
|
|
PatternPendulumWave pendwave;
|
|
PatternPlasma plasma;
|
|
PatternRadar radar;
|
|
PatternSimplexNoise simpnoise;
|
|
PatternSnake snake;
|
|
PatternSpiral spiral;
|
|
PatternSpiro spiro;
|
|
PatternWave wave;
|
|
PatternTheMatrix matrix;
|
|
// PatternTunnel tunnel;
|
|
PatternJuliaSet juliaSet;
|
|
|
|
std::vector<Drawable*> availablePatterns = {
|
|
// &tunnel,
|
|
&juliaSet,
|
|
&matrix,
|
|
&starfield,
|
|
// &sspin,
|
|
&attract,
|
|
&bounce,
|
|
&cube,
|
|
&electricMandala,
|
|
&fire,
|
|
&flock,
|
|
&spiro,
|
|
&radar,
|
|
&flowField,
|
|
&incrementalDrift,
|
|
&incrementalDrift2,
|
|
&infinity,
|
|
&maze,
|
|
&munch,
|
|
&pendwave,
|
|
&plasma,
|
|
&radar,
|
|
&simpnoise,
|
|
//&snake, // a bit crap
|
|
//&spiral, // a bit crap
|
|
&spiro,
|
|
&wave,
|
|
};
|
|
|
|
int currentIndex = 0;
|
|
Drawable* currentItem;
|
|
|
|
int getCurrentIndex() {
|
|
return currentIndex;
|
|
}
|
|
|
|
|
|
public:
|
|
Patterns() {
|
|
this->currentItem = availablePatterns[0];
|
|
this->currentItem->start();
|
|
}
|
|
|
|
void stop() {
|
|
if (currentItem)
|
|
currentItem->stop();
|
|
}
|
|
|
|
void start() {
|
|
if (currentItem)
|
|
currentItem->start();
|
|
}
|
|
|
|
void moveTo(int index)
|
|
{
|
|
index = ((index >= availablePatterns.size()) || (index < 0)) ? 0 : index;
|
|
|
|
if (currentItem)
|
|
currentItem->stop();
|
|
|
|
currentIndex = index;
|
|
currentItem = availablePatterns[currentIndex];
|
|
|
|
Serial.print("Changing pattern to: ");
|
|
Serial.println(getCurrentPatternName());
|
|
|
|
if (currentItem)
|
|
currentItem->start();
|
|
|
|
} // index
|
|
|
|
|
|
void move(int step) {
|
|
|
|
currentIndex += step;
|
|
|
|
if (currentIndex >= availablePatterns.size()) currentIndex = 0;
|
|
else if (currentIndex < 0) currentIndex = 0;
|
|
|
|
moveTo(currentIndex);
|
|
}
|
|
|
|
void moveRandom(int step) {
|
|
int rand_index = random(0, availablePatterns.size()-1);
|
|
moveTo(rand_index);
|
|
}
|
|
|
|
unsigned int drawFrame() {
|
|
return currentItem->drawFrame();
|
|
}
|
|
|
|
void listPatterns() {
|
|
Serial.println(F("{"));
|
|
Serial.print(F(" \"count\": "));
|
|
Serial.print(availablePatterns.size());
|
|
Serial.println(",");
|
|
Serial.println(F(" \"results\": ["));
|
|
|
|
for (size_t i = 0; i < availablePatterns.size(); i++) {
|
|
Serial.print(F(" \""));
|
|
Serial.print(i, DEC);
|
|
Serial.print(F(": "));
|
|
Serial.print(availablePatterns[i]->name);
|
|
if (i == availablePatterns.size() - 1)
|
|
Serial.println(F("\""));
|
|
else
|
|
Serial.println(F("\","));
|
|
}
|
|
|
|
Serial.println(" ]");
|
|
Serial.println("}");
|
|
}
|
|
|
|
char * getCurrentPatternName()
|
|
{
|
|
return currentItem->name;
|
|
}
|
|
/*
|
|
bool setPattern(String name) {
|
|
|
|
for (size_t i = 0; i < availablePatterns.size(); i++) {
|
|
if (name.compareTo(availablePatterns[i]->name) == 0) {
|
|
moveTo(i);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
*/
|
|
bool setPattern(int index) {
|
|
if (index >= availablePatterns.size() || index < 0)
|
|
return false;
|
|
|
|
moveTo(index);
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
#endif |