EffectsSpace

using EffectsSpace.Animation;
using EffectsSpace.Core;

var opacity = new Channel(100);
opacity.SetKey(0, 0, Interpolation.Bezier);
opacity.SetKey(1, 100);
double halfway = CurveEvaluator.Evaluate(opacity, 0.5);
bool moving = CurveVelocity.TryEvaluate(opacity, 0.5, out double perSecond);

var rotation = new Channel(0) { Expression = "value + time * 45" };
double angle = CurveEvaluator.Evaluate(rotation, 2);   // 90

if (!ScalarExpression.TryEvaluate("sin(time) * 100", time: 1, value: 0, index: 1, out double result, out string? error))
    Console.WriteLine(error);

using EffectsSpace.Core;
using EffectsSpace.Documents;

string json = ProjectJson.Save(MotionProject.Empty());
MotionProject project = ProjectJson.Load(json);   // validates on load

sealed class FolderStorage(string root) : IWorkspaceStorage
{
    string Recovery => Path.Combine(root, "recovery.effects");
    public async Task<string?> ReadRecoveryAsync() => File.Exists(Recovery) ? await File.ReadAllTextAsync(Recovery) : null;
    public Task WriteRecoveryAsync(string json) => File.WriteAllTextAsync(Recovery, json);
    public Task<IReadOnlyList<ImportedFile>> PickFilesAsync(bool projectOnly = false) => Task.FromResult<IReadOnlyList<ImportedFile>>([]);
    public Task SaveFileAsync(string name, string mimeType, byte[] data) => File.WriteAllBytesAsync(Path.Combine(root, name), data);
}

using EffectsSpace.Core;
using EffectsSpace.Documents;
using EffectsSpace.Editing;

var session = new EditorSession(MotionProject.Empty());
Layer layer = session.AddLayer(LayerKind.Rectangle);   // added and selected
session.AutoKey = true;
session.SetProperty("X", 250);
session.SetTime(1);
session.SetProperty("X", 700);
session.AddEffect(EffectKind.GaussianBlur);

session.BeginEdit("Drag");                             // interactive gesture
layer.Transform.Y.Value += 40; session.PreviewChanged();
session.CommitEdit();                                  // one undo step; CancelEdit on Escape

session.Undo();
string json = ProjectJson.Save(session.Project);

using EffectsSpace.Core;
using EffectsSpace.Editing;
using EffectsSpace.Rendering;

Composition comp = SampleProject.Create().Compositions[0];

var frame = new CompositionFrame(comp, time: 2.4);
foreach (RenderLayer item in frame.Layers)
    Console.WriteLine($"{item.Layer.Name}: opacity {item.Opacity:0.00}, world {item.World}");

Layer? hit = RenderPlanner.HitTest(comp, 2.4, new Vec2(960, 540));
double[] times = RenderPlanner.ExportTimes(comp).ToArray();   // work-area frame times
RenderBudget.Default.Check(3840, 2160);                         // throws when over budget

using EffectsSpace.Media;

AviSource video = AviSource.Read(aviBytes);                  // MJPEG AVI, optional PCM
ReadOnlyMemory<byte> jpeg = video.FrameData(video.FrameAt(0.5));
PcmSource audio = WaveFile.Read(wavBytes);
float left = audio.Sample(0.25, channel: 0);

var mixer = new AudioMixer(project, composition, quality: AudioResamplingQuality.BandLimited);
var stereo = new float[4096 * 2];
mixer.Mix(startTime: 0, firstFrame: 0, stereo, sampleRate: 48000);
byte[] wave = await WaveRenderer.RenderAsync(mixer, 0, 2, WaveEncoding.Pcm24,
    dither: true, cancellationToken: cancellationToken);

using EffectsSpace.Editing;
using EffectsSpace.Skia;
using SkiaSharp;

var project = SampleProject.Create();
var composition = project.Compositions[0];

using var compositor = new SkiaCompositor { Typeface = SKTypeface.Default };
byte[] png = new FrameExporter(compositor).Png(project, composition, time: 2.4, width: 960);
byte[] avi = await new AviExporter(compositor).ExportAsync(project, composition, width: 960);

using var surface = SKSurface.Create(new SKImageInfo(composition.Width, composition.Height));
compositor.Render(surface.Canvas, project, composition, time: 2.4, includeGuides: false);

using EffectsSpace.Controls;

var opacity = new NumericField("Opacity", 100) { Minimum = 0, Maximum = 100 };
opacity.ValueChanging += value => Preview(value);
opacity.EditCompleted += Commit;

var panel = new StudioPanel();
panel.AddTab("Properties", Studio.Row(Studio.Text("Opacity"), opacity));
panel.AddTab("Actions", new StudioButton("Render", () => Render(), IconKind.Render));
window.Content = panel;   // your Uno Window

using EffectsSpace.Editing;
using EffectsSpace.Viewer;

var session = new EditorSession(SampleProject.Create());
var viewer = new CompositionView(session) { Tool = ViewerTool.Select, ShowGrid = true };
viewer.Error += message => Console.Error.WriteLine(message);
window.Content = viewer;                     // your Uno Window
viewer.Loaded += (_, _) => viewer.Fit();
window.Closed += (_, _) => viewer.Dispose();

using EffectsSpace.Editing;
using EffectsSpace.Timeline;

var session = new EditorSession(SampleProject.Create());
var timeline = new TimelineView(session);
timeline.Error += message => Console.Error.WriteLine(message);
window.Content = timeline;                   // your Uno Window
timeline.Loaded += (_, _) => timeline.Fit();

timeline.RevealProperty("Opacity");           // expand and scroll to a property
timeline.GraphMode = true;                    // curve editor
timeline.GraphKind = GraphKind.Velocity;

using EffectsSpace.Controls;
using EffectsSpace.Documents;
using EffectsSpace.Editing;
using EffectsSpace.Workbench;

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
    var window = new Window { Title = "EffectsSpace" };
    IWorkspaceStorage storage = new MyWorkspaceStorage();   // your platform implementation
    var workbench = new StudioWorkbench(new EditorSession(SampleProject.Create()), storage);
    workbench.Viewer.Renderer.Typeface = Studio.Typeface;
    window.Content = workbench;
    window.Closed += (_, _) => workbench.Dispose();
    window.Activate();
}