Last week (20.-26.5.) was pretty big for Schéma, so I thought a writeup would be appropriate while it’s still fresh. I’ll delve deeper into some of the additions in upcoming posts.
The VVVV community of Berlin has organized yet another one of their meetups. It’s an opportunity to present VVVV related work and spend a nice evvvvening with everyone.
After missing a few of these I finally managed to get on a bus to Berlin, implement Browser Favorites and present the current state of Schéma:
I’d like to point to the last slide of the presentation that covered some things I thought I’d be doing in the near future, like few weeks maybe.
If you were watching some of Schéma’s social channels, you might have noticed that I was arranging for Schéma to be installed permanently in the Prague based Ankali club.
While testing reactions were overwhelmingly positive and a preview version was already installed, there were still few key features missing – preventing Schéma from driving the local light installation efficiently. But still, on Wednesday evening I have received a call that they would like to use Schéma for the upcoming weekend – the club’s 2nd anniversary.
Stakes high, the clock was ticking.
I started the day by some minor fixes and then modifying Stack retention to use one file per Stack in a folder structure based on the category. While using a single file has worked well enough until this point, it was becoming increasingly clear that managing and distributing Stacks contained within an ever growing XML file is going to be a nightmare. While maybe not entirely necessary for the weekend I knew it would come back to haunt me if I ignored it for now.
What was definitely needed though was the Layer support – allowing behavior Stacks to be exchanged piecewise. This would allow setting up a stable base Layer containing, for instance, MIDI mapped faders for each group and freely exchange higher Layers to modify the actual animations.
To support this usecase I also needed to add a Pick.Group block. These along with some minor additions and fixes have kept me busy well into the evening. That was it for the day.
On Friday the update had to be ready and deployed, but there was still plenty missing.
For one, Schéma had to support multipixel fixtures – as the plan was to install Showtec Sunstrips all over the place. While the support was there internally since the beginning – being heavily employed in the 6000 RGB pixel heavy Chapeau Rouge installation – there was no way to edit fixture pixels via the UI. This was now badly needed though, so the fixture mapping could be set up in a reasonable time and with enough flexibility.
Racing with time I decided that it will be sufficient to implement this via keyboard shortcuts and sure enough, before noon I could add/remove pixels in a straight line and rotate them around each of the 3 axis – exactly what was needed to map arbitrary Sunstrip chains the upcoming evening.
For better feedback of pixel animations I also threw in a pixel preview element, displayed only for the root Block as not to waste too much resources.
Next I added a new Duration aspect along with a visualiser for it and Speed. With these ready I added support for 3 channel strobe fixtures ala the Atomic 3000 in 3 channel mode (intensity-duration-rate).
I knew there was one key feature missing still, one that would allow users to go fairly crazy with MIDI mappings inside various Stacks but still be able to keep track of it all. This would have to wait though as it was time to leave for Ankali.
Remember Schéma runs on top of VL (and VVVV) where the runtime and development environments are one? This allows you to tweak the internals on the fly, wherever Schéma is deployed.
So after setting up the Fixtures in the software and helping to figure out some configuration of the lights themselves, I could not only get to showing the operators around the interface but also to implementing that last needed feature – Controller Overview – on the local machine with the MIDI surface attached.
I already had some foundation – a tool to create a 2D grid layout of any MIDI controller and assign the MIDI inputs. What I had to add now was label support for controller mappings along with a display that would combine the two (layout and labels) to form an always up to date Controller Overview.
Although the result was slightly rough around the edges and showing in a separate window, it certainly worked (and beat pen and paper or tape).
Now any mapping could be added or removed on the fly and the overview would automatically update.
During this session the floorplan rectangle and dots indicating groups for each fixture (without having to select them) were also added.
Still, I had to help the operators get to grips with all the new stuff and only at 1AM I was confident they could take over.
With the Ankali deployment behind me it was time to refocus on what was the main event of the weekend for me – the 1st Schéma workshop, aimed at light control and held at Vzletná.
I was planning to set up all the lights to be connected to one computer and share access to them via remote multi-user support.
However, with the Ankali push, this feature has been delayed. Since I had a fairly clear idea how I wanted to approach it, I still tried to cram it in – or at least the essentials: A new Remote Output module and a Source.Remote Block working as the receiver, leaving automatic Fixture discovery and synchronization for another time.
In some 3 hours I had the Remote Module in and working, phew! A Fixture’s output could be set to Remote, which would transform all its generated aspects into OSC Messages and send them over UDP to an address specified in a config file. All you had to do on the receiving end was to have a fixture with the same name, and then put in the Source.Remote Block wherever you saw fit. The block had an index property which allowed to choose who to receive from.
Now it was time to pack all the light toys on hand (DMX controlled pinspot, moving head and strobe, wireless ArtNet controlled WS2811 strips and OSC controlled LED chains) and go go go!
Getting this done meant I arrived with no time to spare and had to skip streaming for Day 1. For Day 2 it was ready and big thanks to the few who came to check it out. I’ll try to edit the 6 hour long recording into something more palatable and put it out.
Still I think, the Remote Module was well worth it – it proved to be super useful and fun. Ever dreamt of hosting a light control LAN party? Soon you might have the chance 🙂
Schéma used in a 3 computer setup. One (projected) is dealing with HW communication, generating its own behaviors while also receiving and merging signals from the other two, resulting in a server-client hieararchy. However the Remote module supports more P2P scenarios where everyone is sharing some lights as well.
Wrapping it up
Do you remember that slide from the beginning?
I thought the features will be in soon, but certainly not by the end of the week. Even though neither of them are in their most refined form yet I still think it’s a testament to the power of VL and a little motivation.
As for the last point – Release: During the workshop I learned that while Schéma is already quite powerful, it still requires more hand-holding during the first moments than I would call fitting for the first release. So I still need to put some work into making the setup easier and improving the documentation to make your first experience with Schéma a smooth one.
However, if you’re working on a time-sensitive project that could make good use of Schéma, please do let me know! Contact details are available at the bottom of the site.
Thanks for reading and until next time when we take a closer look at the Remote Module.
Throw a comment down below if you have any questions or suggestions.