Update README.md

Author: danewhero

usermods/user_fx/README.md

@@ -51,7 +51,7 @@ if (!strip.isMatrix || !SEGMENT.is2D())
 return mode_static();  // not a 2D set-up 
 ```
 The next code block contains several constant variable definitions which essentially serve to extract the dimensions of the user's 2D matrix and allow WLED to interpret the matrix as a 1D coordinate system (WLED must do this for all 2D animations):
-```
+```cpp
 const int cols = SEG_W;
 const int rows = SEG_H;
 const auto XY = [&](int x, int y) { return x + y * cols; };
@@ -64,7 +64,7 @@ const auto XY = [&](int x, int y) { return x + y * cols; };
   * WLED internally treats the LED strip as a 1D array, so effects must translate 2D coordinates into 1D indices. This lambda helps with that.
 
 The next lines of code further the setup process by defining variables that allow the effect's settings to be configurable using the UI sliders (or alternatively, through API calls):
-```
+```cpp
 const uint8_t refresh_hz = map(SEGMENT.speed, 0, 255, 20, 80);
 const unsigned refresh_ms = 1000 / refresh_hz;
 const int16_t diffusion = map(SEGMENT.custom1, 0, 255, 0, 100);
@@ -85,14 +85,14 @@ const uint8_t turbulence = SEGMENT.custom2;
 
 Next we will look at some lines of code that handle memory allocation and effect initialization:
 
-```
+```cpp
 unsigned dataSize = SEGMENT.length();
 ```
 * This part calculates how much memory we need to represent per-pixel state.
   * `SEGMENT.length()` returns the total number of LEDs in the current segment (i.e., cols * rows in a matrix).
   * This fire effect models heat values per pixel (not just colors), so we need persistent storage — one uint8_t per pixel — for the entire effect.
 
-```
+```cpp
 if (!SEGENV.allocateData(dataSize))
 return mode_static(); // allocation failed
 ```
@@ -103,7 +103,7 @@ return mode_static(); // allocation failed
 
 
 The next lines of code clear the LEDs and initialize timing:
-```
+```cpp
 if (SEGENV.call == 0) {
   SEGMENT.fill(BLACK);
   SEGENV.step = 0;
@@ -115,7 +115,7 @@ if (SEGENV.call == 0) {
 * It also initializes `SEGENV.step`, a timing marker, to 0.  This value is later used as a timestamp to control when the next animation frame should occur (based on elapsed time).
 
 The next block of code is where the animation update logic starts to kick in:
-```
+```cpp
 if ((strip.now - SEGENV.step) >= refresh_ms) {
   uint8_t tmp_row[cols];
   SEGENV.step = strip.now;
@@ -134,7 +134,7 @@ if ((strip.now - SEGENV.step) >= refresh_ms) {
   * Note that this is declared on the stack each frame. Since the number of columns is typically small (e.g. ≤ 16), it's efficient.
 
 Now we get to the spark generation portion, where new bursts of heat appear at the bottom of the matrix:
-```
+```cpp
 if (hw_random8() > turbulence) {
   // create new sparks at bottom row
   for (unsigned x = 0; x < cols; x++) {
@@ -161,7 +161,7 @@ if (hw_random8() > turbulence) {
   * This simulates a fresh burst of flame, which will diffuse and move upward over time in subsequent frames.
 
 Next we reach the first part of the core of the fire simulation, which is diffusion (how heat spreads to neighboring pixels):
-```
+```cpp
 // diffuse
 for (unsigned y = 0; y < rows; y++) {
   for (unsigned x = 0; x < cols; x++) {
@@ -188,7 +188,7 @@ for (unsigned y = 0; y < rows; y++) {
   * This entire line of code stores the smoothed heat into the temporary row buffer.
 
 After calculating tmp_row, we now handle rendering the pixels by updating the actual segment data and turning 'heat' into visible colors:
-```
+```cpp
   for (unsigned x = 0; x < cols; x++) {
     SEGMENT.data[XY(x, y)] = tmp_row[x];
     if (SEGMENT.check1) {
@@ -213,7 +213,7 @@ After calculating tmp_row, we now handle rendering the pixels by updating the ac
 * The final line of code fades that base color according to the heat value (acts as brightness multiplier).
 
 The final piece of this custom effect returns the frame time:
-```
+```cpp
 }
 return FRAMETIME;
 }
@@ -229,7 +229,7 @@ return FRAMETIME;
 ### The Metadata String
 At the end of every effect is an important line of code called the **metadata string**.  
 It defines how the effect is to be interacted with in the UI:
-```
+```cpp
 static const char _data_FX_MODE_DIFFUSIONFIRE[] PROGMEM = "Diffusion Fire@!,Spark rate,Diffusion Speed,Turbulence,,Use palette;;Color;;2;pal=35";
 ```
 This string is passed into `strip.addEffect()` and parsed by WLED to determine how your effect appears and behaves in the UI. 
@@ -241,7 +241,7 @@ Let’s split this into logical sections (delimited by semicolons ;):
 ### The UserFxUsermod Class
 
 The `UserFxUsermod` class registers the `mode_diffusionfire` effect with WLED. This section starts right after the effect function and metadata string, and is responsible for making the effect usable in the WLED interface:
-```
+```cpp
 class UserFxUsermod : public Usermod {
  private:
  public:
@@ -278,7 +278,7 @@ class UserFxUsermod : public Usermod {
   * USERMOD_ID_USER_FX is defined in [const.h](https://github.com/wled/WLED/blob/main/wled00/const.h). WLED uses this for tracking, debugging, or referencing usermods internally.
 
 The final part of this file handles instatiation and initialization:
-```
+```cpp
 static UserFxUsermod user_fx;
 REGISTER_USERMOD(user_fx);
 ```