OutWit.Controller.Render 1.15.3

OutWit.Controller.Render

Distributed rendering controller for OmnibusCloud. Current scope is a frame-based .blend rendering flow using Blender CLI across multiple compute nodes, with first-release engine-family support for Cycles, Eevee / Eevee Next, and Grease Pencil.

The upstream neutral DCC scene import/build boundary now lives in the separate host-only OutWit.Controller.Render.Dcc controller so this controller can remain focused on prepared .blend validation, preflight, rendering, collection, and encoding.

Benchmark assets

Canonical benchmark assets for node-side render benchmarks live under @Prerequisites/benchmark/render/ so the exact same .blend files can be versioned and packaged for every machine.

Maintainer regeneration scripts live under Controllers/Render/OutWit.Controller.Render/benchmarks/:

• create_benchmark_still.py
• create_benchmark_video.py

Those scripts are only for regenerating the canonical committed assets. Runtime and client benchmark execution must use the bundled canonical benchmark files, not locally generated ad-hoc files.

Features

Activities

Variable Types

Public Script API

Bundled scripts are the primary public API surface of the render controller. The final v1 contract is:

Output conventions

Blob-backed prepared-scene render scripts

Typed-scene render scripts

Diagnostics and preflight scripts

Scripts

RenderFrames — Distributes animation frames across nodes from a blob-backed prepared scene reference:

Job:RenderFrames(RenderSceneRef:scene, Int:startFrame, Int:endFrame, RenderOptions:options)
{
    Blob:blend = Render.BuildBlendFromRefs(scene);
    RenderTaskCollection:tasks = Render.Split(blend, startFrame, endFrame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    BlobCollection:result = Render.Collect(rendered, options);
}

RenderStill — Renders one frame from a blob-backed prepared scene reference and returns one final still image blob:

Job:RenderStill(RenderSceneRef:scene, Int:frame, RenderOptions:options)
{
    Blob:blend = Render.BuildBlendFromRefs(scene);
    RenderTaskCollection:tasks = Render.Split(blend, frame, frame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    Blob:result = Render.CollectStill(rendered, options);
}

RenderSceneStillTiled — Bootstrap typed-scene tiled still flow with inline prepared .blend bytes:

Job:RenderSceneStillTiled(RenderScene:scene, Int:frame, Int:tilesX, Int:tilesY, RenderOptions:options, TileOptions:tileOptions)
{
    Blob:blend = Render.BuildBlend(scene);
    RenderTaskCollection:tasks = Render.SplitTiles(blend, frame, tilesX, tilesY, options, tileOptions);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    Blob:result = Render.CollectTiles(rendered, options, tileOptions);
}

RenderDccSceneStillTiled — Bootstrap tiled still flow directly from typed neutral DccSceneData:

Job:RenderDccSceneStillTiled(DccScene:scene, Int:frame, Int:tilesX, Int:tilesY, RenderOptions:options, TileOptions:tileOptions)
{
    Blob:blend = Render.BuildBlendFromDccScene(scene);
    Render.ClearScene(scene);
    RenderTaskCollection:tasks = Render.SplitTiles(blend, frame, tilesX, tilesY, options, tileOptions);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    Blob:result = Render.CollectTiles(rendered, options, tileOptions);
}

RenderDccSceneFrames — Bootstrap frame-range rendering directly from typed neutral DccSceneData:

Job:RenderDccSceneFrames(DccScene:scene, Int:startFrame, Int:endFrame, RenderOptions:options)
{
    Blob:blend = Render.BuildBlendFromDccScene(scene);
    Render.ClearScene(scene);
    RenderTaskCollection:tasks = Render.Split(blend, startFrame, endFrame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    BlobCollection:result = Render.Collect(rendered, options);
}

RenderDccSceneVideo — Bootstrap video rendering directly from typed neutral DccSceneData:

Job:RenderDccSceneVideo(DccScene:scene, Int:startFrame, Int:endFrame, RenderOptions:options, VideoOptions:video)
{
    Blob:blend = Render.BuildBlendFromDccScene(scene);
    Render.ClearScene(scene);
    RenderTaskCollection:tasks = Render.Split(blend, startFrame, endFrame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    BlobCollection:frames = Render.Collect(rendered, options);
    Blob:result = Render.EncodeVideo(frames, video);
}

RenderRuntimeDiagnostics — Returns packaged runtime/tool diagnostics for the current node:

Job:RenderRuntimeDiagnostics()
{
    RenderRuntimeDiagnostics:result = Render.RuntimeDiagnostics();
}

RenderBlenderVersion — Returns the packaged Blender version string:

Job:RenderBlenderVersion()
{
    String:result = Render.BlenderVersion();
}

RenderValidateBlend — Validates that a blob-backed prepared scene reference can be materialized and opened by the packaged Blender runtime:

Job:RenderValidateBlend(RenderSceneRef:scene)
{
    Blob:blend = Render.BuildBlendFromRefs(scene);
    String:result = Render.ValidateBlend(blend);
}

RenderPreflightStillTiled — Validates whether a tiled still request can run on the current packaged runtime and reports blocking issues:

Job:RenderPreflightStillTiled(Int:tilesX, Int:tilesY, RenderOptions:options, TileOptions:tileOptions)
{
    RenderPreflightStillTiled:result = Render.PreflightStillTiled(tilesX, tilesY, options, tileOptions);
}

RenderPreflightVideo — Validates whether a video render request can run on the current packaged runtime and reports blocking issues:

Job:RenderPreflightVideo(RenderOptions:options, VideoOptions:video)
{
    RenderPreflightVideo:result = Render.PreflightVideo(options, video);
}

RenderPreflightFrames — Validates whether a frame-range render request can run on the current packaged runtime and reports blocking issues:

Job:RenderPreflightFrames(Int:startFrame, Int:endFrame, RenderOptions:options)
{
    RenderPreflightFrames:result = Render.PreflightFrames(startFrame, endFrame, options);
}

RenderPreflightStill — Convenience single-frame preflight built on top of Render.PreflightFrames:

Job:RenderPreflightStill(Int:frame, RenderOptions:options)
{
    RenderPreflightFrames:result = Render.PreflightFrames(frame, frame, options);
}

RenderPreflight — Unified preflight contract that evaluates still, frame-range, tiled-still, and video readiness in one call:

Job:RenderPreflight(Int:frame, Int:startFrame, Int:endFrame, Int:tilesX, Int:tilesY, RenderOptions:options, TileOptions:tileOptions, VideoOptions:video)
{
    RenderPreflight:result = Render.Preflight(frame, startFrame, endFrame, tilesX, tilesY, options, tileOptions, video);
}

RenderSceneStillTiledLarge — Bootstrap typed-scene tiled still flow with blob-backed prepared .blend references:

Job:RenderSceneStillTiledLarge(RenderSceneRef:scene, Int:frame, Int:tilesX, Int:tilesY, RenderOptions:options, TileOptions:tileOptions)
{
    Blob:blend = Render.BuildBlendFromRefs(scene);
    RenderTaskCollection:tasks = Render.SplitTiles(blend, frame, tilesX, tilesY, options, tileOptions);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    Blob:result = Render.CollectTiles(rendered, options, tileOptions);
}

RenderStillTiled — Splits one still frame from a blob-backed prepared scene reference into tiles and stitches the rendered tiles back into one image:

Job:RenderStillTiled(RenderSceneRef:scene, Int:frame, Int:tilesX, Int:tilesY, RenderOptions:options, TileOptions:tileOptions)
{
    Blob:blend = Render.BuildBlendFromRefs(scene);
    RenderTaskCollection:tasks = Render.SplitTiles(blend, frame, tilesX, tilesY, options, tileOptions);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    Blob:result = Render.CollectTiles(rendered, options, tileOptions);
}

RenderSceneStill — Bootstrap typed-scene still flow with inline prepared .blend bytes:

Job:RenderSceneStill(RenderScene:scene, Int:frame, RenderOptions:options)
{
    Blob:blend = Render.BuildBlend(scene);
    RenderTaskCollection:tasks = Render.Split(blend, frame, frame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    Blob:result = Render.CollectStill(rendered, options);
}

RenderSceneStillLarge — Bootstrap typed-scene still flow with blob-backed prepared .blend references:

Job:RenderSceneStillLarge(RenderSceneRef:scene, Int:frame, RenderOptions:options)
{
    Blob:blend = Render.BuildBlendFromRefs(scene);
    RenderTaskCollection:tasks = Render.Split(blend, frame, frame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    Blob:result = Render.CollectStill(rendered, options);
}

RenderSceneFrames — Bootstrap typed-scene animation flow with inline prepared .blend bytes:

Job:RenderSceneFrames(RenderScene:scene, Int:startFrame, Int:endFrame, RenderOptions:options)
{
    Blob:blend = Render.BuildBlend(scene);
    RenderTaskCollection:tasks = Render.Split(blend, startFrame, endFrame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    BlobCollection:result = Render.Collect(rendered, options);
}

RenderSceneFramesLarge — Bootstrap typed-scene animation flow with blob-backed prepared .blend references:

Job:RenderSceneFramesLarge(RenderSceneRef:scene, Int:startFrame, Int:endFrame, RenderOptions:options)
{
    Blob:blend = Render.BuildBlendFromRefs(scene);
    RenderTaskCollection:tasks = Render.Split(blend, startFrame, endFrame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    BlobCollection:result = Render.Collect(rendered, options);
}

RenderVideo — Renders an animation from a blob-backed prepared scene reference and encodes the ordered frame sequence into MP4:

Job:RenderVideo(RenderSceneRef:scene, Int:startFrame, Int:endFrame, RenderOptions:options, VideoOptions:video)
{
    Blob:blend = Render.BuildBlendFromRefs(scene);
    RenderTaskCollection:tasks = Render.Split(blend, startFrame, endFrame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    BlobCollection:frames = Render.Collect(rendered, options);
    Blob:result = Render.EncodeVideo(frames, video);
}

RenderSceneVideo — Bootstrap typed-scene video flow with inline prepared .blend bytes:

Job:RenderSceneVideo(RenderScene:scene, Int:startFrame, Int:endFrame, RenderOptions:options, VideoOptions:video)
{
    Blob:blend = Render.BuildBlend(scene);
    RenderTaskCollection:tasks = Render.Split(blend, startFrame, endFrame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    BlobCollection:frames = Render.Collect(rendered, options);
    Blob:result = Render.EncodeVideo(frames, video);
}

RenderSceneVideoLarge — Bootstrap typed-scene video flow with blob-backed prepared .blend references:

Job:RenderSceneVideoLarge(RenderSceneRef:scene, Int:startFrame, Int:endFrame, RenderOptions:options, VideoOptions:video)
{
    Blob:blend = Render.BuildBlendFromRefs(scene);
    RenderTaskCollection:tasks = Render.Split(blend, startFrame, endFrame, options);
    RenderResultCollection:rendered = Grid.ForEach(task in tasks)
        => Render.Frame(task);
    BlobCollection:frames = Render.Collect(rendered, options);
    Blob:result = Render.EncodeVideo(frames, video);
}

Dependencies

• Variables — Blob type, Int, IntCollection
• Grid — Grid.ForEach for distributed execution

Blender Integration

The controller expects portable Blender runtimes inside the blender/ subdirectory of the controller module and portable ffmpeg runtimes inside the ffmpeg/ subdirectory. The package currently carries platform-specific subdirectories and resolves the active runtime automatically.

The packaged controller manifest now records explicit archive compatibility conditions for each supported runtime target:

• win-x64 + windows + x64
• linux-x64 + linux + x64
• osx-arm64 + macos + arm64

For the current tiled-still slice, tile collection is fail-fast:

• tile bounds must form a complete rectangular grid over the full [0..1] x [0..1] frame area
• tile image dimensions must match the expected rendered tile size after overlap expansion
• overlap stitching supports two modes:
  • CenterPriorityCrop — overlap regions are rendered, then cropped back to each tile's logical core area before overlay
  • AlphaBlend — overlap regions are feather-blended with normalized weight accumulation in managed RGBA composition before encoding the final image

Supported Platforms

• Windows x64 (blender.exe)
• Linux x64 (blender)
• macOS ARM64 (Blender.app)

Cross-Platform Path Resolution

The BlenderRunner utility uses RenderBinaryResolver to resolve the active runtime from the packaged blender/<rid>/... layout.