Consolidate FixDef, Effects and Projections to Nodes !

Misc
====
- noise.sc: add controls
- add octo.sc, add lines

Server
=====
- rename Effect.h to Nodes.h, combine projection, fixdef and effect in Node, add Panel16 and Multiply
- Animations: add externals for octo, add sync hack and use scriptRuntime.execute
- Physical layer: add setup and loop

Author: ewowi

docs/moonbase/module/animations.md

@@ -37,37 +37,38 @@ They represent current state of Live Script processing and will be extended as m
 
 * Multiple Nodes can be created (1)
     * Each node can have properties (compare controls in WLED / StarLight)
-    * Each node can run precompile code or Live scripts (with or without loop)
+    * Each node can run precompile code or Live scripts (with or without loop) 🚧
     * Each node has a type:
-        * Fixture definition: tell where each pixture is in a 1D/2D/3D physical coordinate space (based on StarLight)
+        * Fixture definition: tell where each pixture is in a 1D/2D/3D physical coordinate space (based on StarLight) ✅
         * Fixture mapping: change the fixture to a 1D/2D/3D virtual coordinate space
             * A fixture mapping is for a specific fixture dimension and effect dimension
             * e.g. if the fixture is a globe, you can map that to 2D using mercator projection mapping
             * if the fixture is 200x200 you can map it to 50x50
             * if the fixture is 2D, a 1D effect can be shown as a circle or a bar (as WLED expand1D)
-        * Effect: run an effect in a virtual coordinate space
-            * or in the physical space if you want to run at highest performance, e.g. a random effect doesn't need to go through mappings ✅
-        * Modifier: Mirror, rotate, etc, multiple projections allowed (projection in StarLight)
+        * Effect: 
+            * run an effect in a virtual coordinate space ✅
+            * in the physical space if you want to run at highest performance, e.g. a random effect doesn't need to go through mappings ✅
+        * Modifier: Mirror, rotate, etc, multiple projections allowed (projection in StarLight) 🚧
         * Driver show: show the result on Leds (using FastLED, hpwit drivers), ArtNet, DDP, ...
 * Future situation: Nodes and noodles (2)
     * Replace the nodes table (1) by a graphical view (2)
 * Virtual Layer (MappingTable) (3)
-    * Array of arrays. Outer array is virtual pixels, inner array is physical pixels. 
-    * Implemented efficiently using the StarLight PhysMap struct
-    * e.g. [[],[0],[1,2],[3,4,5],[6,7,8,9]]
+    * Array of arrays. Outer array is virtual pixels, inner array is physical pixels. ✅
+    * Implemented efficiently using the StarLight PhysMap struct ✅
+    * e.g. [[],[0],[1,2],[3,4,5],[6,7,8,9]] ✅
         * first virtual pixel is not mapped to a physical pixel
         * second virtual pixel is mapped to physical pixel 0
         * third virtual pixel is mapped to physical pixels 1 and 2
         * and so on
     * Virtual pixels can be 1D, 2D or 3D. Physical pixels also, in any combination
-        * Using x + y * sizeX + z * sizeX * sizeY
-    * set/getPixelColor functions used in effects using the MappingTable
+        * Using x + y * sizeX + z * sizeX * sizeY 🚧
+    * set/getPixelColor functions used in effects using the MappingTable ✅
     * Nodes manipulate the MappingTable and/or interfere in the effects loop
-    * A Virtual Layer gets updated if fixture, mapping or dimensions change
-    * An effect uses a virtual layer. One Virtual layer can have multiple effects. 
+    * A Virtual Layer gets updated if fixture, mapping or dimensions change 🚧
+    * An effect uses a virtual layer. One Virtual layer can have multiple effects. ✅
 * Physical layer
-    * CRGB leds[NUM_LEDS] are physical pixels (as in FASTLED)
-    * A Physical layer has one or more virtual layers and a virtual layer has one or more effects using it.
+    * CRGB leds[NUM_LEDS] are physical pixels (as in FASTLED) ✅
+    * A Physical layer has one or more virtual layers and a virtual layer has one or more effects using it. ✅
 * Presets/playlist: change (part of) the nodes model
 
 ✅: Done

misc/livescripts/E_lines.sc

@@ -0,0 +1,11 @@
+void setup()
+{
+}
+
+void loop() {
+  fadeToBlackBy(255);
+  int x = millis() / 100;
+  for (int y = 0; y < height; y++) {
+      sCFP(y*width+x, CRGB(255,0,0), 255);
+  }
+}

misc/livescripts/E_noise.sc

@@ -1,4 +1,5 @@
-//E_noise.sc
+uint8_t intensityControl = 128;
+uint8_t speedControl = 128;
 
 void setup()
 {

misc/livescripts/E_octo.sc

@@ -0,0 +1,44 @@
+uint8_t intensityControl = 128;
+uint8_t speedControl = 128;
+
+#define PI 3.1415926535
+int nb_branches;
+uint8_t C_X;
+uint8_t C_Y;
+uint8_t mapp;
+uint8_t rMapRadius[NUM_LEDS];
+uint8_t rMapAngle[NUM_LEDS];
+uint32_t t = 0; //=speed
+
+void setup()
+{
+  C_X = width / 2;
+  C_Y = height / 2;
+  mapp = 255 / width;
+  for (int x = -C_X; x < C_X + (width % 2); x++) {
+    for (int y = -C_Y; y < C_Y + (height % 2); y++) {
+
+      float h=128*(atan2(y, x)/PI);
+      rMapAngle[(x + C_X) *height+y + C_Y]= (int)(h);
+      h=hypot(x,y);
+      rMapRadius[(x + C_X)*height +y + C_Y] = (int)(h); //thanks Sutaburosu
+    }
+  }
+}
+
+
+void loop() {
+
+  nb_branches = intensityControl / 25;
+
+  for (uint8_t x = 0; x < width; x++) {
+    for (uint8_t y = 0; y < height; y++) {
+      uint8_t angle = rMapAngle[x*height+y];
+      uint8_t radius = rMapRadius[x*height+y];
+      uint16_t intensity = sin8(sin8((angle * 4 - radius*mapp) / 4 + t) + radius*mapp - 2*t+ angle * nb_branches);
+
+      sPC(y*width+x, hsv(2*t - radius*mapp, 255, intensity));
+    }
+  }
+  t = now * speedControl / 32 / 25; //speedControl 0..8, 40 changes per second
+}

misc/livescripts/rings241.sc

@@ -6,7 +6,7 @@ void add(int leds, int radius) {
     int x = width / 2.0 + ((sin8(255 * i / leds) - 127) / 127.0) * radius / 10.0;
     int y = height / 2.0 + ((cos8(255 * i / leds) - 127) / 127.0) * radius / 10.0;
     addPixel(x, y, 0);
-printf("%d %d %d\n", leds,x,y);
+    printf("%d %d %d\n", leds,x,y);
   }
 }
 

src/MoonLight/ModuleAnimations.h

@@ -21,24 +21,34 @@
 #include "../MoonBase/Module.h"
 
 #if FT_LIVESCRIPT
+    #define USE_FASTLED //as ESPLiveScript.h calls hsv ! one of the reserved functions!!
     #include "ESPLiveScript.h" //note: contains declarations AND definitions, therefore can only be included once!
-#endif
-
-#include "Effect.h" //effect.h will include VirtualLayer.h which will include PhysicalLayer.h
+    static bool waitingOnLiveScript = true;
+    static bool scriptsRunning = false;
+    #endif
+    
+#include "Nodes.h" //Nodes.h will include VirtualLayer.h which will include PhysicalLayer.h
 
 PhysicalLayer layerP; //global declaration of the physical layer
 
 //to do: move to virtual layer ...
-void fadeToBlackBy_static(uint8_t fadeValue)
-{
-    layerP.layerV[0]->fadeToBlackBy(fadeValue);
-}
+void _fadeToBlackBy(uint8_t fadeValue) { layerP.layerV[0]->fadeToBlackBy(fadeValue);}
+static void sPCLive(uint16_t pixel, CRGB color) {layerP.layerV[0]->setPixelColor(pixel, color);} //setPixelColor with color
+static void sCFPLive(uint16_t pixel, uint8_t index, uint8_t brightness) { layerP.layerV[0]->setPixelColor(pixel, ColorFromPalette(PartyColors_p, index, brightness));} //setPixelColor within palette
 
 static void _addPin(uint8_t pinNr) {layerP.addPin(pinNr);}
 static void _addPixelsPre() {layerP.addPixelsPre();}
 static void _addPixel(uint16_t x, uint16_t y, uint16_t z) {layerP.addPixel({x, y, z});}
 static void _addPixelsPost() {layerP.addPixelsPost();}
 
+static float _triangle(float j) {return 1.0 - fabs(fmod(2 * j, 2.0) - 1.0);}
+static float _time(float j) {
+    float myVal = millis();;
+    myVal = myVal / 65535 / j;           // PixelBlaze uses 1000/65535 = .015259. 
+    myVal = fmod(myVal, 1.0);               // ewowi: with 0.015 as input, you get fmod(millis/1000,1.0), which has a period of 1 second, sounds right
+    return myVal;
+}
+
 class ModuleAnimations : public Module
 {
 public:
@@ -55,24 +65,53 @@ class ModuleAnimations : public Module
     ) : Module("animations", server, sveltekit, filesService) {
         ESP_LOGD(TAG, "constructor");
 
-        addExternalVariable("leds", "CRGB *", "", (void *)layerP.leds);
-        addExternalFunction("fadeToBlackBy", "void", "uint8_t", (void *)fadeToBlackBy_static);
+        uint8_t (*_inoise8)(uint16_t, uint16_t, uint16_t)=inoise8;
         uint16_t (*_random16)(uint16_t)=random16; //enforce specific random16 function
-        addExternalFunction("random16", "uint16_t", "uint16_t", (void *)_random16);
-        addExternalFunction("sin8", "uint8_t", "uint8_t", (void *)sin8);
-        addExternalFunction("cos8", "uint8_t", "uint8_t", (void *)cos8);
-        addExternalFunction("delay", "void", "uint8_t", (void *)delay);
+
+        //default
+        addExternalFun("uint32_t", "millis", "", (void *)millis);
+        float (*_sin)(float) = sin;
+        addExternalFun("float", "sin", "float", (void *)_sin);
+        float (*_cos)(float) = cos;
+        addExternalFun("float", "cos", "float", (void *)_cos);
+        float (*_atan2)(float, float) = atan2;
+        addExternalFun("float", "atan2", "float,float",(void*)_atan2);
+        float (*_hypot)(float, float) = hypot;
+        addExternalFun("float", "hypot", "float,float",(void*)_hypot);
+        addExternalFun("float", "time", "float", (void *)_time);
+        addExternalFun("float", "triangle", "float", (void *)_triangle);
+    
         addExternalFunction("addPin", "void", "uint8_t", (void *)_addPin);
         addExternalFunction("addPixelsPre", "void", "", (void *)_addPixelsPre);
         addExternalFunction("addPixel", "void", "uint16_t,uint16_t,uint16_t", (void *)_addPixel);
         addExternalFunction("addPixelsPost", "void", "", (void *)_addPixelsPost);
-        
+        addExternalFunction("cos8", "uint8_t", "uint8_t", (void *)cos8);
+        addExternalFunction("delay", "void", "uint8_t", (void *)delay);
+        addExternalFunction("fadeToBlackBy", "void", "uint8_t", (void *)_fadeToBlackBy);
+        addExternalFunction("inoise8", "uint8_t", "uint16_t,uint16_t,uint16_t", (void *)_inoise8);
+        addExternalVariable("leds", "CRGB *", "", (void *)layerP.leds);
+        addExternalVariable("now", "uint32_t", "", (void *)millis);
+        addExternalFunction("random16", "uint16_t", "uint16_t", (void *)_random16);
+        addExternalFunction("sin8", "uint8_t", "uint8_t", (void *)sin8);
+        addExternalFunction("sPC", "void", "uint16_t,CRGB", (void *)sPCLive);
+        addExternalFunction("sCFP", "void", "uint16_t,uint8_t,uint8_t", (void *)sCFPLive);
+
         for (asm_external el: external_links) {
             ESP_LOGD(TAG, "elink %s %s %d", el.shortname.c_str(), el.name.c_str(), el.type);
         }
         // ... send to client
     }
 
+    void addExternalVal(string result, string name, void * ptr) {
+        if (findLink(name, externalType::value) == -1) //not allready added earlier
+            addExternalVariable(name, result, "", ptr);
+    }
+    
+    void addExternalFun(string result, string name, string parameters, void * ptr) {
+        if (findLink(name, externalType::function) == -1) //not allready added earlier
+            addExternalFunction(name, result, parameters, ptr);
+    }
+        
     void begin() {
         Module::begin();
 
@@ -132,6 +171,8 @@ class ModuleAnimations : public Module
             values.add("Sinus");
             values.add("Lissajous");
             values.add("Lines");
+            values.add("Panel16");
+            values.add("Multiply");
             //find all the .sc files on FS
             File rootFolder = ESPFS.open("/");
             walkThroughFiles(rootFolder, [&](File folder, File file) {
@@ -226,14 +267,14 @@ class ModuleAnimations : public Module
             animationsChanged = false;
 
             //rebuild layerP->layerV->effects
-            for (Effect* effect : layerP.layerV[0]->effects) {
-                ESP_LOGD(TAG, "delete effect %s", effect->name());
-                delete effect;
+            for (Node* node : layerP.layerV[0]->nodes) {
+                ESP_LOGD(TAG, "delete effect %s", node->name());
+                delete node;
             }
-            layerP.layerV[0]->effects.clear(); //remove all effects
+            layerP.layerV[0]->nodes.clear(); //remove all effects
             for (JsonObject node: _state.data["nodes"].as<JsonArray>()) {
                 ESP_LOGD(TAG, "create effect %s", node["animation"].as<String>().c_str());
-                layerP.addEffect(node["animation"]); // fill the layers and effects ...
+                layerP.addNode(node["animation"]); // fill the layers and effects ...
             }
         }
 
@@ -247,12 +288,29 @@ class ModuleAnimations : public Module
             layerP.leds[i] = CRGB(0, 0, 128);
         }
 
+        if (scriptsRunning && !waitingOnLiveScript) {// show has been called (in other loop)
+            waitingOnLiveScript = true; //waiting on Live Script
+            // ESP_LOGD(TAG, "waitingOnLiveScript %d %d", scriptsRunning, waitingOnLiveScript);
+            while (waitingOnLiveScript) delay(1); // so live can continue
+        }
+
         // Serial.printf(" %s", animation.c_str());
         if (showLeds) driverShow();
     }
 
     //update scripts / read only values in the UI
     void loop1s() {
+        bool isRunning = false;
+        for (Executable &exec: scriptRuntime._scExecutables) {
+          if (exec.isRunning()) {
+            isRunning = true;
+            break;
+          }
+        }
+        scriptsRunning = isRunning;
+        if (!scriptsRunning) waitingOnLiveScript = true; //reset to default
+        // ESP_LOGD(TAG, "waitingOnLiveScript %d %d", scriptsRunning, waitingOnLiveScript);
+
         if (!_socket->getConnectedClients()) return; 
 
         JsonDocument newData; //to only send updatedData
@@ -291,18 +349,23 @@ class ModuleAnimations : public Module
 
     void driverShow()
     {
-        if (_state.data["driverOn"])
+        if (_state.data["driverOn"] && FastLED.count()) {
             FastLED.show();
+        }
     }
 
     //ESPLiveScript functions
     //=======================
 
-    static void show()
+    static void sync()
     {
-        delay(1); //to feed the watchdog (also if loopState == 0)
+        // Serial.printf("±");
 
-        // gAnimations->driverShow();
+        delay(1); //to feed the watchdog (also if loopState == 0)
+        // ESP_LOGD(TAG, "waitingOnLiveScript %d %d", scriptsRunning, waitingOnLiveScript);
+        while (!waitingOnLiveScript) delay(1); //to feed the watchdog
+        //do Live Script cycle
+        waitingOnLiveScript = false; //Live Script produced a frame, main loop will deal with it
     }
 
     void compileAndRun(const char * animation, const char * type, JsonVariant error) {
@@ -324,21 +387,24 @@ class ModuleAnimations : public Module
 
             //send UI spinner
 
-            runningPrograms.setFunctionToSync(show);
+            runningPrograms.setFunctionToSync(sync);
 
             //run the recompile not in httpd but in main loopTask (otherwise we run out of stack space)
             // runInLoopTask.push_back([&, animation, type, error] {
                 ESP_LOGD(TAG, "compileAndRun %s %s", animation, type);
                 File file = ESPFS.open(animation);
                 if (file) {
-                    std::string scScript = file.readString().c_str();
-                    // scScript += "void main(){setup();sync();}";
+                    std::string scScript;
+                    scScript += "#define NUM_LEDS " + std::to_string(layerP.nrOfLeds) + "\n"; //NUM_LEDS is used in arrays -> must be define e.g. uint8_t rMapRadius[NUM_LEDS];
+                    scScript += "#define width " + std::to_string(layerP.layerV[0]->size.x) + "\n";
+                    scScript += "#define height " + std::to_string(layerP.layerV[0]->size.y) + "\n";
+                    scScript += "#define depth " + std::to_string(layerP.layerV[0]->size.z) + "\n";
+                    scScript += file.readString().c_str();
                     file.close();
 
                     // gAnimations = this;
                     if (equal(type, "Effect")) {
-                        scScript += "#define NUM_LEDS " + std::to_string(layerP.nrOfLeds) + "\n"; //NUM_LEDS is used in arrays -> must be define e.g. uint8_t rMapRadius[NUM_LEDS];
-                        scScript += "void main(){setup();while(2>1){loop();delay(1);}}"; //sync();
+                        scScript += "void main(){setup();while(2>1){loop();sync();}}"; //;
                     } else if (equal(type, "Fixture definition")) {
                         scScript += "void main(){addPixelsPre();setup();addPixelsPost();}";
                     }
@@ -348,15 +414,16 @@ class ModuleAnimations : public Module
 
                     // ESP_LOGD(TAG, "parsing %s", scScript.c_str());
 
-                    Executable executable = parser.parseScript(&scScript);
+                    Executable executable = parser.parseScript(&scScript); // note that this class will be deleted after the function call !!!
                     executable.name = animation;
                     ESP_LOGD(TAG, "parsing %s done\n", animation);
                     scriptRuntime.addExe(executable); //if already exists, delete it first
                     ESP_LOGD(TAG, "addExe success %s\n", executable.exeExist?"true":"false");
 
                     if (executable.exeExist) {
                         if (equal(type, "Fixture definition")) {
-                            executable.execute("main"); //background task (async - vs sync)
+                            // executable.execute("main"); //background task (async - vs sync)
+                            scriptRuntime.execute(executable.name, "main"); //background task (async - vs sync)
                             // pass = 1;
                             // liveM->executeTask(liveFixtureID, "c");
                             // pass = 2;
@@ -366,7 +433,8 @@ class ModuleAnimations : public Module
                             // setup : create controls
                             // executable.execute("setup"); 
                             // send controls to UI
-                            executable.executeAsTask("main"); //background task (async - vs sync)
+                            // executable.executeAsTask("main"); //background task (async - vs sync)
+                            scriptRuntime.executeAsTask(executable.name, "main"); //background task (async - vs sync)
                             //assert failed: xEventGroupSync event_groups.c:228 (uxBitsToWaitFor != 0)
                         }
                     } else
@@ -386,10 +454,15 @@ class ModuleAnimations : public Module
     void kill(int index) {
         ESP_LOGD(TAG, "kill %d", index);
         if (index < scriptRuntime._scExecutables.size()) {
-            scriptRuntime.kill(scriptRuntime._scExecutables[index].name);
-            scriptRuntime.free(scriptRuntime._scExecutables[index].name);
+            // scriptRuntime.kill(scriptRuntime._scExecutables[index].name);
+            // scriptRuntime.free(scriptRuntime._scExecutables[index].name);
             scriptRuntime.deleteExe(scriptRuntime._scExecutables[index].name);
         }
+
+        if (waitingOnLiveScript) {
+            waitingOnLiveScript = false;
+            // ESP_LOGD(TAG, "waitingOnLiveScript %d %d", scriptsRunning, waitingOnLiveScript);
+        }
     }
 }; // class ModuleAnimations