Fire2023()

void Fire2023

(

uint32_t

now

)

Definition at line 138 of file Fire2023.h.

                            {
  // some changing values
  // these values are produced by perlin noise to add randomness and smooth transitions
  uint16_t ctrl1 = inoise16(11 * now, 0, 0);
  uint16_t ctrl2 = inoise16(13 * now, 100000, 100000);
  uint16_t  ctrl = ((ctrl1 + ctrl2) >> 1);
 
  // parameters for the fire heat map
  x[FIRENOISE] = 3 * ctrl * FIRESPEED;
  y[FIRENOISE] = 20 * now * FIRESPEED;
  z[FIRENOISE] = 5 * now * FIRESPEED;
  scale_x[FIRENOISE] = scale8(ctrl1, FIRENOISESCALE);
  scale_y[FIRENOISE] = scale8(ctrl2, FIRENOISESCALE);
 
  //calculate the perlin noise data for the fire
  for (uint8_t x_count = 0; x_count < WIDTH; x_count++) {
    uint32_t xoffset = scale_x[FIRENOISE] * (x_count - CentreX);
    for (uint8_t y_count = 0; y_count < HEIGHT; y_count++) {
      uint32_t yoffset = scale_y[FIRENOISE] * (y_count - CentreY);
      uint16_t data = ((inoise16(x[FIRENOISE] + xoffset, y[FIRENOISE] + yoffset, z[FIRENOISE])) + 1);
      noise[FIRENOISE][x_count][y_count] = data >> 8;
    }
  }
 
  // parameters for the smoke map
  x[SMOKENOISE] = 3 * ctrl * SMOKESPEED;
  y[SMOKENOISE] = 20 * now * SMOKESPEED;
  z[SMOKENOISE] = 5 * now * SMOKESPEED;
  scale_x[SMOKENOISE] = scale8(ctrl1, SMOKENOISESCALE);
  scale_y[SMOKENOISE] = scale8(ctrl2, SMOKENOISESCALE);
 
  //calculate the perlin noise data for the smoke
  for (uint8_t x_count = 0; x_count < WIDTH; x_count++) {
    uint32_t xoffset = scale_x[SMOKENOISE] * (x_count - CentreX);
    for (uint8_t y_count = 0; y_count < HEIGHT; y_count++) {
      uint32_t yoffset = scale_y[SMOKENOISE] * (y_count - CentreY);
      uint16_t data = ((inoise16(x[SMOKENOISE] + xoffset, y[SMOKENOISE] + yoffset, z[SMOKENOISE])) + 1);
      noise[SMOKENOISE][x_count][y_count] = data / SMOKENOISE_DIMMER;
    }
  }
 
  //copy everything one line up
  for (uint8_t y = 0; y < HEIGHT - 1; y++) {
    for (uint8_t x = 0; x < WIDTH; x++) {
      heat[XY(x, y)] = heat[XY(x, y + 1)];
    }
  }
 
  // draw lowest line - seed the fire where it is brightest and hottest
  for (uint8_t x = 0; x < WIDTH; x++) {
    heat[XY(x, HEIGHT-1)] =  noise[FIRENOISE][WIDTH - 1 - x][CentreX];
    //if (heat[XY(x, HEIGHT-1)] < 200) heat[XY(x, HEIGHT-1)] = 150; 
  }
 
  // dim the flames based on FIRENOISE noise. 
  // if the FIRENOISE noise is strong, the led goes out fast
  // if the FIRENOISE noise is weak, the led stays on stronger.
  // once the heat is gone, it stays dark.
  for (uint8_t y = 0; y < HEIGHT - 1; y++) {
    for (uint8_t x = 0; x < WIDTH; x++) {
      uint8_t dim = noise[FIRENOISE][x][y];
      // high value in FLAMEHEIGHT = less dimming = high flames
      dim = dim / FLAMEHEIGHT;
      dim = 255 - dim;
      heat[XY(x, y)] = scale8(heat[XY(x, y)] , dim);
 
      // map the colors based on heatmap
      // use the heat map to set the color of the LED from the "hot" palette
      //                               whichpalette    position      brightness     blend or not
      leds[XY(x, y)] = ColorFromPalette(hotPalette, heat[XY(x, y)], heat[XY(x, y)], LINEARBLEND);
 
      // dim the result based on SMOKENOISE noise
      // this is not saved in the heat map - the flame may dim away and come back
      // next iteration.
      leds[XY(x, y)].nscale8(noise[SMOKENOISE][x][y]);
 
    }
  }
}

References CentreX, CentreY, ColorFromPalette(), FIRENOISE, FIRENOISESCALE, FIRESPEED, FLAMEHEIGHT, heat, HEIGHT, hotPalette, inoise16(), leds, noise, scale_x, scale_y, SMOKENOISE, SMOKENOISE_DIMMER, SMOKENOISESCALE, SMOKESPEED, WIDTH, x, XY(), y, and z.

Referenced by loop().

Here is the call graph for this function:

Here is the caller graph for this function: