Cynopolis/Block-Party-Firmware
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Got the animator fades working

Browse Source
This commit is contained in:
Quinn
2024-08-25 16:11:06 -04:00
parent 240d4866aa
commit 14ac96988a
10 changed files with 164 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/BOARD-DEFINITIONS.h
View File

@@ -20,7 +20,7 @@ static constexpr uint32_t BOARD_WIDTH{3};
static constexpr uint32_t BOARD_LENGTH{3}; static constexpr uint32_t BOARD_LENGTH{3};
static constexpr uint32_t BOARD_HEIGHT{3}; static constexpr uint32_t BOARD_HEIGHT{3};
static constexpr V3D BOARD_DIMENSIONS{BOARD_WIDTH, BOARD_LENGTH, BOARD_HEIGHT}; static constexpr V3D<uint32_t> BOARD_DIMENSIONS{BOARD_WIDTH, BOARD_LENGTH, BOARD_HEIGHT};
// define the number of stacks // define the number of stacks
static constexpr uint32_t NUMBER_STACKS{BOARD_WIDTH * BOARD_LENGTH}; static constexpr uint32_t NUMBER_STACKS{BOARD_WIDTH * BOARD_LENGTH};

32
include/Vector3D.h
View File

@@ -3,17 +3,31 @@
#include <cstdint> #include <cstdint>
#include <cmath> #include <cmath>
template <typename Type>
class V3D{ class V3D{
public: public:
constexpr V3D(const V3D& other): constexpr V3D(const V3D& other):
x(other.x), x(other.x),
y(other.y), y(other.y),
z(other.z){} z(other.z){
static_assert(std::is_arithmetic<Type>::value, "Type must be a number");
}
constexpr V3D(uint32_t x=0, uint32_t y=0, uint32_t z=0): constexpr V3D(Type x=0, Type y=0, Type z=0):
x(x), x(x),
y(y), y(y),
z(z){} z(z){
static_assert(std::is_arithmetic<Type>::value, "Type must be a number");
}
template <typename OtherType>
constexpr V3D(const V3D<OtherType> other):
x(static_cast<Type>(other.x)),
y(static_cast<Type>(other.y)),
z(static_cast<Type>(other.z)){
static_assert(std::is_arithmetic<Type>::value, "Type must be a number");
static_assert(std::is_arithmetic<OtherType>::value, "OtherType must be a number");
}
V3D& operator=(const V3D &other){ V3D& operator=(const V3D &other){
this->x = other.x; this->x = other.x;
@@ -36,7 +50,7 @@ class V3D{
return *this; return *this;
} }
V3D& operator/=(const uint32_t scalar){ V3D& operator/=(const Type scalar){
if(scalar == 0){ if(scalar == 0){
return *this; return *this;
} }
@@ -46,7 +60,7 @@ class V3D{
return *this; return *this;
} }
V3D& operator*=(const uint32_t scalar){ V3D& operator*=(const Type scalar){
this->x *= scalar; this->x *= scalar;
this->y *= scalar; this->y *= scalar;
this->z *= scalar; this->z *= scalar;
@@ -58,9 +72,9 @@ class V3D{
} }
float magnitude(){ float magnitude(){
return std::sqrt(this->x * this->x + this->y * this->y + this->z * this-> z); return std::sqrt(static_cast<float>(this->x * this->x + this->y * this->y + this->z * this->z));
} }
uint32_t x; Type x;
uint32_t y; Type y;
uint32_t z; Type z;
}; };

4
lib/Animator/AnimationTypes.h
View File

@@ -19,8 +19,8 @@ namespace ANIMATION_TYPES{
}; };
struct Cell{ struct Cell{
V3D position; V3D<uint32_t> position;
V3D color; V3D<uint32_t> color;
}; };
// this contains all of the information to specify exactly how a single frame should look and fade to the next frame // this contains all of the information to specify exactly how a single frame should look and fade to the next frame

115
lib/Animator/Animator.h
View File

@@ -13,11 +13,11 @@
using namespace ANIMATION_TYPES; using namespace ANIMATION_TYPES;
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
class Animator{ class Animator{
public: public:
typedef std::array<std::array<std::array<V3D, BOARD_DIMS.z>, BOARD_DIMS.y>, BOARD_DIMS.x> Frame; typedef std::array<std::array<std::array<V3D<uint32_t>, BOARD_DIMS.z>, BOARD_DIMS.y>, BOARD_DIMS.x> Frame;
void StartAnimation(const std::vector<AnimationFrame> *animationSequence); void StartAnimation(const std::vector<AnimationFrame> *animationSequence);
@@ -26,15 +26,13 @@ void RunAnimation(const std::chrono::milliseconds& timePassed);
void SetLoop(bool isLooping); void SetLoop(bool isLooping);
bool HasInterpolatedFrameChanged(){return this->interpolatedFrameHasChanged;}
Frame &GetInterpolatedFrame(){return this->interpolatedFrame;} Frame &GetInterpolatedFrame(){return this->interpolatedFrame;}
bool isEnabled{true}; bool isEnabled{true};
bool interpolatedFrameHasChanged{false};
private: private:
bool isLooping{true}; bool isLooping{true};
bool interpolatedFrameHasChanged{false};
// these are the uncompressed frames you get by following the key colors and interpolation instructions of an animation frame // these are the uncompressed frames you get by following the key colors and interpolation instructions of an animation frame
Frame startFrame; Frame startFrame;
Frame interpolatedFrame; Frame interpolatedFrame;
@@ -52,17 +50,17 @@ void copyFrame(Frame &copyFrom, Frame &copyTo){
std::memcpy(&copyTo, &copyFrom, sizeof(Frame)); std::memcpy(&copyTo, &copyFrom, sizeof(Frame));
} }
V3D getInterpolatedColor(const AnimationFrame &keyFrame, V3D position); V3D<uint32_t> getInterpolatedColor(const AnimationFrame &keyFrame, V3D<uint32_t> position);
V3D keyFrame2BoardCoords(const V3D &keyFramePosition); V3D<uint32_t> keyFrame2BoardCoords(const V3D<uint32_t> &keyFramePosition);
V3D noFillInterpolate(const AnimationFrame &keyFrame, V3D position); V3D<uint32_t> noFillInterpolate(const AnimationFrame &keyFrame, V3D<uint32_t> position);
V3D closestColorInterpolate(const AnimationFrame &keyFrame, V3D position); V3D<uint32_t> closestColorInterpolate(const AnimationFrame &keyFrame, V3D<uint32_t> position);
V3D linearInterpolate(const AnimationFrame &keyFrame, V3D position); V3D<uint32_t> linearInterpolate(const AnimationFrame &keyFrame, V3D<uint32_t> position);
V3D squareInterpolate(const AnimationFrame &keyFrame, V3D position); V3D<uint32_t> squareInterpolate(const AnimationFrame &keyFrame, V3D<uint32_t> position);
void PrintUncompressedFrame(){ void PrintUncompressedFrame(){
for(uint32_t x = 0; x < BOARD_DIMS.x; x++){ for(uint32_t x = 0; x < BOARD_DIMS.x; x++){
@@ -78,7 +76,7 @@ void PrintUncompressedFrame(){
}; };
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Animator<BOARD_DIMS>::StartAnimation(const std::vector<AnimationFrame> *animationSequence){ void Animator<BOARD_DIMS>::StartAnimation(const std::vector<AnimationFrame> *animationSequence){
this->animationSequence = animationSequence; this->animationSequence = animationSequence;
@@ -99,13 +97,13 @@ void Animator<BOARD_DIMS>::StartAnimation(const std::vector<AnimationFrame> *ani
this->copyFrame(this->startFrame, this->interpolatedFrame); this->copyFrame(this->startFrame, this->interpolatedFrame);
this->uncompressFrame((*this->animationSequence)[1], this->endFrame); this->uncompressFrame((*this->animationSequence)[1], this->endFrame);
} }
this->PrintUncompressedFrame(); this->interpolatedFrameHasChanged = true;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Animator<BOARD_DIMS>::RunAnimation(const std::chrono::milliseconds& timePassed){ void Animator<BOARD_DIMS>::RunAnimation(const std::chrono::milliseconds& timePassed){
if(!(this->isEnabled)){ if(!(this->isEnabled)){
this->interpolatedFrameHasChanged = false; return;
} }
auto delayTime = (*this->animationSequence)[this->animationIndex].delay; auto delayTime = (*this->animationSequence)[this->animationIndex].delay;
@@ -118,19 +116,19 @@ void Animator<BOARD_DIMS>::RunAnimation(const std::chrono::milliseconds& timePas
// don't do frame interpolations if we're doing snap fades // don't do frame interpolations if we're doing snap fades
if((*this->animationSequence)[this->animationIndex].frameInterpolation == FrameInterpolation::SNAP){ if((*this->animationSequence)[this->animationIndex].frameInterpolation == FrameInterpolation::SNAP){
this->interpolatedFrameHasChanged = false; return;
} }
// linearly interpolate between the two uncompressed frames // linearly interpolate between the two uncompressed frames
for(uint32_t x = 0; x < BOARD_DIMS.x; x++){ for(uint32_t x = 0; x < BOARD_DIMS.x; x++){
for(uint32_t y = 0; y < BOARD_DIMS.y; y++){ for(uint32_t y = 0; y < BOARD_DIMS.y; y++){
for(uint32_t z = 0; z < BOARD_DIMS.z; z++){ for(uint32_t z = 0; z < BOARD_DIMS.z; z++){
V3D startColor{this->startFrame[x][y][z]}; V3D<float> startColor{this->startFrame[x][y][z]};
V3D endColor{this->endFrame[x][y][z]}; V3D<float> endColor{this->endFrame[x][y][z]};
V3D difference{endColor}; V3D<float> difference{endColor};
difference -= startColor; difference -= startColor;
V3D interpolatedColor{difference}; V3D<float> interpolatedColor{difference};
interpolatedColor *= this->timeElapsed.count(); interpolatedColor *= this->timeElapsed.count();
interpolatedColor /= delayTime.count(); interpolatedColor /= delayTime.count();
interpolatedColor += startColor; interpolatedColor += startColor;
@@ -143,40 +141,40 @@ void Animator<BOARD_DIMS>::RunAnimation(const std::chrono::milliseconds& timePas
this->interpolatedFrameHasChanged = true; this->interpolatedFrameHasChanged = true;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Animator<BOARD_DIMS>::SetLoop(bool isLooping){ void Animator<BOARD_DIMS>::SetLoop(bool isLooping){
this->isLooping = isLooping; this->isLooping = isLooping;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Animator<BOARD_DIMS>::incrimentAnimationIndex(){ void Animator<BOARD_DIMS>::incrimentAnimationIndex(){
if(this->animationIndex < this->animationSequence->size() - 1){ if(this->animationIndex < this->animationSequence->size() - 2){
this->animationIndex++; this->animationIndex++;
this->timeElapsed = std::chrono::milliseconds(0); this->timeElapsed = std::chrono::milliseconds(0);
this->uncompressFrame((*this->animationSequence)[this->animationIndex], this->startFrame); this->uncompressFrame((*this->animationSequence)[this->animationIndex], this->startFrame);
this->copyFrame(this->startFrame, this->interpolatedFrame);
this->uncompressFrame((*this->animationSequence)[this->animationIndex + 1], this->endFrame); this->uncompressFrame((*this->animationSequence)[this->animationIndex + 1], this->endFrame);
} }
else if(isLooping){ else{
this->StartAnimation(this->animationSequence); this->StartAnimation(this->animationSequence);
} }
Serial.println("Animator::incrimentAnimationIndex" + String(animationIndex)); this->interpolatedFrameHasChanged = true;
this->PrintUncompressedFrame();
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Animator<BOARD_DIMS>::uncompressFrame(const AnimationFrame &keyFrame, Frame &frameBuffer){ void Animator<BOARD_DIMS>::uncompressFrame(const AnimationFrame &keyFrame, Frame &frameBuffer){
for(uint32_t x = 0; x < BOARD_DIMS.x; x++){ for(uint32_t x = 0; x < BOARD_DIMS.x; x++){
for(uint32_t y = 0; y < BOARD_DIMS.y; y++){ for(uint32_t y = 0; y < BOARD_DIMS.y; y++){
for(uint32_t z = 0; z < BOARD_DIMS.z; z++){ for(uint32_t z = 0; z < BOARD_DIMS.z; z++){
frameBuffer[x][y][z] = getInterpolatedColor(keyFrame, V3D(x, y, z)); frameBuffer[x][y][z] = getInterpolatedColor(keyFrame, V3D<uint32_t>(x, y, z));
} }
} }
} }
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
V3D Animator<BOARD_DIMS>::getInterpolatedColor(const AnimationFrame &keyFrame, V3D position){ V3D<uint32_t> Animator<BOARD_DIMS>::getInterpolatedColor(const AnimationFrame &keyFrame, V3D<uint32_t> position){
switch(keyFrame.fillInterpolation){ switch(keyFrame.fillInterpolation){
case FillInterpolation::NO_FILL: case FillInterpolation::NO_FILL:
return noFillInterpolate(keyFrame, position); return noFillInterpolate(keyFrame, position);
@@ -187,19 +185,19 @@ V3D Animator<BOARD_DIMS>::getInterpolatedColor(const AnimationFrame &keyFrame, V
case FillInterpolation::SQUARE_WEIGHTED_DISTANCE: case FillInterpolation::SQUARE_WEIGHTED_DISTANCE:
return squareInterpolate(keyFrame, position); return squareInterpolate(keyFrame, position);
default: default:
V3D black{}; V3D<uint32_t> black{};
return black; return black;
} }
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
V3D Animator<BOARD_DIMS>::keyFrame2BoardCoords(const V3D &keyFramePosition){ V3D<uint32_t> Animator<BOARD_DIMS>::keyFrame2BoardCoords(const V3D<uint32_t> &keyFramePosition){
V3D returnValue{}; V3D<uint32_t> returnValue{};
float maxValue{static_cast<float>(std::numeric_limits<uint32_t>::max())}; float maxValue{static_cast<float>(std::numeric_limits<uint32_t>::max())};
// scale the key frame values down to be within board coordinates // scale the key frame values down to be within board coordinates
float keyFrame_X = static_cast<float>(BOARD_DIMS.x) * static_cast<float>(keyFramePosition.x) / maxValue; float keyFrame_X = static_cast<float>(BOARD_DIMS.x - 1) * static_cast<float>(keyFramePosition.x) / maxValue;
float keyFrame_Y = static_cast<float>(BOARD_DIMS.y) * static_cast<float>(keyFramePosition.y) / maxValue; float keyFrame_Y = static_cast<float>(BOARD_DIMS.y - 1) * static_cast<float>(keyFramePosition.y) / maxValue;
float keyFrame_Z = static_cast<float>(BOARD_DIMS.z) * static_cast<float>(keyFramePosition.z) / maxValue; float keyFrame_Z = static_cast<float>(BOARD_DIMS.z - 1) * static_cast<float>(keyFramePosition.z) / maxValue;
// carefully quantize the float values back into ints with a precise rounding operation // carefully quantize the float values back into ints with a precise rounding operation
if(keyFrame_X - std::floor(keyFrame_X) < 0.5f){ if(keyFrame_X - std::floor(keyFrame_X) < 0.5f){
@@ -226,9 +224,9 @@ V3D Animator<BOARD_DIMS>::keyFrame2BoardCoords(const V3D &keyFramePosition){
return returnValue; return returnValue;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
V3D Animator<BOARD_DIMS>::noFillInterpolate(const AnimationFrame &keyFrame, V3D position){ V3D<uint32_t> Animator<BOARD_DIMS>::noFillInterpolate(const AnimationFrame &keyFrame, V3D<uint32_t> position){
V3D returnColor{}; V3D<uint32_t> returnColor{};
for(Cell cell : keyFrame.frame){ for(Cell cell : keyFrame.frame){
if(keyFrame2BoardCoords(cell.position) == position){ if(keyFrame2BoardCoords(cell.position) == position){
returnColor = cell.color; returnColor = cell.color;
@@ -238,34 +236,35 @@ V3D Animator<BOARD_DIMS>::noFillInterpolate(const AnimationFrame &keyFrame, V3D
return returnColor; return returnColor;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
V3D Animator<BOARD_DIMS>::closestColorInterpolate(const AnimationFrame &keyFrame, V3D position){ V3D<uint32_t> Animator<BOARD_DIMS>::closestColorInterpolate(const AnimationFrame &keyFrame, V3D<uint32_t> cubePosition){
V3D returnColor{}; Serial.print("X:" + String(cubePosition.x) + ",Y:" + String(cubePosition.y) + ",Z:" + String(cubePosition.z));
V3D distance{keyFrame.frame[0].position}; V3D<uint32_t> returnColor{keyFrame.frame[0].color};
distance -= position; V3D<uint32_t> distance{keyFrame.frame[0].position};
distance -= cubePosition;
float closestDistance = distance.magnitude(); float closestDistance = distance.magnitude();
for(Cell cell : keyFrame.frame){ for(Cell cell : keyFrame.frame){
distance = keyFrame2BoardCoords(cell.position); distance = keyFrame2BoardCoords(cell.position);
distance -= position; distance -= cubePosition;
float euclidDistance = distance.magnitude(); float euclidDistance = distance.magnitude();
if(euclidDistance < closestDistance){ if(euclidDistance < closestDistance){
returnColor = cell.color; returnColor = cell.color;
closestDistance = euclidDistance; closestDistance = euclidDistance;
} }
} }
return returnColor; return returnColor;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
V3D Animator<BOARD_DIMS>::linearInterpolate(const AnimationFrame &keyFrame, V3D position){ V3D<uint32_t> Animator<BOARD_DIMS>::linearInterpolate(const AnimationFrame &keyFrame, V3D<uint32_t> position){
V3D returnColor{}; V3D<uint32_t> returnColor{};
for(Cell cell : keyFrame.frame){ for(Cell cell : keyFrame.frame){
V3D vectorDistance{keyFrame2BoardCoords(cell.position)}; V3D<uint32_t> vectorDistance{keyFrame2BoardCoords(cell.position)};
vectorDistance -= position; vectorDistance -= position;
uint32_t distance = static_cast<uint32_t>(vectorDistance.magnitude()); float distance = vectorDistance.magnitude();
if(distance == 0) distance = 1; if(distance == 0) return cell.color;
returnColor += cell.color; returnColor += cell.color;
returnColor /= distance; returnColor /= distance;
} }
@@ -275,16 +274,16 @@ V3D Animator<BOARD_DIMS>::linearInterpolate(const AnimationFrame &keyFrame, V3D
return returnColor; return returnColor;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
V3D Animator<BOARD_DIMS>::squareInterpolate(const AnimationFrame &keyFrame, V3D position){ V3D<uint32_t> Animator<BOARD_DIMS>::squareInterpolate(const AnimationFrame &keyFrame, V3D<uint32_t> position){
V3D returnColor{}; V3D<uint32_t> returnColor{};
for(Cell cell : keyFrame.frame){ for(Cell cell : keyFrame.frame){
V3D vectorDistance{keyFrame2BoardCoords(cell.position)}; V3D<uint32_t> vectorDistance{keyFrame2BoardCoords(cell.position)};
vectorDistance -= position; vectorDistance -= position;
uint32_t distance = static_cast<uint32_t>(vectorDistance.magnitude()); uint32_t distance = static_cast<uint32_t>(vectorDistance.magnitude());
distance *= distance; distance *= distance;
if(distance == 0) distance = 1; if(distance == 0) return cell.color;
returnColor += cell.color; returnColor += cell.color;
returnColor /= distance; returnColor /= distance;
} }

36
lib/Animator/TestFrames.h
View File

@@ -8,15 +8,15 @@ using namespace ANIMATION_TYPES;
namespace TestFrames{ namespace TestFrames{
V3D red{255,0,0}; V3D<uint32_t> red{255,0,0};
V3D green{0,255,0}; V3D<uint32_t> green{0,255,0};
V3D blue{0,0,255}; V3D<uint32_t> blue{0,0,255};
uint32_t maxValue{std::numeric_limits<uint32_t>::max()}; uint32_t maxValue{std::numeric_limits<uint32_t>::max()};
Cell CreateCell(float x_percent, float y_percent, float z_percent, V3D &color){ Cell CreateCell(float x_percent, float y_percent, float z_percent, V3D<uint32_t> &color){
float continuousMaxValue{static_cast<float>(std::numeric_limits<uint32_t>::max())}; float continuousMaxValue{static_cast<float>(std::numeric_limits<uint32_t>::max())};
Cell cell{ Cell cell{
.position = V3D{ .position = V3D<uint32_t>{
static_cast<uint32_t>(continuousMaxValue*x_percent), static_cast<uint32_t>(continuousMaxValue*x_percent),
static_cast<uint32_t>(continuousMaxValue*y_percent), static_cast<uint32_t>(continuousMaxValue*y_percent),
static_cast<uint32_t>(continuousMaxValue*z_percent) static_cast<uint32_t>(continuousMaxValue*z_percent)
@@ -126,33 +126,43 @@ namespace TestFrames{
squareFillFadeFrame // 7 squareFillFadeFrame // 7
}; };
AnimationFrame testFrame1{
.frame = {
CreateCell(0,0,0,red),
// CreateCell(0.5,0.5,0,green),
CreateCell(1,1,0,blue)
},
.fillInterpolation = FillInterpolation::NO_FILL,
.frameInterpolation = FrameInterpolation::FADE,
.delay = std::chrono::milliseconds(10000)
};
AnimationFrame noFillFrame2{ AnimationFrame testFrame2{
.frame = { .frame = {
CreateCell(0,1,0,red), CreateCell(0,1,0,red),
// CreateCell(0.5,0.5,0,green), // CreateCell(0.5,0.5,0,green),
CreateCell(1,0,0,green) CreateCell(1,0,0,green)
}, },
.fillInterpolation = FillInterpolation::NO_FILL, .fillInterpolation = FillInterpolation::NO_FILL,
.frameInterpolation = FrameInterpolation::SNAP, .frameInterpolation = FrameInterpolation::FADE,
.delay = std::chrono::milliseconds(10000) .delay = std::chrono::milliseconds(10000)
}; };
AnimationFrame noFillFrame3{ AnimationFrame testFrame3{
.frame = { .frame = {
CreateCell(0.5,0.5,0,red), CreateCell(0.5,0.5,0,red),
// CreateCell(0.5,0.5,0,green), // CreateCell(0.5,0.5,0,green),
CreateCell(0,1,0,blue) CreateCell(0,1,0,blue)
}, },
.fillInterpolation = FillInterpolation::NO_FILL, .fillInterpolation = FillInterpolation::NO_FILL,
.frameInterpolation = FrameInterpolation::SNAP, .frameInterpolation = FrameInterpolation::FADE,
.delay = std::chrono::milliseconds(10000) .delay = std::chrono::milliseconds(10000)
}; };
std::vector<AnimationFrame> testAnimationSequence1{ std::vector<AnimationFrame> testAnimationSequence1{
noFillFrame, testFrame1,
noFillFrame2, testFrame2,
noFillFrame3, testFrame3,
noFillFrame3 testFrame1
}; };
} }

40
lib/Board/Board.h
View File

@@ -12,13 +12,13 @@
#include "BoardTypes.h" #include "BoardTypes.h"
#include "Vector3D.h" #include "Vector3D.h"
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
class Board{ class Board{
public: public:
Board() = default; Board() = default;
~Board() = default; ~Board() = default;
constexpr const V3D &GetSize() const{return BOARD_DIMS;} constexpr const V3D<uint32_t> &GetSize() const{return BOARD_DIMS;}
constexpr uint32_t GetNumberCubes() const{return BOARD_DIMS.x * BOARD_DIMS.y * BOARD_DIMS.z;} constexpr uint32_t GetNumberCubes() const{return BOARD_DIMS.x * BOARD_DIMS.y * BOARD_DIMS.z;}
constexpr uint32_t GetMaxDimension(){return std::max(std::max(BOARD_DIMS.x, BOARD_DIMS.y), BOARD_DIMS.z);} constexpr uint32_t GetMaxDimension(){return std::max(std::max(BOARD_DIMS.x, BOARD_DIMS.y), BOARD_DIMS.z);}
@@ -34,7 +34,7 @@ class Board{
* @brief fill the entire board with the given color * @brief fill the entire board with the given color
* @param color the color to fill the board with * @param color the color to fill the board with
*/ */
void FillColor(const V3D &color); void FillColor(const V3D<uint32_t> &color);
/** /**
* @brief Set the color of the cube at the given position. * @brief Set the color of the cube at the given position.
@@ -43,7 +43,7 @@ class Board{
* @param position the position of the cube. * @param position the position of the cube.
* @param color the color you want the cube to be * @param color the color you want the cube to be
*/ */
void SetCubeColor(const V3D &position, const V3D &color); void SetCubeColor(const V3D<uint32_t> &position, const V3D<uint32_t> &color);
/** /**
* @brief Set the occupation status of the cube at a given position * @brief Set the occupation status of the cube at a given position
@@ -52,7 +52,7 @@ class Board{
* @post if the new occupation status of the cube is different than * @post if the new occupation status of the cube is different than
* the old occupation status, this will enable boardStateHasChanged. * the old occupation status, this will enable boardStateHasChanged.
*/ */
void SetCubeOccupation(const V3D &position, bool occupation); void SetCubeOccupation(const V3D<uint32_t> &position, bool occupation);
/** /**
* @returns true if the board state has changed since this flag was last set to false * @returns true if the board state has changed since this flag was last set to false
@@ -69,18 +69,18 @@ class Board{
* @brief Get a column along any axis read into the sliceBuffer * @brief Get a column along any axis read into the sliceBuffer
* @param column .z specifies the normal direction of the plane (see PLANE_NORMAL), and * @param column .z specifies the normal direction of the plane (see PLANE_NORMAL), and
* the x,y values specify the location of the column in that plane * the x,y values specify the location of the column in that plane
* to fill. IE To fill one stack at 0,2 I would say give V3D(0,2,PLANE_NORMAL::Z) * to fill. IE To fill one stack at 0,2 I would say give V3D<uint32_t>(0,2,PLANE_NORMAL::Z)
* @param sliceBuffer an array of pointers to the cubes along that column * @param sliceBuffer an array of pointers to the cubes along that column
* @returns the number of elements written into the slice buffer * @returns the number of elements written into the slice buffer
* @note That array is stored locally and will be overwritten everytime this function is called. * @note That array is stored locally and will be overwritten everytime this function is called.
* Also, any unused spots at the end of the array will be nullptrs * Also, any unused spots at the end of the array will be nullptrs
* @warning allocate the size of the slice buffer using GetMaxDimension if you don't know what you're doing! * @warning allocate the size of the slice buffer using GetMaxDimension if you don't know what you're doing!
*/ */
uint32_t SliceBoard(const V3D &column, BOARD_TYPES::Cube ** sliceBuffer); uint32_t SliceBoard(const V3D<uint32_t> &column, BOARD_TYPES::Cube ** sliceBuffer);
void PrintEntireBoard() const; void PrintEntireBoard() const;
void UpdateAllColors(const std::array<std::array<std::array<V3D, BOARD_DIMS.z>, BOARD_DIMS.y>, BOARD_DIMS.x>& colorFrame){ void UpdateAllColors(const std::array<std::array<std::array<V3D<uint32_t>, BOARD_DIMS.z>, BOARD_DIMS.y>, BOARD_DIMS.x>& colorFrame){
for(uint32_t x = 0; x < BOARD_DIMS.x; x++){ for(uint32_t x = 0; x < BOARD_DIMS.x; x++){
for(uint32_t y = 0; y < BOARD_DIMS.y; y++){ for(uint32_t y = 0; y < BOARD_DIMS.y; y++){
for(uint32_t z = 0; z < BOARD_DIMS.z; z++){ for(uint32_t z = 0; z < BOARD_DIMS.z; z++){
@@ -106,7 +106,7 @@ class Board{
bool boardStateHasChanged; bool boardStateHasChanged;
}; };
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Board<BOARD_DIMS>::ToStackString(String &stringBuffer) const{ void Board<BOARD_DIMS>::ToStackString(String &stringBuffer) const{
std::array<uint32_t, BOARD_DIMS.x * BOARD_DIMS.y> linearizedBoard; std::array<uint32_t, BOARD_DIMS.x * BOARD_DIMS.y> linearizedBoard;
for(uint32_t x{0}; x < BOARD_DIMS.x; x++){ for(uint32_t x{0}; x < BOARD_DIMS.x; x++){
@@ -126,8 +126,8 @@ void Board<BOARD_DIMS>::ToStackString(String &stringBuffer) const{
} }
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Board<BOARD_DIMS>::FillColor(const V3D &color){ void Board<BOARD_DIMS>::FillColor(const V3D<uint32_t> &color){
for(uint32_t x{0}; x < BOARD_DIMS.x; x++){ for(uint32_t x{0}; x < BOARD_DIMS.x; x++){
for(uint32_t y{0}; y < BOARD_DIMS.y; y++){ for(uint32_t y{0}; y < BOARD_DIMS.y; y++){
for(uint32_t z{0}; z < BOARD_DIMS.z; z++){ for(uint32_t z{0}; z < BOARD_DIMS.z; z++){
@@ -137,23 +137,23 @@ void Board<BOARD_DIMS>::FillColor(const V3D &color){
} }
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Board<BOARD_DIMS>::SetCubeColor(const V3D &position, const V3D &color){ void Board<BOARD_DIMS>::SetCubeColor(const V3D<uint32_t> &position, const V3D<uint32_t> &color){
this->cubes[position.x][position.y][position.z].color = color; this->cubes[position.x][position.y][position.z].color = color;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Board<BOARD_DIMS>::SetCubeOccupation(const V3D &position, bool occupation){ void Board<BOARD_DIMS>::SetCubeOccupation(const V3D<uint32_t> &position, bool occupation){
bool oldOccupation{this->cubes[position.x][position.y][position.z].isOccupied}; bool oldOccupation{this->cubes[position.x][position.y][position.z].isOccupied};
this->cubes[position.x][position.y][position.z].isOccupied = occupation; this->cubes[position.x][position.y][position.z].isOccupied = occupation;
if(occupation != oldOccupation) this->boardStateHasChanged = true; if(occupation != oldOccupation) this->boardStateHasChanged = true;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
uint32_t Board<BOARD_DIMS>::SliceBoard(const V3D &column, BOARD_TYPES::Cube ** sliceBuffer){ uint32_t Board<BOARD_DIMS>::SliceBoard(const V3D<uint32_t> &column, BOARD_TYPES::Cube ** sliceBuffer){
uint32_t columnLength{0}; uint32_t columnLength{0};
V3D indexIncrimentVector{}; V3D<uint32_t> indexIncrimentVector{};
V3D indexVector{}; V3D<uint32_t> indexVector{};
switch(column.z){ switch(column.z){
case BOARD_TYPES::PLANE_NORMAL::X: case BOARD_TYPES::PLANE_NORMAL::X:
@@ -189,7 +189,7 @@ uint32_t Board<BOARD_DIMS>::SliceBoard(const V3D &column, BOARD_TYPES::Cube ** s
return columnLength; return columnLength;
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void Board<BOARD_DIMS>::PrintEntireBoard() const{ void Board<BOARD_DIMS>::PrintEntireBoard() const{
for(uint32_t x = 0; x < BOARD_DIMS.x; x++){ for(uint32_t x = 0; x < BOARD_DIMS.x; x++){
for(uint32_t y = 0; y < BOARD_DIMS.y; y++){ for(uint32_t y = 0; y < BOARD_DIMS.y; y++){

2
lib/Board/BoardDriver.h
View File

@@ -129,7 +129,7 @@ void BoardDriver<NUM_STACKS>::UpdateStackLEDs(
){ ){
this->pixelController.setPin(this->stacks[stackIndex].ledPin); this->pixelController.setPin(this->stacks[stackIndex].ledPin);
for(int i = 0; i < numCubes; i++){ for(int i = 0; i < numCubes; i++){
V3D color{cubes[i]->color}; V3D<uint32_t> color{cubes[i]->color};
this->pixelController.setPixelColor(i*2, this->pixelController.Color(color.x, color.y, color.z)); this->pixelController.setPixelColor(i*2, this->pixelController.Color(color.x, color.y, color.z));
this->pixelController.setPixelColor((i*2 + 1), this->pixelController.Color(color.x, color.y, color.z)); this->pixelController.setPixelColor((i*2 + 1), this->pixelController.Color(color.x, color.y, color.z));
} }

57
lib/Board/BoardManager.h
View File

@@ -9,7 +9,7 @@
#include "Vector3D.h" #include "Vector3D.h"
#include "Animator.h" #include "Animator.h"
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
class BoardManager{ class BoardManager{
public: public:
BoardManager(BoardDriver<BOARD_WIDTH*BOARD_LENGTH> &boardDriver, Animator<BOARD_DIMS> &animator); BoardManager(BoardDriver<BOARD_WIDTH*BOARD_LENGTH> &boardDriver, Animator<BOARD_DIMS> &animator);
@@ -31,7 +31,7 @@ class BoardManager{
* @param position the position of the cube * @param position the position of the cube
* @param color the oclor you want the cube to be * @param color the oclor you want the cube to be
*/ */
void SetCubeColor(const V3D &position, const V3D &color); void SetCubeColor(const V3D<uint32_t> &position, const V3D<uint32_t> &color);
/** /**
* @brief Set the color of one column of cubes. * @brief Set the color of one column of cubes.
@@ -40,17 +40,17 @@ class BoardManager{
* @param column the column vector * @param column the column vector
* @param color the color you want the column to be * @param color the color you want the column to be
*/ */
void SetColumnColors(const V3D &column, const V3D *color, uint32_t numColors); void SetColumnColors(const V3D<uint32_t> &column, const V3D<uint32_t> *color, uint32_t numColors);
/** /**
* @brief Fill a column along any axis with a color * @brief Fill a column along any axis with a color
* @param column .z specifies the normal direction of the plane (see PLANE_NORMAL), and * @param column .z specifies the normal direction of the plane (see PLANE_NORMAL), and
* the x,y values specify the location of the column in that plane * the x,y values specify the location of the column in that plane
* to fill. IE To fill one stack at 0,2 I would say give V3D(0,2,PLANE_NORMAL::Z) * to fill. IE To fill one stack at 0,2 I would say give V3D<uint32_t>(0,2,PLANE_NORMAL::Z)
* @param color the color you want to fill the column with * @param color the color you want to fill the column with
*/ */
void FillColumnColor(const V3D &column, const V3D &color); void FillColumnColor(const V3D<uint32_t> &column, const V3D<uint32_t> &color);
/** /**
* @returns true if the board has changed state * @returns true if the board has changed state
@@ -67,14 +67,14 @@ class BoardManager{
*/ */
void Board2StackString(String& messageBuffer); void Board2StackString(String& messageBuffer);
void FillColor(const V3D &color){this->board.FillColor(color);} void FillColor(const V3D<uint32_t> &color){this->board.FillColor(color);}
private: private:
BoardDriver<BOARD_WIDTH*BOARD_LENGTH> &driver; BoardDriver<BOARD_WIDTH*BOARD_LENGTH> &driver;
Board<BOARD_DIMS> board{}; Board<BOARD_DIMS> board{};
Animator<BOARD_DIMS> &animator; Animator<BOARD_DIMS> &animator;
void updateStackColors(const V3D &column); void updateStackColors(const V3D<uint32_t> &column);
uint32_t getColumnHeight(BOARD_TYPES::PLANE_NORMAL normal){ uint32_t getColumnHeight(BOARD_TYPES::PLANE_NORMAL normal){
switch(normal){ switch(normal){
@@ -95,24 +95,25 @@ class BoardManager{
void updateColorsFromAnimator(); void updateColorsFromAnimator();
}; };
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::updateColorsFromAnimator(){ void BoardManager<BOARD_DIMS>::updateColorsFromAnimator(){
if(this->animator.HasInterpolatedFrameChanged()){ if(this->animator.interpolatedFrameHasChanged){
this->board.UpdateAllColors(this->animator.GetInterpolatedFrame()); this->board.UpdateAllColors(this->animator.GetInterpolatedFrame());
this->animator.interpolatedFrameHasChanged = false;
} }
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
BoardManager<BOARD_DIMS>::BoardManager(BoardDriver<BOARD_WIDTH*BOARD_LENGTH> &boardDriver, Animator<BOARD_DIMS> &animator): BoardManager<BOARD_DIMS>::BoardManager(BoardDriver<BOARD_WIDTH*BOARD_LENGTH> &boardDriver, Animator<BOARD_DIMS> &animator):
driver(boardDriver), driver(boardDriver),
animator(animator){} animator(animator){}
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::Init(){ void BoardManager<BOARD_DIMS>::Init(){
this->driver.Init(); this->driver.Init();
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::Update(){ void BoardManager<BOARD_DIMS>::Update(){
this->updateColorsFromAnimator(); this->updateColorsFromAnimator();
// update the occupied cubes on the board and the cube colors // update the occupied cubes on the board and the cube colors
@@ -121,13 +122,13 @@ void BoardManager<BOARD_DIMS>::Update(){
uint32_t stackIndex{y * BOARD_DIMS.x + x}; uint32_t stackIndex{y * BOARD_DIMS.x + x};
uint32_t numCubes{this->driver.GetNumberCubes(stackIndex)}; uint32_t numCubes{this->driver.GetNumberCubes(stackIndex)};
for(uint32_t z = 0; z < BOARD_DIMS.z; z++){ for(uint32_t z = 0; z < BOARD_DIMS.z; z++){
V3D cubePosition{x, y, z}; V3D<uint32_t> cubePosition{x, y, z};
// update the cube's occupation // update the cube's occupation
this->board.SetCubeOccupation(cubePosition, z < numCubes); this->board.SetCubeOccupation(cubePosition, z < numCubes);
} }
// create the column vector for the slice direction // create the column vector for the slice direction
V3D sliceVector{x,y,BOARD_TYPES::PLANE_NORMAL::Z}; V3D<uint32_t> sliceVector{x,y,BOARD_TYPES::PLANE_NORMAL::Z};
// create a cube slice array buffer // create a cube slice array buffer
BOARD_TYPES::Cube* sliceBuffer[BOARD_DIMS.z]; BOARD_TYPES::Cube* sliceBuffer[BOARD_DIMS.z];
// have the board slice get read into our buffer // have the board slice get read into our buffer
@@ -138,10 +139,10 @@ void BoardManager<BOARD_DIMS>::Update(){
} }
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::updateStackColors(const V3D &column){ void BoardManager<BOARD_DIMS>::updateStackColors(const V3D<uint32_t> &column){
// the only column type allowed here is z. // the only column type allowed here is z.
V3D sliceVector{column.x, column.y, BOARD_TYPES::Z}; V3D<uint32_t> sliceVector{column.x, column.y, BOARD_TYPES::Z};
// create a buffer for slice board to write the cube slice into // create a buffer for slice board to write the cube slice into
BOARD_TYPES::Cube * cubeSlice[BOARD_DIMS.z]; BOARD_TYPES::Cube * cubeSlice[BOARD_DIMS.z];
this->board.SliceBoard(column, cubeSlice); this->board.SliceBoard(column, cubeSlice);
@@ -150,15 +151,15 @@ void BoardManager<BOARD_DIMS>::updateStackColors(const V3D &column){
this->driver.UpdateStackLEDs(BOARD_DIMS.x, cubeSlice, numCubes); this->driver.UpdateStackLEDs(BOARD_DIMS.x, cubeSlice, numCubes);
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::SetCubeColor(const V3D &position, const V3D &color){ void BoardManager<BOARD_DIMS>::SetCubeColor(const V3D<uint32_t> &position, const V3D<uint32_t> &color){
this->board.SetCubeColor(position, color); this->board.SetCubeColor(position, color);
V3D slice{position.x, position.y, BOARD_TYPES::PLANE_NORMAL::Z}; V3D<uint32_t> slice{position.x, position.y, BOARD_TYPES::PLANE_NORMAL::Z};
this->updateStackColors(slice); this->updateStackColors(slice);
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::SetColumnColors(const V3D &column, const V3D *color, uint32_t numColors){ void BoardManager<BOARD_DIMS>::SetColumnColors(const V3D<uint32_t> &column, const V3D<uint32_t> *color, uint32_t numColors){
uint32_t columnHeight{this->getColumnHeight(static_cast<BOARD_TYPES::PLANE_NORMAL>(column.z))}; uint32_t columnHeight{this->getColumnHeight(static_cast<BOARD_TYPES::PLANE_NORMAL>(column.z))};
// create a cube pointer buffer and store a board slice into it // create a cube pointer buffer and store a board slice into it
@@ -171,11 +172,11 @@ void BoardManager<BOARD_DIMS>::SetColumnColors(const V3D &column, const V3D *col
} }
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::FillColumnColor(const V3D &column, const V3D &color){ void BoardManager<BOARD_DIMS>::FillColumnColor(const V3D<uint32_t> &column, const V3D<uint32_t> &color){
uint32_t columnHeight{this->getColumnHeight(column.z)}; uint32_t columnHeight{this->getColumnHeight(column.z)};
V3D colors[columnHeight]; V3D<uint32_t> colors[columnHeight];
for(uint32_t i = 0; i < columnHeight; i++){ for(uint32_t i = 0; i < columnHeight; i++){
colors[i] = color; colors[i] = color;
} }
@@ -183,13 +184,13 @@ void BoardManager<BOARD_DIMS>::FillColumnColor(const V3D &column, const V3D &col
this->SetColumnColors(column, colors); this->SetColumnColors(column, colors);
} }
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
bool BoardManager<BOARD_DIMS>::HasBoardChanged(){return this->board.BoardStateChanged();} bool BoardManager<BOARD_DIMS>::HasBoardChanged(){return this->board.BoardStateChanged();}
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::ClearBoardChanged(){this->board.SetStateChanged(false);} void BoardManager<BOARD_DIMS>::ClearBoardChanged(){this->board.SetStateChanged(false);}
template <const V3D &BOARD_DIMS> template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::Board2StackString(String& messageBuffer){ void BoardManager<BOARD_DIMS>::Board2StackString(String& messageBuffer){
this->board.ToStackString(messageBuffer); this->board.ToStackString(messageBuffer);
} }

2
lib/Board/BoardTypes.h
View File

@@ -20,7 +20,7 @@ namespace BOARD_TYPES{
}; };
struct Cube{ struct Cube{
V3D color; V3D<uint32_t> color;
bool isOccupied{false}; bool isOccupied{false};
}; };
}; };

13
src/main.cpp
View File

@@ -83,15 +83,15 @@ void SetStackColor(uint32_t * args, int argsLength){
uint32_t Y_COORD{(stackNum - X_COORD) / BOARD_DIMENSIONS.y}; uint32_t Y_COORD{(stackNum - X_COORD) / BOARD_DIMENSIONS.y};
uint32_t numColors = (argsLength - 2) / 3; uint32_t numColors = (argsLength - 2) / 3;
V3D colors[numColors]; V3D<uint32_t> colors[numColors];
for(int i = 0; i < numColors; i++){ for(int i = 0; i < numColors; i++){
uint32_t red = args[2 + (i * 3)]; uint32_t red = args[2 + (i * 3)];
uint32_t green = args[3 + (i * 3)]; uint32_t green = args[3 + (i * 3)];
uint32_t blue = args[4 + (i * 3)]; uint32_t blue = args[4 + (i * 3)];
colors[i] = V3D{red, green, blue}; colors[i] = V3D<uint32_t>{red, green, blue};
} }
boardManager.SetColumnColors(V3D{X_COORD, Y_COORD, BOARD_TYPES::PLANE_NORMAL::Z}, colors, numColors); boardManager.SetColumnColors(V3D<uint32_t>{X_COORD, Y_COORD, BOARD_TYPES::PLANE_NORMAL::Z}, colors, numColors);
} }
void parseData(Message<SERIAL_CHAR_LENGTH, SERIAL_ARG_LENGTH> &message){ void parseData(Message<SERIAL_CHAR_LENGTH, SERIAL_ARG_LENGTH> &message){
@@ -110,7 +110,7 @@ void parseData(Message<SERIAL_CHAR_LENGTH, SERIAL_ARG_LENGTH> &message){
case Commands::SetStackColors:{ case Commands::SetStackColors:{
GlobalPrint::Println("!2;"); GlobalPrint::Println("!2;");
animator.isEnabled = false; animator.isEnabled = false;
V3D black{}; V3D<uint32_t> black{};
boardManager.FillColor(black); boardManager.FillColor(black);
SetStackColor(reinterpret_cast<uint32_t *>(args), argsLength); SetStackColor(reinterpret_cast<uint32_t *>(args), argsLength);
break; break;
@@ -157,14 +157,15 @@ void UpdateBoard(void * params){
auto updateTickRate{std::chrono::milliseconds(8)}; auto updateTickRate{std::chrono::milliseconds(8)};
auto boardStateTimer{std::chrono::milliseconds(0)}; auto boardStateTimer{std::chrono::milliseconds(0)};
auto boardStateMaxUpdatePeriod{std::chrono::milliseconds(34)}; // this is a little slower than 30fps auto boardStateMaxUpdatePeriod{std::chrono::milliseconds(34)}; // this is a little slower than 30fps
unsigned long accurateTimer{millis()};
for(;;){ for(;;){
if(boardStateTimer >= boardStateMaxUpdatePeriod && boardManager.HasBoardChanged()){ if(boardStateTimer >= boardStateMaxUpdatePeriod && boardManager.HasBoardChanged()){
printBoardState(); printBoardState();
boardManager.ClearBoardChanged(); boardManager.ClearBoardChanged();
} }
animator.RunAnimation(updateTickRate); animator.RunAnimation(std::chrono::milliseconds(millis() - accurateTimer));
accurateTimer = millis();
boardManager.Update(); boardManager.Update();
boardStateTimer += updateTickRate; boardStateTimer += updateTickRate;