API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 22nd, 2018
85
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.67 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.    Светодиодный куб 16x16 на Arduino NANO и сдвиговых регистрах 74HC595
  3.  
  4.    Разработал VECT, модифицировал AlexGyver
  5.    http://AlexGyver.ru/LEDcube/
  6.    https://github.com/AlexGyver/GyverLibs
  7.    2018 AlexGyver
  8. */
  9.  
  10. #define INVERT_Y 1    // инвертировать по вертикали (если дождь идёт вверх)
  11. #define INVERT_X 0    // инвертировать по горизонтали (если текст не читается)
  12.  
  13. // текст для режима текста
  14. String disp_text = "U1152 U103 SAPR LETI ";
  15.  
  16. #define XAXIS 0
  17. #define YAXIS 1
  18. #define ZAXIS 2
  19.  
  20. #define POS_X 0
  21. #define NEG_X 1
  22. #define POS_Z 2
  23. #define NEG_Z 3
  24. #define POS_Y 4
  25. #define NEG_Y 5
  26.  
  27. #define BUTTON1 18
  28. #define BUTTON2 19
  29. #define RED_LED 5
  30. #define GREEN_LED 7
  31.  
  32. #define TOTAL_EFFECTS 12  // количество эффектов
  33.  
  34. #define RAIN 0
  35. #define SEND_VOXELS 1
  36. #define SPHERE_BOOM 2
  37. #define SPHERE 3
  38. #define WOOP_WOOP 4
  39. #define CUBE_JUMP 5
  40. #define GLOW 6
  41. #define TEXT 7
  42. #define LIT 8
  43.  
  44. #include <SPI.h>
  45. #include "GyverButton.h"
  46. #include "fonts.h"
  47.  
  48. GButton butt1(BUTTON1);
  49. GButton butt2(BUTTON2);
  50.  
  51. #define RAIN_TIME 15
  52. #define SPHERE_BOOM_TIME 40
  53. #define SPHERE_TIME 20
  54. #define SEND_VOXELS_TIME 14
  55. #define WOOP_WOOP_TIME 15
  56. #define CUBE_JUMP_TIME 10
  57. #define GLOW_TIME 8
  58. #define TEXT_TIME 10
  59. #define CLOCK_TIME 50
  60. #define WALKING_TIME 10
  61.  
  62. uint8_t cube[8][8];
  63. int8_t currentEffect;
  64. uint16_t timer;
  65. uint16_t modeTimer;
  66. bool loading;
  67. int8_t pos;
  68. int8_t vector[3];
  69. int16_t coord[3];
  70. uint8_t len = disp_text.length();
  71.  
  72. void setup() {
  73.   Serial.begin(9600);
  74.  
  75.   loading = true;
  76.   currentEffect = RAIN;
  77.   SPI.begin();
  78.   SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
  79.   pinMode(RED_LED, OUTPUT);
  80.   pinMode(GREEN_LED, OUTPUT);
  81.   randomSeed(analogRead(0));
  82.   digitalWrite(GREEN_LED, HIGH);
  83.  
  84.   butt1.setIncrStep(5);         // настройка инкремента, может быть отрицательным (по умолчанию 1)
  85.   butt1.setIncrTimeout(100);    // настрйока интервала инкремента (по умолчанию 800 мс)
  86.   butt2.setIncrStep(-5);        // настройка инкремента, может быть отрицательным (по умолчанию 1)
  87.   butt2.setIncrTimeout(100);    // настрйока интервала инкремента (по умолчанию 800 мс)
  88.  
  89.   currentEffect = TEXT;
  90.   changeMode();
  91. }
  92.  
  93. void loop() {
  94.   butt1.tick();
  95.   butt2.tick();
  96.  
  97.   if (butt1.isSingle()) {
  98.     currentEffect++;
  99.     if (currentEffect >= TOTAL_EFFECTS) currentEffect = 0;
  100.     changeMode();
  101.   }
  102.   if (butt2.isSingle()) {
  103.     currentEffect--;
  104.     if (currentEffect < 0) currentEffect = TOTAL_EFFECTS - 1;
  105.     changeMode();
  106.   }
  107.  
  108.   if (butt1.isIncr()) {                                 // если кнопка была удержана (это для инкремента)
  109.     modeTimer = butt1.getIncr(modeTimer);               // увеличивать/уменьшать переменную value с шагом и интервалом
  110.   }
  111.   if (butt2.isIncr()) {                                 // если кнопка была удержана (это для инкремента)
  112.     modeTimer = butt2.getIncr(modeTimer);               // увеличивать/уменьшать переменную value с шагом и интервалом
  113.   }
  114.  
  115.   switch (currentEffect) {
  116.     case RAIN: rain(); break;
  117.     case SEND_VOXELS: sendVoxels(); break;
  118.     case SPHERE_BOOM: sphere_boom(); break;
  119.     case SPHERE: sphere_woop(); break;
  120.     case WOOP_WOOP: woopWoop(); break;
  121.     case CUBE_JUMP: cubeJump(); break;
  122.     case GLOW: glow(); break;
  123.     case TEXT: text(); break;
  124.     case LIT: lit(); break;
  125.     case 9: sinusFill(); break;
  126.     case 10: sinusThin(); break;
  127.     case 11: walkingCube(); break;
  128.  
  129.     default: sphere_woop(); break;
  130.   }
  131.   renderCube();
  132. }
  133.  
  134. void changeMode() {
  135.   clearCube();
  136.   loading = true;
  137.   timer = 0;
  138.   randomSeed(millis());
  139.   digitalWrite(RED_LED, HIGH);
  140.   digitalWrite(GREEN_LED, LOW);
  141.   delay(500);
  142.   digitalWrite(RED_LED, LOW);
  143.   digitalWrite(GREEN_LED, HIGH);
  144.  
  145.   switch (currentEffect) {
  146.     case RAIN: modeTimer = RAIN_TIME; break;
  147.     case SEND_VOXELS: modeTimer = SEND_VOXELS_TIME; break;
  148.     case SPHERE_BOOM: modeTimer = SPHERE_BOOM_TIME; break;
  149.     case SPHERE: modeTimer = SPHERE_TIME; break;
  150.     case WOOP_WOOP: modeTimer = WOOP_WOOP_TIME; break;
  151.     case CUBE_JUMP: modeTimer = CUBE_JUMP_TIME; break;
  152.     case GLOW: modeTimer = GLOW_TIME; break;
  153.     case TEXT: modeTimer = TEXT_TIME; break;
  154.     case LIT: modeTimer = CLOCK_TIME; break;
  155.     case 9: modeTimer = RAIN_TIME; break;
  156.     case 10: modeTimer = RAIN_TIME; break;
  157.     case 11: modeTimer = WALKING_TIME; break;
  158.   }
  159. }
  160.  
  161. void renderCube() {
  162.   for (uint8_t i = 0; i < 8; i++) {
  163.     digitalWrite(SS, LOW);
  164.     if (INVERT_Y) SPI.transfer(0x01 << (7 - i));
  165.     else SPI.transfer(0x01 << i);
  166.     for (uint8_t j = 0; j < 8; j++) {
  167.       if (INVERT_X) SPI.transfer(cube[7 - i][j]);
  168.       else SPI.transfer(cube[i][j]);
  169.     }
  170.     digitalWrite(SS, HIGH);
  171.     delay(1);
  172.   }
  173. }
  174.  
  175. void walkingCube() {
  176.   if (loading) {
  177.     clearCube();
  178.     loading = false;
  179.     for (byte i = 0; i < 3; i++) {
  180.       // координата от о до 700!
  181.       coord[i] = 300;
  182.       vector[i] = random(3, 8) * 15;
  183.     }
  184.   }
  185.   timer++;
  186.   if (timer > modeTimer) {
  187.     timer = 0;
  188.     clearCube();
  189.     for (byte i = 0; i < 3; i++) {
  190.       coord[i] += vector[i];
  191.       if (coord[i] < 1) {
  192.         coord[i] = 1;
  193.         vector[i] = -vector[i];
  194.         vector[i] += random(0, 6) - 3;
  195.       }
  196.       if (coord[i] > 700 - 100) {
  197.         coord[i] = 700 - 100;
  198.         vector[i] = -vector[i];
  199.         vector[i] += random(0, 6) - 3;
  200.       }
  201.     }
  202.  
  203.     int8_t thisX = coord[0] / 100;
  204.     int8_t thisY = coord[1] / 100;
  205.     int8_t thisZ = coord[2] / 100;
  206.  
  207.     setVoxel(thisX, thisY, thisZ);
  208.     setVoxel(thisX + 1, thisY, thisZ);
  209.     setVoxel(thisX, thisY + 1, thisZ);
  210.     setVoxel(thisX, thisY, thisZ + 1);
  211.     setVoxel(thisX + 1, thisY + 1, thisZ);
  212.     setVoxel(thisX, thisY + 1, thisZ + 1);
  213.     setVoxel(thisX + 1, thisY, thisZ + 1);
  214.     setVoxel(thisX + 1, thisY + 1, thisZ + 1);
  215.   }
  216. }
  217.  
  218. void sinusFill() {
  219.   if (loading) {
  220.     clearCube();
  221.     loading = false;
  222.   }
  223.   timer++;
  224.   if (timer > modeTimer) {
  225.     timer = 0;
  226.     clearCube();
  227.     if (++pos > 10) pos = 0;
  228.     for (uint8_t i = 0; i < 8; i++) {
  229.       for (uint8_t j = 0; j < 8; j++) {
  230.         int8_t sinZ = 4 + ((float)sin((float)(i + pos) / 2) * 2);
  231.         for (uint8_t y = 0; y < sinZ; y++) {
  232.           setVoxel(i, y, j);
  233.         }
  234.       }
  235.     }
  236.   }
  237. }
  238.  
  239. void sinusThin() {
  240.   if (loading) {
  241.     clearCube();
  242.     loading = false;
  243.   }
  244.   timer++;
  245.   if (timer > modeTimer) {
  246.     timer = 0;
  247.     clearCube();
  248.     if (++pos > 10) pos = 0;
  249.     for (uint8_t i = 0; i < 8; i++) {
  250.       for (uint8_t j = 0; j < 8; j++) {
  251.         int8_t sinZ = 4 + ((float)sin((float)(i + pos) / 2) * 2);
  252.         setVoxel(i, sinZ, j);
  253.       }
  254.     }
  255.   }
  256. }
  257.  
  258. void rain() {
  259.   if (loading) {
  260.     clearCube();
  261.     loading = false;
  262.   }
  263.   timer++;
  264.   if (timer > modeTimer) {
  265.     timer = 0;
  266.     shift(NEG_Y);
  267.     uint8_t numDrops = random(0, 5);
  268.     for (uint8_t i = 0; i < numDrops; i++) {
  269.       setVoxel(random(0, 8), 7, random(0, 8));
  270.     }
  271.   }
  272. }
  273.  
  274. uint8_t sphereSize = -1;
  275. bool sphereExpanding = true;
  276. bool didDelayed = false;
  277.  
  278. void drawSphere(uint8_t _sphereSize) {
  279.   for (uint8_t i = 0; i < 8; i++) {
  280.       for (uint8_t j = 0; j < 8; j++) {
  281.         cube[i][j] = sphere[i + 8*_sphereSize][j];
  282.       }
  283.   }
  284. }
  285.  
  286. void sphere_boom() {
  287.   if (loading) {
  288.     clearCube();
  289.     sphereSize = -1;
  290.     sphereExpanding = true;
  291.     didDelayed = false;
  292.     loading = false;
  293.   }
  294.  
  295.   timer++;
  296.   if (timer > modeTimer) {
  297.     timer = 0;
  298.     if (sphereExpanding) {
  299.       sphereSize += 1;
  300.       if (sphereSize == 3) {
  301.         if (!didDelayed) {
  302.           didDelayed = true;
  303.         } else {
  304.           sphereExpanding = false;
  305.         }
  306.       }
  307.     } else {
  308.       sphereSize -= 1;
  309.       if (sphereSize == 0) {
  310.         sphereExpanding = true;
  311.         didDelayed = false;
  312.       }
  313.     }
  314.     clearCube();
  315.     drawSphere(sphereSize);
  316.   }
  317. }
  318.  
  319.  
  320.  
  321. void sphere_woop() {
  322.   if (loading) {
  323.     clearCube();
  324.     sphereSize = -1;
  325.     sphereExpanding = true;
  326.     didDelayed = false;
  327.     loading = false;
  328.   }
  329.  
  330.   timer++;
  331.   if (timer > modeTimer) {
  332.     timer = 0;
  333.     if (sphereExpanding) {
  334.       if (didDelayed == false && sphereExpanding == true) {
  335.         sphereSize += 1;
  336.       }
  337.       if (sphereSize == 3) {
  338.         if (didDelayed == false) {
  339.           didDelayed = true;
  340.         } else {
  341.           sphereExpanding = false;
  342.         }
  343.       }
  344.     } else {
  345.       sphereSize -= 1;
  346.       if (sphereSize == 0) {
  347.         sphereExpanding = true;
  348.         didDelayed = false;
  349.       }
  350.     }
  351.     clearCube();
  352.     drawSphere(sphereSize);
  353.   }
  354. }
  355.  
  356. uint8_t selX = 0;
  357. uint8_t selY = 0;
  358. uint8_t selZ = 0;
  359. uint8_t sendDirection = 0;
  360. bool sending = false;
  361.  
  362. void sendVoxels() {
  363.   if (loading) {
  364.     clearCube();
  365.     for (uint8_t x = 0; x < 8; x++) {
  366.       for (uint8_t z = 0; z < 8; z++) {
  367.         setVoxel(x, random(0, 2) * 7, z);
  368.       }
  369.     }
  370.     loading = false;
  371.   }
  372.  
  373.   timer++;
  374.   if (timer > modeTimer) {
  375.     timer = 0;
  376.     if (!sending) {
  377.       selX = random(0, 8);
  378.       selZ = random(0, 8);
  379.       if (getVoxel(selX, 0, selZ)) {
  380.         selY = 0;
  381.         sendDirection = POS_Y;
  382.       } else if (getVoxel(selX, 7, selZ)) {
  383.         selY = 7;
  384.         sendDirection = NEG_Y;
  385.       }
  386.       sending = true;
  387.     } else {
  388.       if (sendDirection == POS_Y) {
  389.         selY++;
  390.         setVoxel(selX, selY, selZ);
  391.         clearVoxel(selX, selY - 1, selZ);
  392.         if (selY == 7) {
  393.           sending = false;
  394.         }
  395.       } else {
  396.         selY--;
  397.         setVoxel(selX, selY, selZ);
  398.         clearVoxel(selX, selY + 1, selZ);
  399.         if (selY == 0) {
  400.           sending = false;
  401.         }
  402.       }
  403.     }
  404.   }
  405. }
  406.  
  407. uint8_t cubeSize = 0;
  408. bool cubeExpanding = true;
  409.  
  410. void woopWoop() {
  411.   if (loading) {
  412.     clearCube();
  413.     cubeSize = 2;
  414.     cubeExpanding = true;
  415.     loading = false;
  416.   }
  417.  
  418.   timer++;
  419.   if (timer > modeTimer) {
  420.     timer = 0;
  421.     if (cubeExpanding) {
  422.       cubeSize += 2;
  423.       if (cubeSize == 8) {
  424.         cubeExpanding = false;
  425.       }
  426.     } else {
  427.       cubeSize -= 2;
  428.       if (cubeSize == 2) {
  429.         cubeExpanding = true;
  430.       }
  431.     }
  432.     clearCube();
  433.     drawCube(4 - cubeSize / 2, 4 - cubeSize / 2, 4 - cubeSize / 2, cubeSize);
  434.   }
  435. }
  436.  
  437. uint8_t xPos;
  438. uint8_t yPos;
  439. uint8_t zPos;
  440.  
  441. void cubeJump() {
  442.   if (loading) {
  443.     clearCube();
  444.     xPos = random(0, 2) * 7;
  445.     yPos = random(0, 2) * 7;
  446.     zPos = random(0, 2) * 7;
  447.     cubeSize = 8;
  448.     cubeExpanding = false;
  449.     loading = false;
  450.   }
  451.  
  452.   timer++;
  453.   if (timer > modeTimer) {
  454.     timer = 0;
  455.     clearCube();
  456.     if (xPos == 0 && yPos == 0 && zPos == 0) {
  457.       drawCube(xPos, yPos, zPos, cubeSize);
  458.     } else if (xPos == 7 && yPos == 7 && zPos == 7) {
  459.       drawCube(xPos + 1 - cubeSize, yPos + 1 - cubeSize, zPos + 1 - cubeSize, cubeSize);
  460.     } else if (xPos == 7 && yPos == 0 && zPos == 0) {
  461.       drawCube(xPos + 1 - cubeSize, yPos, zPos, cubeSize);
  462.     } else if (xPos == 0 && yPos == 7 && zPos == 0) {
  463.       drawCube(xPos, yPos + 1 - cubeSize, zPos, cubeSize);
  464.     } else if (xPos == 0 && yPos == 0 && zPos == 7) {
  465.       drawCube(xPos, yPos, zPos + 1 - cubeSize, cubeSize);
  466.     } else if (xPos == 7 && yPos == 7 && zPos == 0) {
  467.       drawCube(xPos + 1 - cubeSize, yPos + 1 - cubeSize, zPos, cubeSize);
  468.     } else if (xPos == 0 && yPos == 7 && zPos == 7) {
  469.       drawCube(xPos, yPos + 1 - cubeSize, zPos + 1 - cubeSize, cubeSize);
  470.     } else if (xPos == 7 && yPos == 0 && zPos == 7) {
  471.       drawCube(xPos + 1 - cubeSize, yPos, zPos + 1 - cubeSize, cubeSize);
  472.     }
  473.     if (cubeExpanding) {
  474.       cubeSize++;
  475.       if (cubeSize == 8) {
  476.         cubeExpanding = false;
  477.         xPos = random(0, 2) * 7;
  478.         yPos = random(0, 2) * 7;
  479.         zPos = random(0, 2) * 7;
  480.       }
  481.     } else {
  482.       cubeSize--;
  483.       if (cubeSize == 1) {
  484.         cubeExpanding = true;
  485.       }
  486.     }
  487.   }
  488. }
  489.  
  490. bool glowing;
  491. uint16_t glowCount = 0;
  492.  
  493. void glow() {
  494.   if (loading) {
  495.     clearCube();
  496.     glowCount = 0;
  497.     glowing = true;
  498.     loading = false;
  499.   }
  500.  
  501.   timer++;
  502.   if (timer > modeTimer) {
  503.     timer = 0;
  504.     if (glowing) {
  505.       if (glowCount < 448) {
  506.         do {
  507.           selX = random(0, 8);
  508.           selY = random(0, 8);
  509.           selZ = random(0, 8);
  510.         } while (getVoxel(selX, selY, selZ));
  511.         setVoxel(selX, selY, selZ);
  512.         glowCount++;
  513.       } else if (glowCount < 512) {
  514.         lightCube();
  515.         glowCount++;
  516.       } else {
  517.         glowing = false;
  518.         glowCount = 0;
  519.       }
  520.     } else {
  521.       if (glowCount < 448) {
  522.         do {
  523.           selX = random(0, 8);
  524.           selY = random(0, 8);
  525.           selZ = random(0, 8);
  526.         } while (!getVoxel(selX, selY, selZ));
  527.         clearVoxel(selX, selY, selZ);
  528.         glowCount++;
  529.       } else {
  530.         clearCube();
  531.         glowing = true;
  532.         glowCount = 0;
  533.       }
  534.     }
  535.   }
  536. }
  537.  
  538. uint8_t charCounter = 0;
  539. uint8_t charPosition = 0;
  540.  
  541. void text() {
  542.   if (loading) {
  543.     clearCube();
  544.     charPosition = -1;
  545.     charCounter = 0;
  546.     loading = false;
  547.   }
  548.   timer++;
  549.   if (timer > modeTimer) {
  550.     timer = 0;
  551.  
  552.     shift(NEG_Z);
  553.     charPosition++;
  554.  
  555.     if (charPosition == 7) {
  556.       charCounter++;
  557.       if (charCounter > len - 1) {
  558.         charCounter = 0;
  559.       }
  560.       charPosition = 0;
  561.     }
  562.     if (charPosition == 0) {
  563.       for (uint8_t i = 0; i < 8; i++) {
  564.         cube[i][0] = getFont(disp_text[charCounter], i);
  565.       }
  566.     }
  567.   }
  568. }
  569.  
  570. void lit() {
  571.   if (loading) {
  572.     clearCube();
  573.     for (uint8_t i = 0; i < 8; i++) {
  574.       for (uint8_t j = 0; j < 8; j++) {
  575.         cube[i][j] = 0xFF;
  576.       }
  577.     }
  578.     loading = false;
  579.   }
  580. }
  581.  
  582. void setVoxel(uint8_t x, uint8_t y, uint8_t z) {
  583.   cube[7 - y][7 - z] |= (0x01 << x);
  584. }
  585.  
  586. void clearVoxel(uint8_t x, uint8_t y, uint8_t z) {
  587.   cube[7 - y][7 - z] ^= (0x01 << x);
  588. }
  589.  
  590. bool getVoxel(uint8_t x, uint8_t y, uint8_t z) {
  591.   return (cube[7 - y][7 - z] & (0x01 << x)) == (0x01 << x);
  592. }
  593.  
  594. void setPlane(uint8_t axis, uint8_t i) {
  595.   for (uint8_t j = 0; j < 8; j++) {
  596.     for (uint8_t k = 0; k < 8; k++) {
  597.       if (axis == XAXIS) {
  598.         setVoxel(i, j, k);
  599.       } else if (axis == YAXIS) {
  600.         setVoxel(j, i, k);
  601.       } else if (axis == ZAXIS) {
  602.         setVoxel(j, k, i);
  603.       }
  604.     }
  605.   }
  606. }
  607.  
  608. void shift(uint8_t dir) {
  609.  
  610.   if (dir == POS_X) {
  611.     for (uint8_t y = 0; y < 8; y++) {
  612.       for (uint8_t z = 0; z < 8; z++) {
  613.         cube[y][z] = cube[y][z] << 1;
  614.       }
  615.     }
  616.   } else if (dir == NEG_X) {
  617.     for (uint8_t y = 0; y < 8; y++) {
  618.       for (uint8_t z = 0; z < 8; z++) {
  619.         cube[y][z] = cube[y][z] >> 1;
  620.       }
  621.     }
  622.   } else if (dir == POS_Y) {
  623.     for (uint8_t y = 1; y < 8; y++) {
  624.       for (uint8_t z = 0; z < 8; z++) {
  625.         cube[y - 1][z] = cube[y][z];
  626.       }
  627.     }
  628.     for (uint8_t i = 0; i < 8; i++) {
  629.       cube[7][i] = 0;
  630.     }
  631.   } else if (dir == NEG_Y) {
  632.     for (uint8_t y = 7; y > 0; y--) {
  633.       for (uint8_t z = 0; z < 8; z++) {
  634.         cube[y][z] = cube[y - 1][z];
  635.       }
  636.     }
  637.     for (uint8_t i = 0; i < 8; i++) {
  638.       cube[0][i] = 0;
  639.     }
  640.   } else if (dir == POS_Z) {
  641.     for (uint8_t y = 0; y < 8; y++) {
  642.       for (uint8_t z = 1; z < 8; z++) {
  643.         cube[y][z - 1] = cube[y][z];
  644.       }
  645.     }
  646.     for (uint8_t i = 0; i < 8; i++) {
  647.       cube[i][7] = 0;
  648.     }
  649.   } else if (dir == NEG_Z) {
  650.     for (uint8_t y = 0; y < 8; y++) {
  651.       for (uint8_t z = 7; z > 0; z--) {
  652.         cube[y][z] = cube[y][z - 1];
  653.       }
  654.     }
  655.     for (uint8_t i = 0; i < 8; i++) {
  656.       cube[i][0] = 0;
  657.     }
  658.   }
  659. }
  660.  
  661. void drawCube(uint8_t x, uint8_t y, uint8_t z, uint8_t s) {
  662.   for (uint8_t i = 0; i < s; i++) {
  663.     setVoxel(x, y + i, z);
  664.     setVoxel(x + i, y, z);
  665.     setVoxel(x, y, z + i);
  666.     setVoxel(x + s - 1, y + i, z + s - 1);
  667.     setVoxel(x + i, y + s - 1, z + s - 1);
  668.     setVoxel(x + s - 1, y + s - 1, z + i);
  669.     setVoxel(x + s - 1, y + i, z);
  670.     setVoxel(x, y + i, z + s - 1);
  671.     setVoxel(x + i, y + s - 1, z);
  672.     setVoxel(x + i, y, z + s - 1);
  673.     setVoxel(x + s - 1, y, z + i);
  674.     setVoxel(x, y + s - 1, z + i);
  675.   }
  676. }
  677.  
  678. void lightCube() {
  679.   for (uint8_t i = 0; i < 8; i++) {
  680.     for (uint8_t j = 0; j < 8; j++) {
  681.       cube[i][j] = 0xFF;
  682.     }
  683.   }
  684. }
  685.  
  686. void clearCube() {
  687.   for (uint8_t i = 0; i < 8; i++) {
  688.     for (uint8_t j = 0; j < 8; j++) {
  689.       cube[i][j] = 0;
  690.     }
  691.   }
  692. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!