Last Week Recap

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.

Wednesday

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.

Thursday

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.

 

Friday

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.

The Weekend

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.