Papaltine.FluxSDK.ResoniteLink 1.5.1-prerelease

Papaltine.FluxSDK.ResoniteLink

This package provides ResoniteLink integration for the Flux SDK. It allows you to build ProtoGraph modules and deploy them directly to a running Resonite session, as well as perform general automation tasks within Resonite from F#.

In Brief

• Connects to Resonite via WebSockets using the standard ResoniteLink protocol
• A high-level DSL (step { ... }) for sequencing Resonite actions without manually passing the LinkInterface around
• Compile ProtoGraph modules and deploy them to Resonite
• Full F# iteractive REPL support for rapid development and testing using scripts (.fsx files)
  • Access to Nuget packages and .NET libraries in your scripts
  • Also usable from full dotnet projects (.fsproj) for more complex tooling and integration scenarios

Installation

Install via NuGet:

dotnet add package Papaltine.FluxSDK.ResoniteLink

Getting Started

Initialize Connection

open System.Threading
open FluxSDK.ResoniteLink

// Connect to local Resonite instance
let link = Link.initialize ("ws://localhost:6984", CancellationToken.None)

Define and Run Steps

A Step<'T> is an asynchronous operation that acts on the LinkInterface. You can combine them using the step { ... } builder.

open ResoniteLink

// Define a step to create a new empty slot
let createSlot : Step<unit> =
    step {
        // Create a slot under the root slot
        let! response =
            Reso.slot (ID = "MyNewSlot", Name = "Hello Resonite!") [] []
            |> Reso.addSlotUnder Slot.ROOT_SLOT_ID

        if response.Success then
            printfn "Slot created successfully!"
        else
            printfn $"Failed to create slot: {response.ErrorInfo}"
    }

// Execute the step
createSlot |> Link.runStep link

Building and Linking ProtoGraph Modules

open FluxSDK.Build.Pipeline
open FluxSDK.Types.Project

// Cache of compiled modules
let stores = Build.initializeStores "Path/To/FrooxDll"

let deployModule (projectManifest: ProjectManifest) (modulePath: string) =
    step {
        // Reset for fresh unique ID generation
        ElementID.setEpoch (DateTime.UtcNow.Ticks |> uint64) |> ignore
        
        let config = Build.defaultConfig projectManifest

        match Build.compileModule stores config modulePath with
        | Stage.Success(nodeData, logs) ->

            // You might query this from Resonite first using RPath or use a known ID
            let parentSlotId = "TargetSlotID"

            // The library handles converting the graph into a batch of create operations
            let! batchResult =
                Link.batchAddProtoGraphNodes (config, parentSlotId, dict [], dict [], nodeData)

            if batchResult.Success then
                 printfn $"Deployed {modulePath} to Resonite!"
            else
                 printfn $"Deployment failed: {batchResult.ErrorInfo}"

        | _ -> printfn "Build failed"
    }

// Execute the deployment step
deployModule myManifest "MyFlux/MyCalculator" |> Link.runStep link