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

57
lib/Board/BoardManager.h
View File

@@ -9,7 +9,7 @@
#include "Vector3D.h"
#include "Animator.h"
template <const V3D &BOARD_DIMS>
template <const V3D<uint32_t> &BOARD_DIMS>
class BoardManager{
public:
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 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.
@@ -40,17 +40,17 @@ class BoardManager{
* @param column the column vector
* @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
* @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
* 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
*/
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
@@ -67,14 +67,14 @@ class BoardManager{
*/
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:
BoardDriver<BOARD_WIDTH*BOARD_LENGTH> &driver;
Board<BOARD_DIMS> board{};
Animator<BOARD_DIMS> &animator;
void updateStackColors(const V3D &column);
void updateStackColors(const V3D<uint32_t> &column);
uint32_t getColumnHeight(BOARD_TYPES::PLANE_NORMAL normal){
switch(normal){
@@ -95,24 +95,25 @@ class BoardManager{
void updateColorsFromAnimator();
};
template <const V3D &BOARD_DIMS>
template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::updateColorsFromAnimator(){
if(this->animator.HasInterpolatedFrameChanged()){
if(this->animator.interpolatedFrameHasChanged){
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):
driver(boardDriver),
animator(animator){}
template <const V3D &BOARD_DIMS>
template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::Init(){
this->driver.Init();
}
template <const V3D &BOARD_DIMS>
template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::Update(){
this->updateColorsFromAnimator();
// 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 numCubes{this->driver.GetNumberCubes(stackIndex)};
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
this->board.SetCubeOccupation(cubePosition, z < numCubes);
}
// 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
BOARD_TYPES::Cube* sliceBuffer[BOARD_DIMS.z];
// have the board slice get read into our buffer
@@ -138,10 +139,10 @@ void BoardManager<BOARD_DIMS>::Update(){
}
}
template <const V3D &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::updateStackColors(const V3D &column){
template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::updateStackColors(const V3D<uint32_t> &column){
// 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
BOARD_TYPES::Cube * cubeSlice[BOARD_DIMS.z];
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);
}
template <const V3D &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::SetCubeColor(const V3D &position, const V3D &color){
template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::SetCubeColor(const V3D<uint32_t> &position, const V3D<uint32_t> &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);
}
template <const V3D &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::SetColumnColors(const V3D &column, const V3D *color, uint32_t numColors){
template <const V3D<uint32_t> &BOARD_DIMS>
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))};
// 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>
void BoardManager<BOARD_DIMS>::FillColumnColor(const V3D &column, const V3D &color){
template <const V3D<uint32_t> &BOARD_DIMS>
void BoardManager<BOARD_DIMS>::FillColumnColor(const V3D<uint32_t> &column, const V3D<uint32_t> &color){
uint32_t columnHeight{this->getColumnHeight(column.z)};
V3D colors[columnHeight];
V3D<uint32_t> colors[columnHeight];
for(uint32_t i = 0; i < columnHeight; i++){
colors[i] = color;
}
@@ -183,13 +184,13 @@ void BoardManager<BOARD_DIMS>::FillColumnColor(const V3D &column, const V3D &col
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();}
template <const V3D &BOARD_DIMS>
template <const V3D<uint32_t> &BOARD_DIMS>
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){
this->board.ToStackString(messageBuffer);
}