disguise developers

Designer Plugins

Plugins for Disguise Designer software.

Add Video Layer at current track time

tCurrent_value = LocalState.localState().currentTransport.player.tCurrent
state.track.addNewLayer(VariableVideoModule, tCurrent_value, 60, 'Video');

Split track at current track time

tCurrent_value = LocalState.localState().currentTransport.player.tCurrent
state.track.splitSectionAtBeat(tCurrent_value);

Add a projector & set it’s resolution to 4K

projector = resourceManager.loadOrCreate('objects/projector/myprojector.apx', Projector)
projector.resolution = Vec2(3840, 2160)

Add and configure an OSC device

# Create OSC device using resource manager
osc = resourceManager.loadOrCreate('objects/OscDevice/PluginMonitor.apx', OscDevice)

# Configure OSC device
osc.sendIPAddress = '127.0.0.1'  # IP where the plugin is running
osc.sendPort = {port}  # Port where our plugin is listening
osc.receivePort = {port} + 1  # Use next port for Designer to listen

# Add the device to devices array if not already there
device_exists = False
for device in state.devices.devices:
    if device.path == osc.path:
        device_exists = True
        break
if not device_exists:
    state.devices.devices.append(osc)
    print("Added OSC device to state.devices")

# Start the device if not already started
if not osc.started:
    osc.start()

List all resources of a type

resourceManager.allResources(OscDevice)

Set ExpressionVariable to a value

# Find our device
existing_devices = resourceManager.allResources(ExpressionVariablesDevice)
for device in existing_devices:
    if device.path == 'objects/ExpressionVariablesDevice/PluginVariable.apx':
        for var in device.container.variables:
            if var.name == 'plugin_value':
                var.defaultFloat = {value}
                print("Updated plugin_value to %f" % {value})
                break

Create a 5x5 grid of LED screens with rainbow keyframes

def createOddEvenLEDScreenGrid(nXScreens, nYScreens, screen_size, screen_gap):
    
    screen_offset = screen_size + 2*screen_gap
    
    x_offset = (nXScreens/2)*screen_offset - screen_offset/2
    y_offset = screen_size/2
    
    mapping_even_path = 'objects/directprojection/even_screens_direct.apx'
    mapping_even = resourceManager.loadOrCreate(mapping_even_path, DirectProjection)
    
    mapping_odd_path = 'objects/directprojection/odd_screens_direct.apx'
    mapping_odd = resourceManager.loadOrCreate(mapping_odd_path, DirectProjection)
    
    for i in range(nYScreens):
        for j in range (nXScreens):
            new_resource = resourceManager.loadOrCreate(
                'objects/ledscreen/ledscreen_{idx}.apx'.format(
                    idx=i*nYScreens + j ), LedScreen)

            new_resource.scale = Vec(screen_size, screen_size, 0)
            new_resource.offset = Vec(-x_offset + screen_offset*j, y_offset + screen_offset*i, 0)
            new_resource.resolution = Vec(1920, 1080)
            
            if i % 2 == 0:
                mapping_even.screens.append(new_resource)
            else:
                mapping_odd.screens.append(new_resource)
            
    return [mapping_even_path, mapping_odd_path]

def createVideoLayer(layer_name, start_time_seconds, length_seconds):
    return state.track.addNewLayer(VariableVideoModule, start_time_seconds, length_seconds, layer_name) 

def makeSineWaveKeyFrame(layer, field, initial_value, offset_value):
    import math
    layer.fields[field].disableSequencing = False
    for i in range(1, 60):
        layer.fields[field].sequence.setFloat(i, offset_value + initial_value*math.sin(math.pi*((5 - (i % 10) )/5.0)))
    
if __name__ == '__main__':
    
    mapping_paths = createOddEvenLEDScreenGrid(5, 5, 5, 0.5)
    
    layer_1 = createVideoLayer('layer_1', 0, 60)
    layer_1.fields[10].sequence.setString(0, 'objects/videoclip/sample/george.jpg.apx')
    layer_1.fields[2].sequence.setString(0, mapping_paths[0])
    
    layer_2 = createVideoLayer('layer_2', 0, 60)
    layer_2.fields[10].sequence.setString(0, 'objects/videoclip/sample/ada.jpg.apx')
    layer_2.fields[2].sequence.setString(0, mapping_paths[1])
    
    makeSineWaveKeyFrame(layer_1, 20, 360, 0) # Hue
    makeSineWaveKeyFrame(layer_1, 36, 1, 1) # Size
    makeSineWaveKeyFrame(layer_1, 41, 90, 0) # Rotation
    
    makeSineWaveKeyFrame(layer_2, 20, -360, 0) # Hue
    makeSineWaveKeyFrame(layer_2, 36, 1, 1) # Size
    makeSineWaveKeyFrame(layer_2, 41, -90, 0) # Rotation

Locate all feed rectangles

import json

feed_scenes = resourceManager.allResources(FeedScene)
output = []

for scene in feed_scenes:
    scene_info = {
        "Scene UID": str(scene.uid),
        "FeedRects": []
    }
    
    if hasattr(scene, "feedRects"):
        for rect in scene.feedRects:
            rect_info = {
                "FeedRect UID": str(rect.uid),
                "Local Position and Size": str(rect.rect) if hasattr(rect, "rect") else "Not found",
                "Screen Position and Size": str(rect.screenRect) if hasattr(rect, "screenRect") else "Not found",
                "Output Rectangle": str(rect.outputRect) if hasattr(rect, "outputRect") else "Not found"
            }

            # Reference Display Extraction
            if hasattr(rect, "referenceDisplay"):
                ref_disp = rect.referenceDisplay
                ref_info = {
                    "Reference Display": str(ref_disp),
                    "uid": str(ref_disp.uid) if hasattr(ref_disp, "uid") else "Unknown",
                    "path": str(ref_disp.path) if hasattr(ref_disp, "path") else "Unknown"
                }
                if hasattr(ref_disp, "parent"):
                    parent = ref_disp.parent
                    ref_info["Parent UID"] = str(parent.uid) if hasattr(parent, "uid") else "Unknown"
                    ref_info["Parent Path"] = str(parent.path) if hasattr(parent, "path") else "Unknown"
                rect_info["Reference Display Info"] = ref_info

            # Display Target Extraction
            if hasattr(rect, "displayTarget"):
                disp_target = rect.displayTarget
                disp_info = {
                    "Display Target": str(disp_target),
                    "uid": str(disp_target.uid) if hasattr(disp_target, "uid") else "Unknown"
                }
                rect_info["Display Target Info"] = disp_info

            scene_info["FeedRects"].append(rect_info)

    output.append(scene_info)

print(json.dumps(output, indent=4))