expose fade times for root activation/deactivation

js/packages/core/index.ts

@@ -199,10 +199,14 @@ class Renderer {
   }
 
   render(...args) {
+    return this.renderWithOptions({ rootFadeInMs: 20, rootFadeOutMs: 20 }, args);
+  }
+
+  renderWithOptions(options: { rootFadeInMs: number, rootFadeOutMs: number }, ...args) {
     const t0 = now();
 
     this._delegate.clear();
-    renderWithDelegate(this._delegate as any, args.map(resolve));
+    renderWithDelegate(this._delegate as any, args.map(resolve), options.rootFadeInMs, options.rootFadeOutMs);
 
     const t1 = now();
 

js/packages/core/src/Reconciler.gen.ts

@@ -15,7 +15,7 @@ import type {t as NodeRepr_t} from './NodeRepr.gen';
 // tslint:disable-next-line:max-classes-per-file 
 export abstract class RenderDelegate_t { protected opaque!: any }; /* simulate opaque types */
 
-export const renderWithDelegate: (delegate:RenderDelegate_t, graphs:NodeRepr_t[]) => void = function (Arg1: any, Arg2: any) {
-  const result = Curry._2(ReconcilerBS.renderWithDelegate, Arg1, Arg2);
+export const renderWithDelegate: <T1,T2>(delegate:RenderDelegate_t, graphs:NodeRepr_t[], rootFadeInMs:T1, rootFadeOutMs:T2) => void = function <T1,T2>(Arg1: any, Arg2: any, Arg3: any, Arg4: any) {
+  const result = Curry._4(ReconcilerBS.renderWithDelegate, Arg1, Arg2, Arg3, Arg4);
   return result
 };

js/packages/core/src/Reconciler.res

@@ -87,14 +87,14 @@ let rec visit = (
 }
 
 @genType
-let renderWithDelegate = (delegate, graphs) => {
+let renderWithDelegate = (delegate, graphs, rootFadeInMs, rootFadeOutMs) => {
   let visitSet = Set.make()
   let roots = Belt.List.mapWithIndex(Belt.List.fromArray(graphs), (i, g) => {
-    NodeRepr.create("root", {"channel": i}, [g])
+    NodeRepr.create("root", {"channel": i, "fadeInMs": rootFadeInMs, "fadeOutMs": rootFadeOutMs}, [g])
   })
 
   visit(delegate, visitSet, roots)
-
+  
   RenderDelegate.activateRoots(delegate, Belt.List.toArray(Belt.List.map(roots, r => r.hash)))
   RenderDelegate.commitUpdates(delegate)
 }

runtime/elem/GraphRenderSequence.h

@@ -178,7 +178,7 @@ namespace elem
         {
             // Don't promote if our RootRenderSequence represents a RootNode that has become
             // inactive, even if it's still fading out
-            if (rootPtr->getTargetGain() < FloatType(0.5))
+            if (!rootPtr->active() && rootPtr->stillRunning())
                 return;
 
             for (auto& n : tapList) {

runtime/elem/Runtime.h

@@ -354,7 +354,7 @@ namespace elem
             auto ptr = std::dynamic_pointer_cast<RootNode<FloatType>>(it->second);
             if (ptr)
             {
-                ptr->activate(currentRoots.empty() ? FloatType(1) : FloatType(0));
+                ptr->setProperty("active", true);
                 active.insert(nodeId);
                 ELEM_DBG("[Success] Activated root: " << nodeIdToHex(nodeId));
             }

runtime/elem/builtins/Core.h

@@ -4,6 +4,7 @@
 #include "../SingleWriterSingleReaderQueue.h"
 
 #include "helpers/Change.h"
+#include "helpers/GainFade.h"
 #include "helpers/RefCountedPool.h"
 
 
@@ -19,28 +20,14 @@ namespace elem
             return channelIndex.load();
         }
 
-        FloatType getTargetGain()
-        {
-            return targetGain.load();
-        }
-
         bool active()
         {
-            return targetGain.load() > 0.0f;
+            return fade.on();
         }
 
         bool stillRunning()
         {
-            auto const t = targetGain.load();
-            auto const c = currentGain.load();
-
-            return (t >= 0.5 || (std::abs(c - t) >= 1e-6));
-        }
-
-        void activate(FloatType initialGain = FloatType(0)) 
-        {
-            setProperty("active", true);
-            currentGain.store(initialGain);
+            return active() || !fade.settled();
         }
 
         int setProperty(std::string const& key, js::Value const& val) override
@@ -49,13 +36,30 @@ namespace elem
                 if (!val.isBool())
                     return ReturnCode::InvalidPropertyType();
 
-                targetGain.store(FloatType(val ? 1 : 0));
+                if (val)
+                    fade.fadeIn();
+                else
+                    fade.fadeOut();
             }
 
             if (key == "channel") {
                 channelIndex.store(static_cast<int>((js::Number) val));
             }
 
+            if (key == "fadeInMs") {
+                if (!val.isNumber())
+                    return ReturnCode::InvalidPropertyType();
+
+                fade.setFadeInTimeMs(GraphNode<FloatType>::getSampleRate(), static_cast<float>((js::Number) val));
+            }
+
+            if (key == "fadeOutMs") {
+                if (!val.isNumber())
+                    return ReturnCode::InvalidPropertyType();
+
+                fade.setFadeOutTimeMs(GraphNode<FloatType>::getSampleRate(), static_cast<float>((js::Number) val));
+            }
+
             return GraphNode<FloatType>::setProperty(key, val);
         }
 
@@ -70,22 +74,11 @@ namespace elem
             if (numChannels < 1)
                 return (void) std::fill_n(outputData, numSamples, FloatType(0));
 
-            auto const t = targetGain.load();
-            auto c = currentGain.load();
-
-            auto const direction = (t < c) ? FloatType(-1) : FloatType(1);
-            auto const step = direction * FloatType(20) / FloatType(GraphNode<FloatType>::getSampleRate());
-
-            for (size_t i = 0; i < numSamples; ++i) {
-                outputData[i] = inputData[0][i] * c;
-                c = std::clamp(c + step, FloatType(0), FloatType(1));
-            }
-
-            currentGain.store(c);
+            fade.process(inputData[0], outputData, numSamples);
         }
 
-        std::atomic<FloatType> targetGain = 1;
-        std::atomic<FloatType> currentGain = 0;
+        GainFade<FloatType> fade = {GraphNode<FloatType>::getSampleRate(), 20, 20, 0.0, 1.0};
+
         std::atomic<int> channelIndex = -1;
     };
 

runtime/elem/builtins/helpers/GainFade.h

@@ -6,62 +6,116 @@
 namespace elem
 {
 
+    namespace detail {
+        inline double millisecondsToStep(double sampleRate, double ms) {
+            return ms > 1e-6 ? 1.0 / (sampleRate * ms / 1000.0) : 1.0;
+        }
+    }
+
     template <typename FloatType>
     struct GainFade
     {
-        GainFade(double sampleRate, double fadeTimeMs)
-            : step(FloatType(1.0 / (sampleRate * fadeTimeMs / 1000.0)))
+        GainFade(double sampleRate, double fadeInTimeMs, double fadeOutTimeMs, FloatType current = 0.0, FloatType target = 0.0)
+        : currentGain(current)
+        , targetGain(target)
         {
+            setFadeInTimeMs(sampleRate, fadeInTimeMs);
+            setFadeOutTimeMs(sampleRate, fadeOutTimeMs);
         }
 
         GainFade(GainFade const& other)
-            : currentGain(other.currentGain), targetGain(other.targetGain), step(other.step)
+        : currentGain(other.currentGain.load())
+        , targetGain(other.targetGain.load())
+        , step(other.step.load())
+        , inStep(other.inStep)
+        , outStep(other.outStep)
         {
         }
 
         void operator= (GainFade const& other)
         {
-            currentGain = other.currentGain;
-            targetGain = other.targetGain;
-            step = other.step;
+            currentGain.store(other.currentGain.load());
+            targetGain.store(other.targetGain.load());
+            step.store(other.step.load());
+            inStep = other.inStep;
+            outStep = other.outStep;
         }
 
         FloatType operator() (FloatType x) {
-            if (currentGain == targetGain)
-                return (currentGain * x);
+            auto const _currentGain = currentGain.load();
+            if (_currentGain == targetGain.load())
+                return (_currentGain * x);
 
-            auto y = x * currentGain;
-            currentGain = std::clamp(currentGain + step, FloatType(0), FloatType(1));
+            auto y = x * _currentGain;
+            currentGain.store(std::clamp(_currentGain + step.load(), FloatType(0), FloatType(1)));
 
             return y;
         }
 
-        void setTargetGain (FloatType g) {
-            targetGain = g;
+        void process (const FloatType* input, FloatType* output, int numSamples) {
+            auto const _currentGain = currentGain.load();
+            if (_currentGain == targetGain.load()) {
+                for (int i = 0; i < numSamples; ++i) {
+                    output[i] = input[i] * _currentGain;
+                }
+                return;
+            }
 
-            if (targetGain < currentGain) {
-                step = FloatType(-1) * std::abs(step);
-            } else {
-                step = std::abs(step);
+            auto const _step = step.load();
+            for (int i = 0; i < numSamples; ++i) {
+                output[i] = input[i] * std::clamp(_currentGain + _step * i, FloatType(0), FloatType(1));
             }
+
+            currentGain.store(std::clamp(_currentGain + _step * numSamples, FloatType(0), FloatType(1)));
+        }
+
+        void setFadeInTimeMs(double sampleRate, double fadeInTimeMs) {
+            inStep = detail::millisecondsToStep(sampleRate, fadeInTimeMs);
+            updateCurrentStep();
+        }
+
+        void setFadeOutTimeMs(double sampleRate, double fadeOutTimeMs) {
+            outStep = FloatType(-1) * detail::millisecondsToStep(sampleRate, fadeOutTimeMs);
+            updateCurrentStep();
+        }
+
+        void fadeIn() {
+            targetGain.store(FloatType(1));
+            updateCurrentStep();
+        }
+
+        void fadeOut() {
+            targetGain.store(FloatType(0));
+            updateCurrentStep();
+        }
+
+        void setCurrentGain(FloatType gain) {
+            currentGain.store(gain);
         }
 
         bool on() {
-            return (targetGain > FloatType(0.5));
+            return (targetGain.load() > FloatType(0.5));
         }
 
         bool settled() {
-            return fpEqual(targetGain, currentGain);
+            return fpEqual(targetGain.load(), currentGain.load());
         }
 
         void reset() {
-            currentGain = FloatType(0);
-            targetGain = FloatType(0);
+            currentGain.store(FloatType(0));
+            targetGain.store(FloatType(0));
+        }
+
+    private:
+        void updateCurrentStep() {
+            step.store(currentGain.load() > targetGain.load() ? outStep : inStep);
         }
 
-        FloatType currentGain = 0;
-        FloatType targetGain = 0;
-        FloatType step = 0;
+        std::atomic<FloatType> currentGain = 0;
+        std::atomic<FloatType> targetGain = 0;
+        std::atomic<FloatType> step = 0;
+        FloatType inStep = 0;
+        FloatType outStep = 0;
     };
 
 } // namespace elem

runtime/elem/builtins/mc/SampleSeq.h

@@ -13,21 +13,21 @@ namespace elem
         template <typename FloatType>
         struct MCBufferReader {
             MCBufferReader(double sampleRate, double fadeTime)
-                : fade(sampleRate, fadeTime)
+                : fade(sampleRate, fadeTime, fadeTime)
             {
             }
 
             void engage (double start, double currentTime, size_t _bufferSize) {
                 startTime = start;
                 bufferSize = _bufferSize;
-                fade.setTargetGain(FloatType(1));
+                fade.fadeIn();
 
                 position = static_cast<size_t>(((currentTime - startTime) / sampleDuration) * (double) (bufferSize - 1u));
                 position = std::clamp<size_t>(position, 0, bufferSize);
             }
 
             void disengage() {
-                fade.setTargetGain(FloatType(0));
+                fade.fadeOut();
             }
 
             // Does the incoming time match what this reader is expecting?