Processing + resolume + spout

Introduction

This tutorial guides you through the process of creating a plugin for Resolume and connecting it with Processing using Spout. This setup is particularly useful for VJs and multimedia artists looking to integrate real-time graphics into their performances. Note that this method does not work on Mac; for Mac users, Syphon is the alternative, though the specifics are outside the scope of this tutorial.

Step 1: Setting Up Your Environment

To start, you'll need to ensure you have the necessary software and libraries installed.

• Download and Install Processing: Go to the Processing website and download the latest version for your OS.
• Install Resolume: Download Resolume from the official website and install it.
• Download Spout: Get Spout from the Spout GitHub repository and follow the installation instructions.
• Download Spout for Processing: Visit Spout for Processing GitHub and clone or download the repository.

Step 2: Setting Up Your Plugin in Resolume

Now, you need to configure Resolume to accept inputs from Processing.

1. Open Resolume: Launch the Resolume application.
2. Create a New Composition: Set up a new composition by going to File > New.
3. Add a New Layer: Click on the "+" button to add a layer where your Processing output will be displayed.
4. Configure Spout Input:
   • Go to the "Sources" panel.
   • Click on the "Spout" option to add it as a source.
   • Ensure that your Spout server is running and ready to receive input.

Step 3: Writing the Processing Code

Next, you will write some code in Processing to send visuals to Resolume.

1. Open Processing: Launch the Processing IDE.
2. Create a New Sketch: Start a new project.
3. Import Spout Library: Include the Spout library by adding the following line at the beginning of your sketch:

   import spout.*;
   

4. Set Up Spout:
   • Create a Spout object:

   Spout spout;
   

   • Initialize Spout in the setup() function:

   void setup() {
       size(800, 600); // Set your desired window size
       spout = new Spout();
       spout.setName("Processing Output");
   }
   

5. Draw Something: In the draw() function, create visuals:

   void draw() {
       background(0); // Clear the background
       fill(255, 0, 0); // Set fill color to red
       ellipse(mouseX, mouseY, 50, 50); // Draw an ellipse based on mouse position
       spout.send(); // Send the frame to Resolume
   }
   

Step 4: Running Your Setup

With everything set up, it's time to run your applications.

1. Run Your Processing Sketch: Click on the "Run" button in Processing. You should see your visuals being generated.
2. Check Resolume: Go back to Resolume and ensure that your Spout source is receiving the visuals from Processing. You should see your Processing output in the layer you created.

Conclusion

You have successfully created a plugin in Resolume that connects with Processing via Spout. This setup allows for dynamic visuals that can enhance your multimedia performances.

Key Takeaways

• Ensure all necessary software is installed.
• Properly configure Resolume to accept Spout inputs.
• Write and run Processing code to generate and send visuals.

Next Steps

• Experiment with different shapes, colors, and interactions in Processing.
• Explore additional features of Spout and Resolume to enhance your visuals.
• If you are a Mac user, consider researching Syphon as an alternative for similar functionality.