@opendaw/studio-core 0.0.112 → 0.0.114

package/dist/ui/renderer/fading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fading.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/fading.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAC,aAAa,EAAC,MAAM,aAAa,CAAA;AACzC,OAAO,EAAC,WAAW,EAAC,MAAM,OAAO,CAAA;AAEjC,yBAAiB,mBAAmB,CAAC;IAC1B,MAAM,MAAM,GAAI,SAAS,wBAAwB,EACjC,OAAO,aAAa,EACpB,QAAQ,cAAc,CAAC,MAAM,EAC7B,iBAAe,WAAW,EAC1B,WAAW,MAAM,EACjB,SAAS,MAAM,EACf,OAAO,MAAM,KAAG,IAkDtC,CAAA;CACJ"}

package/dist/ui/renderer/fading.js

@@ -0,0 +1,55 @@
+import { Curve, TAU } from "@opendaw/lib-std";
+export var AudioFadingRenderer;
+(function (AudioFadingRenderer) {
+    AudioFadingRenderer.render = (context, range, fading, { top, bottom }, startPPQN, endPPQN, color) => {
+        const { inSlope: fadeInSlope, outSlope: fadeOutSlope } = fading;
+        const duration = endPPQN - startPPQN;
+        const totalFading = fading.in + fading.out;
+        const scale = totalFading > duration ? duration / totalFading : 1.0;
+        const fadeIn = fading.in * scale;
+        const fadeOut = fading.out * scale;
+        context.strokeStyle = color;
+        context.fillStyle = "rgba(0,0,0,0.25)";
+        context.lineWidth = devicePixelRatio;
+        if (fadeIn > 0) {
+            const fadeInEndPPQN = startPPQN + fadeIn;
+            const x0 = range.unitToX(startPPQN) * devicePixelRatio;
+            const x1 = range.unitToX(fadeInEndPPQN) * devicePixelRatio;
+            const xn = x1 - x0;
+            const path = new Path2D();
+            path.moveTo(x0, bottom);
+            let x = x0;
+            Curve.run(fadeInSlope, xn, bottom, top, y => path.lineTo(++x, y));
+            path.lineTo(x1, top);
+            context.stroke(path);
+            path.lineTo(x0, top);
+            path.lineTo(x0, bottom);
+            context.fill(path);
+        }
+        if (fadeOut > 0) {
+            const x0 = range.unitToX(endPPQN - fadeOut) * devicePixelRatio;
+            const x1 = range.unitToX(endPPQN) * devicePixelRatio;
+            const xn = x1 - x0;
+            const path = new Path2D();
+            path.moveTo(x0, top);
+            let x = x0;
+            Curve.run(fadeOutSlope, xn, top, bottom, y => path.lineTo(++x, y));
+            path.lineTo(x1, bottom);
+            context.strokeStyle = color;
+            context.stroke(path);
+            path.lineTo(x1, top);
+            path.lineTo(x0, top);
+            context.fill(path);
+        }
+        const handleRadius = 1.5 * devicePixelRatio;
+        const x0 = Math.max(range.unitToX(startPPQN + fadeIn), range.unitToX(startPPQN)) * devicePixelRatio;
+        const x1 = Math.min(range.unitToX(endPPQN - fadeOut), range.unitToX(endPPQN)) * devicePixelRatio;
+        context.fillStyle = color;
+        context.beginPath();
+        context.arc(x0, top, handleRadius, 0, TAU);
+        context.fill();
+        context.beginPath();
+        context.arc(x1, top, handleRadius, 0, TAU);
+        context.fill();
+    };
+})(AudioFadingRenderer || (AudioFadingRenderer = {}));

package/dist/ui/renderer/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./audio";
+export * from "./env";
+export * from "./fading";
+export * from "./notes";
+export * from "./value";
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/renderer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA;AACrB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA"}

package/dist/ui/renderer/index.js

@@ -0,0 +1,5 @@
+export * from "./audio";
+export * from "./env";
+export * from "./fading";
+export * from "./notes";
+export * from "./value";

package/dist/ui/renderer/notes.d.ts

@@ -0,0 +1,7 @@
+import { NoteRegionBoxAdapter } from "@opendaw/studio-adapters";
+import { LoopableRegion } from "@opendaw/lib-dsp";
+import { RegionBound, TimelineRange } from "../../index";
+export declare namespace NotesRenderer {
+    const render: (context: CanvasRenderingContext2D, range: TimelineRange, region: NoteRegionBoxAdapter, { top, bottom }: RegionBound, contentColor: string, { rawStart, regionStart, resultStart, resultEnd }: LoopableRegion.LoopCycle) => void;
+}
+//# sourceMappingURL=notes.d.ts.map

package/dist/ui/renderer/notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/notes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAC,WAAW,EAAE,aAAa,EAAC,MAAM,aAAa,CAAA;AAEtD,yBAAiB,aAAa,CAAC;IACpB,MAAM,MAAM,GAAI,SAAS,wBAAwB,EACjC,OAAO,aAAa,EACpB,QAAQ,oBAAoB,EAC5B,iBAAe,WAAW,EAC1B,cAAc,MAAM,EACpB,mDAAiD,cAAc,CAAC,SAAS,SAiB/F,CAAA;CACJ"}

package/dist/ui/renderer/notes.js

@@ -0,0 +1,23 @@
+export var NotesRenderer;
+(function (NotesRenderer) {
+    NotesRenderer.render = (context, range, region, { top, bottom }, contentColor, { rawStart, regionStart, resultStart, resultEnd }) => {
+        const collection = region.optCollection.unwrap();
+        const height = bottom - top;
+        context.fillStyle = contentColor;
+        const padding = 8;
+        const noteHeight = 5;
+        const searchStart = Math.floor(resultStart - rawStart);
+        const searchEnd = Math.floor(resultEnd - rawStart);
+        for (const note of collection.events.iterateRange(searchStart - collection.maxDuration, searchEnd)) {
+            const position = rawStart + note.position;
+            if (position < regionStart) {
+                continue;
+            }
+            const complete = Math.min(rawStart + note.complete, resultEnd);
+            const x0 = Math.floor(range.unitToX(position) * devicePixelRatio);
+            const x1 = Math.floor(range.unitToX(complete) * devicePixelRatio);
+            const y = top + padding + Math.floor(note.normalizedPitch() * (height - (padding * 2 + noteHeight)));
+            context.fillRect(x0, y, Math.max(1, x1 - x0), noteHeight);
+        }
+    };
+})(NotesRenderer || (NotesRenderer = {}));

package/dist/ui/renderer/value.d.ts

@@ -0,0 +1,7 @@
+import { LoopableRegion, ValueEvent } from "@opendaw/lib-dsp";
+import { Func, unitValue } from "@opendaw/lib-std";
+import { TimelineRange } from "../../index";
+export declare namespace ValueStreamRenderer {
+    const render: (context: CanvasRenderingContext2D, range: TimelineRange, generator: IterableIterator<ValueEvent>, valueToY: Func<unitValue, number>, contentColor: string, alphaFill: unitValue, anchor: unitValue, { resultStart, resultEnd, rawStart: delta }: LoopableRegion.LoopCycle) => void;
+}
+//# sourceMappingURL=value.d.ts.map

package/dist/ui/renderer/value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAE,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAC3D,OAAO,EAA2B,IAAI,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAA;AAC1E,OAAO,EAAC,aAAa,EAAC,MAAM,aAAa,CAAA;AAEzC,yBAAiB,mBAAmB,CAAC;IAC1B,MAAM,MAAM,GAAI,SAAS,wBAAwB,EACjC,OAAO,aAAa,EACpB,WAAW,gBAAgB,CAAC,UAAU,CAAC,EACvC,UAAU,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,EACjC,cAAc,MAAM,EACpB,WAAW,SAAS,EACpB,QAAQ,SAAS,EACjB,6CAA2C,cAAc,CAAC,SAAS,SAuFzF,CAAA;CACJ"}

package/dist/ui/renderer/value.js

@@ -0,0 +1,101 @@
+import { asDefined, assert, Curve } from "@opendaw/lib-std";
+export var ValueStreamRenderer;
+(function (ValueStreamRenderer) {
+    ValueStreamRenderer.render = (context, range, generator, valueToY, contentColor, alphaFill, anchor, { resultStart, resultEnd, rawStart: delta }) => {
+        const { done, value } = generator.next();
+        if (done) {
+            return;
+        }
+        const unitToX = (unit) => range.unitToX(unit + delta) * devicePixelRatio;
+        const path = new Path2D();
+        const windowMin = resultStart - delta;
+        const windowMax = resultEnd - delta;
+        const xMin = unitToX(windowMin);
+        const xMax = unitToX(windowMax);
+        let notMoved = true; // makes sure we start with a moveTo command
+        let prev = asDefined(value);
+        for (const next of generator) {
+            assert(prev !== next, "iterator error");
+            const { position: p0, value: v0, interpolation } = prev;
+            const { position: p1, value: v1 } = next;
+            const type = interpolation.type;
+            const x0 = unitToX(p0);
+            const x1 = unitToX(p1);
+            const y0 = valueToY(v0);
+            const y1 = valueToY(v1);
+            if (type === "none" || p1 - p0 === 0) { // hold and jumps to the next event's value
+                if (notMoved) {
+                    if (p1 > windowMax) {
+                        break;
+                    } // leave the rest for after the loop
+                    path.moveTo(xMin, y0); // move pen to window min
+                    path.lineTo(x1, y0); // line to next event
+                    notMoved = false;
+                }
+                if (x1 > xMax) {
+                    break;
+                }
+                path.lineTo(x1, y0); // hold value to the next event
+                path.lineTo(x1, y1); // jump to the next event value
+            }
+            else if (type === "linear") {
+                const ratio = (v1 - v0) / (p1 - p0);
+                if (notMoved) {
+                    path.moveTo(xMin, valueToY(p0 < windowMin ? v0 + ratio * (windowMin - p0) : v0)); // move pen to window min
+                    if (p0 > windowMin) {
+                        path.lineTo(x0, y0);
+                    } // line to first event
+                    notMoved = false;
+                }
+                if (p1 > windowMax) {
+                    path.lineTo(xMax, valueToY(v0 + ratio * (windowMax - p0))); // line to window max
+                }
+                else {
+                    path.lineTo(x1, y1); // line to next event
+                }
+            }
+            else if (type === "curve") {
+                const cx0 = Math.max(x0, xMin);
+                const cx1 = Math.min(x1, xMax);
+                const definition = { slope: interpolation.slope, steps: x1 - x0, y0, y1 };
+                if (notMoved) {
+                    if (p0 > windowMin) {
+                        path.moveTo(xMin, y0); // move to window edge
+                        path.lineTo(x0, y0); // draw the line to the first event
+                    }
+                    else {
+                        path.moveTo(cx0, Curve.valueAt(definition, cx0 - x0));
+                    }
+                    notMoved = false;
+                }
+                // TODO We can optimise this by walking the Curve.coefficients
+                for (let x = cx0; x <= cx1; x += 4) {
+                    path.lineTo(x, Curve.valueAt(definition, x - x0));
+                }
+                path.lineTo(cx1, Curve.valueAt(definition, cx1 - x0));
+            }
+            prev = next;
+        }
+        if (notMoved) {
+            // we have not moved, so let's draw a straight line from min to max to respect the sole event
+            path.moveTo(xMin, valueToY(prev.value));
+            path.lineTo(xMax, valueToY(prev.value));
+        }
+        else if (prev.position < windowMax) {
+            // hold value to the window max
+            path.lineTo(xMax, valueToY(prev.value));
+        }
+        const yMin = valueToY(anchor) + devicePixelRatio;
+        const style = contentColor;
+        context.fillStyle = style;
+        context.strokeStyle = style;
+        context.beginPath();
+        context.stroke(path);
+        path.lineTo(xMax, yMin);
+        path.lineTo(xMin, yMin);
+        path.closePath();
+        context.globalAlpha = alphaFill;
+        context.fill(path);
+        context.globalAlpha = 1.00;
+    };
+})(ValueStreamRenderer || (ValueStreamRenderer = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendaw/studio-core",
-  "version": "0.0.112",
+  "version": "0.0.114",
   "license": "LGPL-3.0-or-later",
   "publishConfig": {
     "access": "public"
@@ -34,16 +34,16 @@
   },
   "dependencies": {
     "@opendaw/lib-box": "^0.0.75",
-    "@opendaw/lib-dawproject": "^0.0.59",
+    "@opendaw/lib-dawproject": "^0.0.60",
     "@opendaw/lib-dom": "^0.0.75",
-    "@opendaw/lib-dsp": "^0.0.73",
+    "@opendaw/lib-dsp": "^0.0.74",
     "@opendaw/lib-fusion": "^0.0.80",
     "@opendaw/lib-runtime": "^0.0.71",
     "@opendaw/lib-std": "^0.0.70",
     "@opendaw/nam-wasm": "^1.0.3",
-    "@opendaw/studio-adapters": "^0.0.90",
-    "@opendaw/studio-boxes": "^0.0.77",
-    "@opendaw/studio-enums": "^0.0.65",
+    "@opendaw/studio-adapters": "^0.0.91",
+    "@opendaw/studio-boxes": "^0.0.78",
+    "@opendaw/studio-enums": "^0.0.66",
     "dropbox": "^10.34.0",
     "y-websocket": "^1.4.5",
     "yjs": "^13.6.27",
@@ -57,10 +57,10 @@
     "@ffmpeg/ffmpeg": "^0.12.15",
     "@ffmpeg/util": "^0.12.2",
     "@opendaw/eslint-config": "^0.0.27",
-    "@opendaw/studio-core-processors": "^0.0.93",
-    "@opendaw/studio-core-workers": "^0.0.85",
-    "@opendaw/studio-forge-boxes": "^0.0.77",
+    "@opendaw/studio-core-processors": "^0.0.94",
+    "@opendaw/studio-core-workers": "^0.0.86",
+    "@opendaw/studio-forge-boxes": "^0.0.78",
     "@opendaw/typescript-config": "^0.0.29"
   },
-  "gitHead": "731fdb7389fd85b216ec7d7d343baa92cc9eeeee"
+  "gitHead": "4781e65b5b6bc29077d2e32da950b8a6a352dfce"
 }